linqx 0.2.1 → 0.3.3

package/dist/linqx.d.ts

@@ -1,36 +0,0 @@
-declare module './linq.js' {
-    type IEnumerable<T> = Enumerable.IEnumerable<T>;
-    namespace Enumerable {
-        interface IPageInfo {
-            pageNumber: number;
-            pageSize: number;
-        }
-        interface IndexedItem<T> {
-            index: number;
-            item: T;
-        }
-        interface PositionedItem<T> extends IndexedItem<T> {
-            isFirst: boolean;
-            isLast: boolean;
-        }
-        interface ItemWithNeighbors<T> {
-            prev: T | null;
-            item: T;
-            next: T | null;
-        }
-        const prototype: any;
-        interface IEnumerable<T> {
-            whereIf(flag: boolean | string | undefined | null, filter: (t: T) => boolean): IEnumerable<T>;
-            page(pageNumber: number, pageSize: number): IEnumerable<T>;
-            page(info: IPageInfo): IEnumerable<T>;
-            joinWith(separator: string): string;
-            joinWith<T>(this: IEnumerable<T>, separator: (t: T) => T): IEnumerable<T>;
-            toMap<K, V>(keySelector: (element: T) => K, valueSelector: (element: T) => V): Map<K, V>;
-            chunk(size: number): IEnumerable<T[]>;
-            index(): IEnumerable<IndexedItem<T>>;
-            position(): IEnumerable<PositionedItem<T>>;
-            withNeighbors(): IEnumerable<ItemWithNeighbors<T>>;
-        }
-    }
-}
-export {};

package/dist/linqx.js

@@ -1,153 +0,0 @@
-import { Enumerable } from "./linq.js";
-Enumerable.prototype.whereIf = function (flag, filter) {
-    return flag ? this.where(filter) : this;
-};
-function page(...args) {
-    let number = 0;
-    let size = 0;
-    if (args.length === 1) {
-        const info = args[0];
-        number = info.pageNumber;
-        size = info.pageSize;
-    }
-    else {
-        number = args[0];
-        size = args[1];
-    }
-    return this.skip((number - 1) * size).take(size);
-}
-Enumerable.prototype.page = page;
-Enumerable.prototype.map = function (selector) {
-    return this.select(selector).toArray();
-};
-function joinWith(separator) {
-    if (typeof separator === 'string') {
-        return this.toArray().join(separator);
-    }
-    return Enumerable.from(joinWithIterator(this, separator));
-    function* joinWithIterator(enumerable, sep) {
-        for (const { index, item, isFirst, isLast } of enumerable.position()) {
-            yield item;
-            if (!isLast) {
-                yield sep(item);
-            }
-        }
-    }
-}
-Enumerable.prototype.joinWith = joinWith;
-Enumerable.prototype.toMap = function (keySelector, valueSelector) {
-    const map = new Map();
-    for (const m of this) {
-        const k = keySelector(m);
-        const v = valueSelector(m);
-        map.set(k, v);
-    }
-    return map;
-};
-function* chunkIterator(enumerable, size) {
-    const e = enumerable.getEnumerator();
-    // Before allocating anything, make sure there's at least one element.
-    if (e.moveNext()) {
-        // Now that we know we have at least one item, allocate an initial storage array. This is not
-        // the array we'll yield.  It starts out small in order to avoid significantly overallocating
-        // when the source has many fewer elements than the chunk size.
-        let arraySize = Math.min(size, 4);
-        let i;
-        do {
-            const array = new Array(arraySize);
-            // Store the first item.
-            array[0] = e.current();
-            i = 1;
-            if (size != array.length) {
-                // This is the first chunk. As we fill the array, grow it as needed.
-                for (; i < size && e.moveNext(); i++) {
-                    if (i >= array.length) {
-                        arraySize = Math.min(size, 2 * array.length);
-                        resize(array, arraySize);
-                    }
-                    array[i] = e.current();
-                }
-            }
-            else {
-                // For all but the first chunk, the array will already be correctly sized.
-                // We can just store into it until either it's full or MoveNext returns false.
-                const local = array; // avoid bounds checks by using cached local (`array` is lifted to iterator object as a field)
-                for (; i < local.length && e.moveNext(); i++) {
-                    local[i] = e.current();
-                }
-            }
-            if (i != array.length) {
-                resize(array, i);
-            }
-            yield array;
-        } while (i >= size && e.moveNext());
-    }
-}
-Enumerable.prototype.chunk = function (size) {
-    if (size < 1)
-        throw new Error('size cannot be less than 1');
-    const e = chunkIterator(this, size);
-    return Enumerable.from(e);
-};
-function* positionIterator(enumerable) {
-    const e = enumerable.getEnumerator();
-    if (!e.moveNext()) {
-        return;
-    }
-    let i = 0;
-    let current = e.current();
-    while (e.moveNext()) {
-        yield {
-            index: i,
-            item: current,
-            isFirst: i === 0,
-            isLast: false
-        };
-        current = e.current();
-        ++i;
-    }
-    yield {
-        index: i,
-        item: current,
-        isFirst: i === 0,
-        isLast: true
-    };
-}
-Enumerable.prototype.position = function () {
-    const e = positionIterator(this);
-    return Enumerable.from(e);
-};
-Enumerable.prototype.index = function () {
-    const e = positionIterator(this);
-    return this.select((m, i) => ({ index: i, item: m }));
-};
-function* withNeighborsIterator(enumerable) {
-    const e = enumerable.getEnumerator();
-    if (!e.moveNext()) {
-        return;
-    }
-    let previous = null;
-    let current = e.current();
-    while (e.moveNext()) {
-        const next = e.current();
-        yield { prev: previous, item: current, next: next };
-        previous = current;
-        current = next;
-    }
-    yield { prev: previous, item: current, next: null };
-}
-Enumerable.prototype.withNeighbors = function () {
-    const e = withNeighborsIterator(this);
-    return Enumerable.from(e);
-};
-function resize(array, newSize) {
-    const oldSize = array.length;
-    if (newSize > oldSize) {
-        array.length = newSize;
-        array.fill(undefined, oldSize, newSize);
-    }
-    else if (newSize < oldSize) {
-        array.length = newSize;
-    }
-}
-;