@aidc-toolkit/utility 0.9.16-beta → 0.9.18-beta

package/test/character-set.test.ts

@@ -1,20 +1,27 @@
 import { I18NEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import {
-    ALPHABETIC_CREATOR,
-    ALPHANUMERIC_CREATOR,
-    CharacterSetCreator,
+    ALPHABETIC_CREATOR, ALPHABETIC_VALIDATOR,
+    ALPHANUMERIC_CREATOR, ALPHANUMERIC_VALIDATOR,
+    CharacterSetCreator, type CharacterSetValidator,
     Exclusion,
-    HEXADECIMAL_CREATOR,
+    HEXADECIMAL_CREATOR, HEXADECIMAL_VALIDATOR,
     i18nUtilityInit,
-    NUMERIC_CREATOR,
+    NUMERIC_CREATOR, NUMERIC_VALIDATOR,
     Sequence
-} from "../src/index.js";
+} from "../src";
 
 await i18nUtilityInit(I18NEnvironment.CLI);
 
-function testCharacterSetCreator(name: string, characterSetCreator: CharacterSetCreator, characterSetSize: number, length: number, excludeFirstZero: boolean, excludeAllNumeric: boolean): void {
+// Type is used to ensure that testCharacterSet() is not called with creator twice.
+type ValidatorNotCreator<T extends CharacterSetValidator> = T extends CharacterSetCreator ? never : T;
+
+function testCharacterSet<T extends CharacterSetValidator>(name: string, characterSetCreator: CharacterSetCreator, characterSetValidator: ValidatorNotCreator<T>, characterSetSize: number, length: number, excludeFirstZero: boolean, excludeAllNumeric: boolean): void {
     describe(name, () => {
+        test("Validator is creator", () => {
+            expect(characterSetValidator).toBe(characterSetCreator);
+        });
+
         test("Character set", () => {
             characterSetCreator.characterSet.forEach((c, index) => {
                 expect(c).not.toBeUndefined();
@@ -65,37 +72,40 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
                     break;
             }
 
-            const sequence = Iterator.from(characterSetCreator.create(length, new Sequence(0n, domain), exclusion));
+            const sequence = characterSetCreator.create(length, new Sequence(0n, domain), exclusion);
 
             let previousS = "";
 
-            let sequenceCount = 0;
+            let index = 0;
 
-            sequence.forEach((s, index) => {
+            for (const s of sequence) {
                 expect(s > previousS).toBe(true);
                 previousS = s;
 
                 expect(s.length).toBe(length);
 
+                expect(() => {
+                    characterSetValidator.validate(s);
+                }).not.toThrow(RangeError);
                 expect(characterSetCreator.valueFor(s, exclusion)).toBe(BigInt(index));
 
-                sequenceCount++;
-            });
+                index++;
+            }
 
-            expect(sequenceCount).toBe(domain);
+            expect(index).toBe(domain);
 
             expect(() => characterSetCreator.create(length, domain, exclusion)).toThrow(`Value ${domain} must be less than ${domain}`);
 
-            const sparseSequence = Iterator.from(characterSetCreator.create(length, new Sequence(domain - 1, -domain), exclusion, 123456n));
+            const sparseSequence = characterSetCreator.create(length, new Sequence(domain - 1, -domain), exclusion, 123456n);
 
             let sequential = true;
             previousS = "~";
 
             const sequenceSet = new Set<string>();
 
-            sequenceCount = 0;
+            index = 0;
 
-            sparseSequence.forEach((s, index) => {
+            for (const s of sparseSequence) {
                 sequential &&= s < previousS;
                 previousS = s;
 
@@ -104,13 +114,16 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
                 expect(sequenceSet.has(s)).toBe(false);
                 sequenceSet.add(s);
 
+                expect(() => {
+                    characterSetValidator.validate(s);
+                }).not.toThrow(RangeError);
                 expect(characterSetCreator.valueFor(s, exclusion, 123456n)).toBe(BigInt(domain - index - 1));
 
-                sequenceCount++;
-            });
+                index++;
+            }
 
             expect(sequential).toBe(false);
-            expect(sequenceCount).toBe(domain);
+            expect(index).toBe(domain);
 
             const randomValues = new Array<bigint>();
             const straightRandomValues = new Array<string>();
@@ -137,12 +150,18 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
             expect(() => characterSetCreator.create(41, 0)).toThrow("Length 41 must be less than or equal to 40");
         });
 
-        test("Create sequence", () => {
+        test("Create sequence", {
+            // Test can take a moderate amount of time.
+            timeout: 10 * 1000
+        }, () => {
             testCreate(Exclusion.None);
         });
 
         if (excludeFirstZero) {
-            test("Create sequence, exclude first zero", () => {
+            test("Create sequence, exclude first zero", {
+                // Test can take a moderate amount of time.
+                timeout: 10 * 1000
+            }, () => {
                 testCreate(Exclusion.FirstZero);
 
                 expect(() => characterSetCreator.valueFor("0000", Exclusion.FirstZero)).toThrow("Invalid character '0' at position 1");
@@ -151,7 +170,10 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
         }
 
         if (excludeAllNumeric) {
-            test("Create sequence, exclude all numeric", () => {
+            test("Create sequence, exclude all numeric", {
+                // Test can take a moderate amount of time.
+                timeout: 10 * 1000
+            }, () => {
                 testCreate(Exclusion.AllNumeric);
 
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Nine is known to be present in the character set.
@@ -189,12 +211,15 @@ describe("Exclusion", () => {
     });
 });
 
-testCharacterSetCreator("Numeric", NUMERIC_CREATOR, 10, 4, true, false);
-testCharacterSetCreator("Hexadecimal", HEXADECIMAL_CREATOR, 16, 4, true, true);
-testCharacterSetCreator("Alphabetic", ALPHABETIC_CREATOR, 26, 3, false, false);
-testCharacterSetCreator("Alphanumeric", ALPHANUMERIC_CREATOR, 36, 3, true, true);
-testCharacterSetCreator("Middle numeric", new CharacterSetCreator([
+testCharacterSet("Numeric", NUMERIC_CREATOR, NUMERIC_VALIDATOR, 10, 4, true, false);
+testCharacterSet("Hexadecimal", HEXADECIMAL_CREATOR, HEXADECIMAL_VALIDATOR, 16, 4, true, true);
+testCharacterSet("Alphabetic", ALPHABETIC_CREATOR, ALPHABETIC_VALIDATOR, 26, 3, false, false);
+testCharacterSet("Alphanumeric", ALPHANUMERIC_CREATOR, ALPHANUMERIC_VALIDATOR, 36, 3, true, true);
+
+const middleNumericCreator = new CharacterSetCreator([
     "(", ")",
     "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
     "<", ">"
-], Exclusion.AllNumeric), 14, 4, false, true);
+], Exclusion.AllNumeric);
+
+testCharacterSet("Middle numeric", middleNumericCreator, middleNumericCreator as CharacterSetValidator, 14, 4, false, true);

package/test/record.test.ts

@@ -1,6 +1,6 @@
 import { I18NEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
-import { i18nUtilityInit, RecordValidator } from "../src/index.js";
+import { i18nUtilityInit, RecordValidator } from "../src";
 
 await i18nUtilityInit(I18NEnvironment.CLI);
 

package/test/reg-exp.test.ts

@@ -1,6 +1,6 @@
 import { I18NEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
-import { i18nUtilityInit, RegExpValidator } from "../src/index.js";
+import { i18nUtilityInit, RegExpValidator } from "../src";
 
 await i18nUtilityInit(I18NEnvironment.CLI);
 

package/test/sequence.test.ts

@@ -1,6 +1,6 @@
 import { I18NEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
-import { i18nUtilityInit, Sequence } from "../src/index.js";
+import { i18nUtilityInit, Sequence } from "../src";
 
 await i18nUtilityInit(I18NEnvironment.CLI);
 
@@ -29,7 +29,7 @@ describe("Sequence", () => {
         expectedValue = 10n;
         count = 0;
 
-        for (const value of Iterator.from(sequence1)) {
+        for (const value of sequence1) {
             expect(value).toBe(expectedValue);
 
             expectedValue++;
@@ -41,7 +41,7 @@ describe("Sequence", () => {
         expectedValue = 29n;
         count = 0;
 
-        for (const value of Iterator.from(sequence2)) {
+        for (const value of sequence2) {
             expect(value).toBe(expectedValue);
 
             expectedValue--;

package/test/transformer.test.ts

@@ -1,6 +1,6 @@
 import { I18NEnvironment } from "@aidc-toolkit/core";
-import { describe, expect, test } from "vitest";
-import { EncryptionTransformer, i18nUtilityInit, IdentityTransformer, Sequence, Transformer } from "../src/index.js";
+import { afterEach, describe, expect, test } from "vitest";
+import { EncryptionTransformer, i18nUtilityInit, IdentityTransformer, Sequence, Transformer } from "../src";
 
 await i18nUtilityInit(I18NEnvironment.CLI);
 
@@ -11,22 +11,24 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
 
     const transformedValuesSet = new Set<bigint>();
 
-    Iterator.from(transformer.forward(new Sequence(0n, domain))).forEach((transformedValue, index) => {
-        const indexN = BigInt(index);
+    let index = 0n;
 
-        if (sequential && transformedValue !== indexN) {
+    for (const transformedValue of transformer.forward(new Sequence(0n, domain))) {
+        if (sequential && transformedValue !== index) {
             sequential = false;
         }
 
         expect(transformedValuesSet.has(transformedValue)).toBe(false);
-        expect(transformer.reverse(transformedValue)).toBe(indexN);
+        expect(transformer.reverse(transformedValue)).toBe(index);
 
         transformedValuesSet.add(transformedValue);
 
         if (callback !== undefined) {
-            callback(indexN, transformedValue);
+            callback(index, transformedValue);
         }
-    });
+
+        index++;
+    }
 
     expect(sequential).toBe(tweak === undefined);
 
@@ -50,6 +52,12 @@ function testTransformer(domain: number, tweak?: number, callback?: (value: bigi
     expect(() => transformer.forward(new Sequence(-1, -1))).toThrow("Minimum value -1 must be greater than or equal to 0");
 }
 
+// TODO Remove when https://github.com/vitest-dev/vitest/discussions/6511 resolved.
+afterEach(async () => {
+    // eslint-disable-next-line promise/avoid-new -- Patch.
+    await new Promise(resolve => setImmediate(resolve));
+});
+
 describe("Identity", () => {
     test("Get", () => {
         const transformer = Transformer.get(1000);
@@ -57,7 +65,7 @@ describe("Identity", () => {
         expect(transformer instanceof IdentityTransformer).toBe(true);
         expect(Transformer.get(1000n)).toBe(transformer);
 
-        expect(transformer.domain).toBe(BigInt(1000n));
+        expect(transformer.domain).toBe(1000n);
     });
 
     test("Reversible", () => {
@@ -82,7 +90,7 @@ describe("Encryption", () => {
         expect(transformer instanceof EncryptionTransformer).toBe(true);
         expect(Transformer.get(1000n, 1234n)).toBe(transformer);
 
-        expect(transformer.domain).toBe(BigInt(1000n));
+        expect(transformer.domain).toBe(1000n);
 
         const transformer0 = Transformer.get(1000, 0);
 

package/typedoc.json

@@ -4,8 +4,6 @@
     "@aidc-toolkit/dev/typedoc.json"
   ],
   "name": "Utility",
-  "entryPoints": [
-    "src/index.ts"
-  ],
+  "tsconfig": "node_modules/@aidc-toolkit/dev/tsconfig-build-dev.json",
   "gitRevision": "main"
 }

package/utility.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>