@aidc-toolkit/utility 0.9.3 → 0.9.5

package/test/iterator_proxy.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, test } from "vitest";
+import { IteratorProxy } from "../src/index.js";
+
+const source: readonly string[] = [
+    "1", "2", "3", "4", "5"
+];
+
+function iterableSource(): Iterable<string> {
+    return [...source];
+}
+
+function arraySource(): string[] {
+    return [...source];
+}
+
+function iteratorSource(): Iterator<string> {
+    return [...source][Symbol.iterator]();
+}
+
+function * generatorSource(): Generator<string> {
+    for (const s of source) {
+        yield s;
+    }
+}
+
+function callbackSource(): string[] {
+    return [...source];
+}
+
+describe("Basic", () => {
+    function validateIterable(iterationSource: Iterator<string> | Iterable<string>): void {
+        const iteratorProxy = IteratorProxy.from(iterationSource);
+
+        expect(IteratorProxy.from(iteratorProxy)).toBe(iteratorProxy);
+
+        // @ts-expect-error -- Property exists.
+        expect(iteratorProxy["_initialIterable"]).toBe(iterationSource);
+
+        expect(Array.from(iteratorProxy)).toStrictEqual(source);
+    }
+
+    test("Iterator proxy", () => {
+        expect(IteratorProxy).not.toBe(Iterator);
+    });
+
+    test("Iterable", () => {
+        validateIterable(iterableSource());
+    });
+
+    test("Array", () => {
+        validateIterable(arraySource());
+    });
+
+    test("Iterator", () => {
+        validateIterable(iteratorSource());
+    });
+
+    test("Generator", () => {
+        validateIterable(generatorSource());
+    });
+
+    test("Callback", () => {
+        validateIterable(callbackSource());
+    });
+});
+
+describe("Helpers", () => {
+    test("Map", () => {
+        let count = 0;
+
+        const mapIteratorProxy = IteratorProxy.from(source).map((element, index) => {
+            expect(Number(element)).toBe(index + 1);
+            expect(index).toBe(count++);
+
+            return -count;
+        });
+
+        expect(count).toBe(0);
+
+        let negativeCount = 0;
+
+        for (const element of mapIteratorProxy) {
+            expect(element).toBe(--negativeCount);
+        }
+
+        expect(count).toBe(source.length);
+    });
+
+    test("Flat map", () => {
+        let count = 0;
+
+        const flatMapIteratorProxy = IteratorProxy.from(source).flatMap((element, index) => {
+            expect(Number(element)).toBe(index + 1);
+            expect(index).toBe(count++);
+
+            return [count, -count];
+        });
+
+        expect(count).toBe(0);
+
+        let index = 0;
+
+        for (const element of flatMapIteratorProxy) {
+            const absoluteElement = Math.floor(index / 2) + 1;
+
+            expect(element).toBe(index % 2 === 0 ? absoluteElement : -absoluteElement);
+            index++;
+        }
+
+        expect(count).toBe(source.length);
+    });
+
+    test("Filter", () => {
+        let count = 0;
+
+        const filteredIterable = IteratorProxy.from(source).filter((element, index) => {
+            expect(Number(element)).toBe(index + 1);
+            expect(index).toBe(count++);
+
+            return Number(element) % 2 === 0;
+        });
+
+        expect(count).toBe(0);
+
+        let evenCount = 0;
+
+        for (const element of filteredIterable) {
+            const n = Number(element);
+
+            expect(n % 2).toBe(0);
+            expect(Math.floor((n - 1) / 2)).toBe(evenCount++);
+        }
+
+        expect(count).toBe(source.length);
+        expect(evenCount).toBe(Math.floor(source.length / 2));
+    });
+
+    test("Take", () => {
+        let count = 0;
+
+        for (const element of IteratorProxy.from(source).take(3)) {
+            expect(element).toBe(String(++count));
+        }
+
+        expect(count).toBe(3);
+
+        count = 0;
+
+        for (const element of IteratorProxy.from(source).take(source.length + 1)) {
+            expect(element).toBe(String(++count));
+        }
+
+        expect(count).toBe(source.length);
+
+        count = 0;
+
+        for (const element of IteratorProxy.from(source).take(0)) {
+            expect(element).toBe(String(++count));
+        }
+
+        expect(count).toBe(0);
+    });
+
+    test("Drop", () => {
+        let count = 0;
+
+        for (const element of IteratorProxy.from(source).drop(3)) {
+            expect(element).toBe(String(++count + 3));
+        }
+
+        expect(count).toBe(source.length - 3);
+
+        count = 0;
+
+        for (const element of IteratorProxy.from(source).drop(0)) {
+            expect(element).toBe(String(++count));
+        }
+
+        expect(count).toBe(source.length);
+
+        count = 0;
+
+        for (const element of IteratorProxy.from(source).drop(source.length)) {
+            expect(element).toBe(String(++count));
+        }
+
+        expect(count).toBe(0);
+    });
+
+    test("To array", () => {
+        const sourceToArray = IteratorProxy.from(source).toArray();
+
+        expect(sourceToArray).not.toBe(source);
+        expect(sourceToArray).toStrictEqual(source);
+    });
+
+    test("For each", () => {
+        let count = 0;
+
+        IteratorProxy.from(source).forEach((value, index) => {
+            expect(Number(value)).toBe(index + 1);
+            expect(index).toBe(count++);
+        });
+
+        expect(count).toBe(source.length);
+    });
+
+    test("Reduce no initial value", () => {
+        let count = 0;
+
+        expect(IteratorProxy.from(source).reduce((previousValue, currentValue, currentIndex) => {
+            expect(Number(currentValue)).toBe(currentIndex + 1);
+            expect(currentIndex - 1).toBe(count++);
+
+            return previousValue + currentValue;
+        })).toBe("".concat(...source));
+
+        expect(count).toBe(source.length - 1);
+
+        expect(() => IteratorProxy.from<string>([]).reduce(() => "")).toThrow("reduce() of empty iterator with no initial value");
+    });
+
+    test("Reduce initial value", () => {
+        let count = 0;
+
+        expect(IteratorProxy.from(source).reduce((previousValue, currentValue, currentIndex) => {
+            expect(Number(currentValue)).toBe(currentIndex + 1);
+            expect(currentIndex).toBe(count++);
+
+            return previousValue + currentValue;
+        }, "0")).toBe("0".concat(...source));
+
+        expect(count).toBe(source.length);
+
+        expect(IteratorProxy.from<string>([]).reduce(() => "", "0")).toBe("0");
+    });
+
+    test("Some", () => {
+        expect(IteratorProxy.from(source).some(value => value === "3")).toBe(true);
+        expect(IteratorProxy.from(source).some(value => value === "6")).toBe(false);
+    });
+
+    test("Every", () => {
+        expect(IteratorProxy.from(source).every(value => Number(value) > 0)).toBe(true);
+        expect(IteratorProxy.from(source).every(value => Number(value) < Number(source[source.length - 1]))).toBe(false);
+    });
+
+    test("Find", () => {
+        expect(IteratorProxy.from(source).find(value => Number(value) % 3 === 0)).toBe("3");
+        expect(IteratorProxy.from(source).find(value => Number(value) % 7 === 0)).toBeUndefined();
+    });
+});

