Socket
Socket
Sign inDemoInstall

@mathigon/core

Package Overview
Dependencies
Maintainers
1
Versions
62
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@mathigon/core - npm Package Compare versions

Comparing version 1.1.8 to 1.1.9

115

dist/index.cjs.js

@@ -27,3 +27,2 @@ "use strict";

EventTarget: () => EventTarget,
Itarray: () => Itarray,
LinkedList: () => LinkedList,

@@ -35,2 +34,3 @@ autoCorrect: () => autoCorrect,

chunk: () => chunk,
concat: () => concat,
cumulative: () => cumulative,

@@ -42,2 +42,3 @@ deepExtend: () => deepExtend,

every: () => every,
filter: () => filter,
findMin: () => findMin,

@@ -55,2 +56,3 @@ first: () => first,

loop: () => loop,
map: () => map,
pairs: () => pairs,

@@ -666,2 +668,6 @@ repeat: () => repeat,

}
function* concat(...sets) {
for (const set of sets)
yield* set;
}
function every(set, callback) {

@@ -681,5 +687,20 @@ for (const s of set) {

}
function* flatMap(set, map) {
function* filter(set, test) {
let i = 0;
for (const s of set) {
for (const x of map(s)) {
if (test(s, i))
yield s;
i += 1;
}
}
function* map(set, fn) {
let i = 0;
for (const s of set) {
yield fn(s, i);
i += 1;
}
}
function* flatMap(set, map2) {
for (const s of set) {
for (const x of map2(s)) {
yield x;

@@ -718,90 +739,2 @@ }

}
var Itarray = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
//# sourceMappingURL=index.cjs.js.map

115

dist/index.esm.js

@@ -588,2 +588,6 @@ // src/utilities.ts

}
function* concat(...sets) {
for (const set of sets)
yield* set;
}
function every(set, callback) {

@@ -603,5 +607,20 @@ for (const s of set) {

}
function* flatMap(set, map) {
function* filter(set, test) {
let i = 0;
for (const s of set) {
for (const x of map(s)) {
if (test(s, i))
yield s;
i += 1;
}
}
function* map(set, fn) {
let i = 0;
for (const s of set) {
yield fn(s, i);
i += 1;
}
}
function* flatMap(set, map2) {
for (const s of set) {
for (const x of map2(s)) {
yield x;

@@ -640,90 +659,2 @@ }

}
var Itarray = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
export {

@@ -734,3 +665,2 @@ BinarySearchType,

EventTarget,
Itarray,
LinkedList,

@@ -742,2 +672,3 @@ autoCorrect,

chunk,
concat,
cumulative,

@@ -749,2 +680,3 @@ deepExtend,

every,
filter,
findMin,

@@ -762,2 +694,3 @@ first,

loop,
map,
pairs,

@@ -764,0 +697,0 @@ repeat,

18

dist/iterable.d.ts
export declare function first<T>(set: Iterable<T>): T | undefined;
/** Iterator version of Array.concat(). */
export declare function concat<T>(...sets: Array<Iterable<T>>): Iterable<T>;
export declare function every<T>(set: Iterable<T>, callback: (v: T) => unknown): boolean;
export declare function some<T>(set: Iterable<T>, callback: (v: T) => unknown): boolean;
/** Iterator version of Array.filter(). */
export declare function filter<T>(set: Iterable<T>, test: (v: T, i: number) => unknown): Iterable<T>;
/** Iterator version of Array.map(). */
export declare function map<T, S>(set: Iterable<T>, fn: (v: T, i: number) => S): Iterable<S>;
export declare function flatMap<S, T>(set: Iterable<T>, map: (x: T) => Iterable<S>): Generator<S, void, unknown>;

@@ -9,13 +15,1 @@ export declare function pairs<S, T>(a: Iterable<S>, b: Iterable<T>): Iterable<[S, T]>;

export declare function findMin<T>(items: Iterable<T>, value: (item: T) => number, max?: number, min?: number): T | undefined;
export declare class Itarray<T> implements Iterable<T> {
private readonly values;
constructor(...values: Array<Iterable<T>>);
map<S>(fn: (t: T, i: number) => S): Itarray<S>;
every(fn: (t: T, i: number) => boolean): boolean;
some(fn: (t: T, i: number) => boolean): boolean;
slice(from: number, to?: number): Itarray<T>;
filter(fn: (t: T, i: number) => unknown): Itarray<T>;
concat(newValues: Iterable<T>): void;
[Symbol.iterator](): Generator<T, void, unknown>;
static make<T>(fn: (i: number) => T, max?: number): Itarray<T>;
}

2

package.json
{
"name": "@mathigon/core",
"version": "1.1.8",
"version": "1.1.9",
"license": "MIT",

@@ -5,0 +5,0 @@ "homepage": "https://mathigon.io/core",

121

src/iterable.ts
// =============================================================================
// Core.ts | Iterable Array Functions
// Core.ts | Iterator Functions
// (c) Mathigon

@@ -11,2 +11,7 @@ // =============================================================================

/** Iterator version of Array.concat(). */
export function* concat<T>(...sets: Array<Iterable<T>>): Iterable<T> {
for (const set of sets) yield* set;
}
export function every<T>(set: Iterable<T>, callback: (v: T) => unknown): boolean {

@@ -26,2 +31,20 @@ for (const s of set) {

/** Iterator version of Array.filter(). */
export function* filter<T>(set: Iterable<T>, test: (v: T, i: number) => unknown): Iterable<T> {
let i = 0;
for (const s of set) {
if (test(s, i)) yield s;
i += 1;
}
}
/** Iterator version of Array.map(). */
export function* map<T, S>(set: Iterable<T>, fn: (v: T, i: number) => S): Iterable<S> {
let i = 0;
for (const s of set) {
yield fn(s, i);
i += 1;
}
}
export function* flatMap<S, T>(set: Iterable<T>, map: (x: T) => Iterable<S>) {

@@ -68,97 +91,1 @@ for (const s of set) {

}
export class Itarray<T> implements Iterable<T> {
private readonly values: Array<Iterable<T>>;
constructor(...values: Array<Iterable<T>>) {
this.values = values;
}
map<S>(fn: (t: T, i: number) => S) {
const values = this.values;
return new Itarray<S>((function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
})());
}
every(fn: (t: T, i: number) => boolean) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i)) return false;
i += 1;
}
}
return true;
}
some(fn: (t: T, i: number) => boolean) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i)) return true;
i += 1;
}
}
return false;
}
slice(from: number, to?: number) {
const values = this.values;
return new Itarray<T>((function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || (to !== undefined && i > from + to)) continue;
yield v;
i += 1;
}
}
})());
}
filter(fn: (t: T, i: number) => unknown) {
const values = this.values;
return new Itarray<T>((function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i)) yield v;
i += 1;
}
}
})());
}
concat(newValues: Iterable<T>) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return (function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
})();
}
static make<T>(fn: (i: number) => T, max?: number) {
return new Itarray<T>((function* () {
let i = 0;
while (max === undefined || i < max) {
yield fn(i);
i += 1;
}
})());
}
}
test/itarray-test.ts
dist/index.cjs.js.map

Sorry, the diff of this file is not supported yet

dist/index.esm.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc