linqx 0.1.8

package/dist/linqx.d.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,153 @@
+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;
+    }
+}
+;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "linqx",
+  "author": "huoshan12345",
+  "description": "Modern fork of linq with more APIs",
+  "type": "module",
+  "version": "0.1.8",
+  "license": "MIT",
+  "homepage": "https://github.com/huoshan12345/linqx",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/huoshan12345/linqx.git"
+  },
+  "preferGlobal": false,
+  "keywords": [
+    "linq",
+    "linqx",
+    "linqjs",
+    "linqts"
+  ],
+  "engines": {
+    "node": "*"
+  },
+  "main": "dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "npm-run-all2": "^8.0.4",
+    "shx": "^0.4.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.4"
+  },
+  "scripts": {
+    "preinstall": "npx only-allow pnpm",
+    "clean": "shx rm -rf dist/** && shx rm -f *.tgz",
+    "copy": "shx cp linq.js dist && shx cp linq.d.ts dist",
+    "build": "run-s clean && tsc && run-s copy",
+    "type-check": "tsc --noEmit",
+    "test:ts": "run-s type-check && vitest run",
+    "test:js": "node test/testrunner.js",
+    "test": "run-p test:ts test:js"
+  }
+}