package/test/record.test.ts

@@ -2,7 +2,7 @@ import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { RecordValidator } from "../src/index.js";
 
-await i18nInit(I18NEnvironment.CLI, true);
+await i18nInit(I18NEnvironment.CLI);
 
 describe("Record validator", () => {
     enum StringEnum {

package/test/reg_exp.test.ts

@@ -2,7 +2,7 @@ import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { RegExpValidator } from "../src/index.js";
 
-await i18nInit(I18NEnvironment.CLI, true);
+await i18nInit(I18NEnvironment.CLI);
 
 describe("Regular expression validator", () => {
     test("Validation", () => {

package/test/sequencer.test.ts

@@ -1,8 +1,8 @@
 import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
-import { Sequencer } from "../src/index.js";
+import { IteratorProxy, Sequencer } from "../src/index.js";
 
-await i18nInit(I18NEnvironment.CLI, true);
+await i18nInit(I18NEnvironment.CLI);
 
 describe("Sequence", () => {
     const sequencer1 = new Sequencer(10, 20);
@@ -29,7 +29,7 @@ describe("Sequence", () => {
         expectedValue = 10n;
         count = 0;
 
-        for (const value of Iterator.from(sequencer1)) {
+        for (const value of IteratorProxy.from(sequencer1)) {
             expect(value).toBe(expectedValue);
 
             expectedValue++;
@@ -41,7 +41,7 @@ describe("Sequence", () => {
         expectedValue = 29n;
         count = 0;
 
-        for (const value of Iterator.from(sequencer2)) {
+        for (const value of IteratorProxy.from(sequencer2)) {
             expect(value).toBe(expectedValue);
 
             expectedValue--;
@@ -60,7 +60,7 @@ describe("Sequence", () => {
 
         sequencer1.reset();
 
-        for (const value of Iterator.from(sequencer1)) {
+        for (const value of IteratorProxy.from(sequencer1)) {
             expect(value).toBe(expectedValue);
 
             expectedValue++;

package/test/transformer.test.ts

@@ -1,8 +1,8 @@
 import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
-import { EncryptionTransformer, IdentityTransformer, Sequencer, Transformer } from "../src/index.js";
+import { EncryptionTransformer, IdentityTransformer, IteratorProxy, Sequencer, Transformer } from "../src/index.js";
 
-await i18nInit(I18NEnvironment.CLI, true);
+await i18nInit(I18NEnvironment.CLI);
 
 function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
     const transformer = Transformer.get(domain, tweak);
@@ -11,7 +11,7 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
 
     const transformedValuesSet = new Set<bigint>();
 
-    Iterator.from(transformer.forward(new Sequencer(0n, domain))).forEach((transformedValue, index) => {
+    IteratorProxy.from(transformer.forward(new Sequencer(0n, domain))).forEach((transformedValue, index) => {
         const indexN = BigInt(index);
 
         if (sequential && transformedValue !== indexN) {

package/.github/workflows/npm-publish.yml

@@ -1,38 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-      - run: npm ci
-      # This is necessary to work around platform-specific optional dependencies bug (https://github.com/npm/cli/issues/4828).
-      # - run: npm i @rollup/rollup-linux-x64-gnu
-      # "vitest run" fails with:
-      # Error: failed to resolve "extends":"@aidc-toolkit/dev/tsconfig.json" in /home/runner/work/utility/utility/tsconfig.json
-      # Caused by: Error: Cannot find module '@aidc-toolkit/dev/tsconfig.json/tsconfig.json'
-      # - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.idea/runConfigurations/build_dev.xml

@@ -1,12 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="build-dev" type="js.build_tools.npm" nameIsGenerated="true">
-    <package-json value="$PROJECT_DIR$/package.json" />
-    <command value="run" />
-    <scripts>
-      <script value="build-dev" />
-    </scripts>
-    <node-interpreter value="project" />
-    <envs />
-    <method v="2" />
-  </configuration>
-</component>