@aidc-toolkit/utility 1.0.25-beta → 1.0.27-beta

package/src/sequence.ts

@@ -5,32 +5,32 @@ export class Sequence implements Iterable<bigint> {
     /**
      * Start value (inclusive).
      */
-    private readonly _startValue: bigint;
+    readonly #startValue: bigint;
 
     /**
      * End value (exclusive).
      */
-    private readonly _endValue: bigint;
+    readonly #endValue: bigint;
 
     /**
      * Count of values.
      */
-    private readonly _count: number;
+    readonly #count: number;
 
     /**
      * Delta to the next value; equal to the sign of the count.
      */
-    private readonly _nextDelta: 1n | -1n;
+    readonly #nextDelta: 1n | -1n;
 
     /**
      * Minimum value (inclusive).
      */
-    private readonly _minimumValue: bigint;
+    readonly #minimumValue: bigint;
 
     /**
      * Maximum value (inclusive).
      */
-    private readonly _maximumValue: bigint;
+    readonly #maximumValue: bigint;
 
     /**
      * Constructor.
@@ -43,18 +43,18 @@ export class Sequence implements Iterable<bigint> {
      * start value.
      */
     constructor(startValue: number | bigint, count: number) {
-        this._startValue = BigInt(startValue);
-        this._endValue = this._startValue + BigInt(count);
-        this._count = count;
+        this.#startValue = BigInt(startValue);
+        this.#endValue = this.#startValue + BigInt(count);
+        this.#count = count;
 
         if (count >= 0) {
-            this._nextDelta = 1n;
-            this._minimumValue = this._startValue;
-            this._maximumValue = this._endValue - 1n;
+            this.#nextDelta = 1n;
+            this.#minimumValue = this.#startValue;
+            this.#maximumValue = this.#endValue - 1n;
         } else {
-            this._nextDelta = -1n;
-            this._minimumValue = this._endValue + 1n;
-            this._maximumValue = this._startValue;
+            this.#nextDelta = -1n;
+            this.#minimumValue = this.#endValue + 1n;
+            this.#maximumValue = this.#startValue;
         }
     }
 
@@ -62,35 +62,35 @@ export class Sequence implements Iterable<bigint> {
      * Get the start value (inclusive).
      */
     get startValue(): bigint {
-        return this._startValue;
+        return this.#startValue;
     }
 
     /**
      * Get the end value (exclusive).
      */
     get endValue(): bigint {
-        return this._endValue;
+        return this.#endValue;
     }
 
     /**
      * Get the count of values.
      */
     get count(): number {
-        return this._count;
+        return this.#count;
     }
 
     /**
      * Get the minimum value (inclusive).
      */
     get minimumValue(): bigint {
-        return this._minimumValue;
+        return this.#minimumValue;
     }
 
     /**
      * Get the maximum value (inclusive).
      */
     get maximumValue(): bigint {
-        return this._maximumValue;
+        return this.#maximumValue;
     }
 
     /**
@@ -100,7 +100,7 @@ export class Sequence implements Iterable<bigint> {
      * Next value in sequence.
      */
     * [Symbol.iterator](): Generator<bigint> {
-        for (let value = this._startValue; value !== this._endValue; value += this._nextDelta) {
+        for (let value = this.#startValue; value !== this.#endValue; value += this.#nextDelta) {
             yield value;
         }
     }

package/src/transformer.ts

@@ -1,6 +1,6 @@
-import { type IndexedCallback, mapIterable } from "./iterable-utility";
-import { i18nextUtility } from "./locale/i18n";
-import { Sequence } from "./sequence";
+import { type IndexedCallback, mapIterable } from "./iterable-utility.js";
+import { i18nextUtility } from "./locale/i18n.js";
+import { Sequence } from "./sequence.js";
 
 /**
  * Transformer primitive type.
@@ -54,12 +54,12 @@ export abstract class Transformer {
     /**
      * Transformers cache, mapping a domain to another map, which maps an optional tweak to a transformer.
      */
-    private static readonly TRANSFORMER_MAPS_MAP = new Map<bigint, Map<bigint | undefined, Transformer>>();
+    static readonly #TRANSFORMER_MAPS_MAP = new Map<bigint, Map<bigint | undefined, Transformer>>();
 
     /**
      * Domain.
      */
-    private readonly _domain: bigint;
+    readonly #domain: bigint;
 
     /**
      * Constructor.
@@ -68,9 +68,9 @@ export abstract class Transformer {
      * Domain.
      */
     constructor(domain: number | bigint) {
-        this._domain = BigInt(domain);
+        this.#domain = BigInt(domain);
 
-        if (this._domain <= 0n) {
+        if (this.#domain <= 0n) {
             throw new RangeError(i18nextUtility.t("Transformer.domainMustBeGreaterThanZero", {
                 domain
             }));
@@ -95,11 +95,11 @@ export abstract class Transformer {
     static get(domain: number | bigint, tweak?: number | bigint): Transformer {
         const domainN = BigInt(domain);
 
-        let transformersMap = Transformer.TRANSFORMER_MAPS_MAP.get(domainN);
+        let transformersMap = Transformer.#TRANSFORMER_MAPS_MAP.get(domainN);
 
         if (transformersMap === undefined) {
             transformersMap = new Map();
-            Transformer.TRANSFORMER_MAPS_MAP.set(domainN, transformersMap);
+            Transformer.#TRANSFORMER_MAPS_MAP.set(domainN, transformersMap);
         }
 
         const tweakN = tweak === undefined ? undefined : BigInt(tweak);
@@ -118,7 +118,7 @@ export abstract class Transformer {
      * Get the domain.
      */
     get domain(): bigint {
-        return this._domain;
+        return this.#domain;
     }
 
     /**
@@ -127,7 +127,7 @@ export abstract class Transformer {
      * @param value
      * Value.
      */
-    private validate(value: bigint): void {
+    #validate(value: bigint): void {
         if (value < 0n) {
             throw new RangeError(i18nextUtility.t("Transformer.valueMustBeGreaterThanOrEqualToZero", {
                 value
@@ -162,10 +162,10 @@ export abstract class Transformer {
      * @returns
      * Transformed value.
      */
-    private validateDoForward(value: number | bigint): bigint {
+    #validateDoForward(value: number | bigint): bigint {
         const valueN = BigInt(value);
 
-        this.validate(valueN);
+        this.#validate(valueN);
 
         return this.doForward(valueN);
     }
@@ -185,8 +185,8 @@ export abstract class Transformer {
      * @returns
      * Transformed value.
      */
-    private validateDoForwardCallback<TOutput>(transformerCallback: IndexedCallback<bigint, TOutput>, value: number | bigint, index?: number): TOutput {
-        return transformerCallback(this.validateDoForward(value), index);
+    #validateDoForwardCallback<TOutput>(transformerCallback: IndexedCallback<bigint, TOutput>, value: number | bigint, index?: number): TOutput {
+        return transformerCallback(this.#validateDoForward(value), index);
     };
 
     /**
@@ -231,7 +231,7 @@ export abstract class Transformer {
         let result: bigint | TOutput | Iterable<bigint> | Iterable<TOutput>;
 
         if (typeof valueOrValues !== "object") {
-            result = transformerCallback === undefined ? this.validateDoForward(valueOrValues) : this.validateDoForwardCallback(transformerCallback, valueOrValues);
+            result = transformerCallback === undefined ? this.#validateDoForward(valueOrValues) : this.#validateDoForwardCallback(transformerCallback, valueOrValues);
         } else if (valueOrValues instanceof Sequence) {
             if (valueOrValues.minimumValue < 0n) {
                 throw new RangeError(i18nextUtility.t("Transformer.minimumValueMustBeGreaterThanOrEqualToZero", {
@@ -248,7 +248,7 @@ export abstract class Transformer {
 
             result = transformerCallback === undefined ? mapIterable(valueOrValues, value => this.doForward(value)) : mapIterable(valueOrValues, (value, index) => transformerCallback(this.doForward(value), index));
         } else {
-            result = transformerCallback === undefined ? mapIterable(valueOrValues, value => this.validateDoForward(value)) : mapIterable(valueOrValues, (value, index) => this.validateDoForwardCallback(transformerCallback, value, index));
+            result = transformerCallback === undefined ? mapIterable(valueOrValues, value => this.#validateDoForward(value)) : mapIterable(valueOrValues, (value, index) => this.#validateDoForwardCallback(transformerCallback, value, index));
         }
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled above.
@@ -278,7 +278,7 @@ export abstract class Transformer {
     reverse(transformedValue: number | bigint): bigint {
         const transformedValueN = BigInt(transformedValue);
 
-        this.validate(transformedValueN);
+        this.#validate(transformedValueN);
 
         return this.doReverse(transformedValueN);
     }
@@ -328,41 +328,41 @@ export class EncryptionTransformer extends Transformer {
     /**
      * Individual bits, pre-calculated for performance.
      */
-    private static readonly BITS = new Uint8Array([
+    static readonly #BITS = new Uint8Array([
         0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
     ]);
 
     /**
      * Inverse individual bits, pre-calculated for performance.
      */
-    private static readonly INVERSE_BITS = new Uint8Array([
+    static readonly #INVERSE_BITS = new Uint8Array([
         0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F
     ]);
 
     /**
      * Number of bytes covered by the domain.
      */
-    private readonly _domainBytes: number;
+    readonly #domainBytes: number;
 
     /**
      * Xor bytes array generated from the domain and tweak.
      */
-    private readonly _xorBytes: Uint8Array;
+    readonly #xorBytes: Uint8Array;
 
     /**
      * Bits array generated from the domain and tweak.
      */
-    private readonly _bits: Uint8Array;
+    readonly #bits: Uint8Array;
 
     /**
      * Inverse bits array generated from the domain and tweak.
      */
-    private readonly _inverseBits: Uint8Array;
+    readonly #inverseBits: Uint8Array;
 
     /**
      * Number of rounds (length of arrays) generated from the domain and tweak.
      */
-    private readonly _rounds: number;
+    readonly #rounds: number;
 
     /**
      * Constructor.
@@ -389,7 +389,7 @@ export class EncryptionTransformer extends Transformer {
             domainBytes++;
         }
 
-        this._domainBytes = domainBytes;
+        this.#domainBytes = domainBytes;
 
         const xorBytes = new Array<number>();
         const bits = new Array<number>();
@@ -404,29 +404,29 @@ export class EncryptionTransformer extends Transformer {
             const bitNumber = Number(BigInt.asUintN(3, reducedKey));
 
             // Bits are applied in reverse order so that they don't correlate directly with the key bytes at the same index.
-            bits.push(EncryptionTransformer.BITS[bitNumber]);
-            inverseBits.push(EncryptionTransformer.INVERSE_BITS[bitNumber]);
+            bits.push(EncryptionTransformer.#BITS[bitNumber]);
+            inverseBits.push(EncryptionTransformer.#INVERSE_BITS[bitNumber]);
         }
 
         // Domains occupying a single byte will not shuffle and will map all values to themselves for very small domains.
         if (domainBytes === 1) {
             // Determine the lowest possible mask that will cover all values in the domain.
-            const domainMask = EncryptionTransformer.BITS.filter(bit => bit < domain).reduce((accumulator, bit) => accumulator | bit, 0);
+            const domainMask = EncryptionTransformer.#BITS.filter(bit => bit < domain).reduce((accumulator, bit) => accumulator | bit, 0);
 
             // Reduce all xor bytes to a single byte and strip higher bits.
-            this._xorBytes = new Uint8Array([xorBytes.reduce((accumulator, xorByte) => accumulator ^ xorByte, 0) & domainMask]);
+            this.#xorBytes = new Uint8Array([xorBytes.reduce((accumulator, xorByte) => accumulator ^ xorByte, 0) & domainMask]);
 
             // Bits and inverse bits are irrelevant as there will be no shuffling; choose first bit arbitrarily.
-            this._bits = new Uint8Array([EncryptionTransformer.BITS[0]]);
-            this._inverseBits = new Uint8Array([EncryptionTransformer.INVERSE_BITS[0]]);
+            this.#bits = new Uint8Array([EncryptionTransformer.#BITS[0]]);
+            this.#inverseBits = new Uint8Array([EncryptionTransformer.#INVERSE_BITS[0]]);
 
             // Everything will be done in one round.
-            this._rounds = 1;
+            this.#rounds = 1;
         } else {
-            this._xorBytes = new Uint8Array(xorBytes);
-            this._bits = new Uint8Array(bits);
-            this._inverseBits = new Uint8Array(inverseBits);
-            this._rounds = xorBytes.length;
+            this.#xorBytes = new Uint8Array(xorBytes);
+            this.#bits = new Uint8Array(bits);
+            this.#inverseBits = new Uint8Array(inverseBits);
+            this.#rounds = xorBytes.length;
         }
     }
 
@@ -439,11 +439,11 @@ export class EncryptionTransformer extends Transformer {
      * @returns
      * Big-endian byte array equivalent to the value.
      */
-    private valueToBytes(value: bigint): Uint8Array {
-        const bytes = new Uint8Array(this._domainBytes);
+    #valueToBytes(value: bigint): Uint8Array {
+        const bytes = new Uint8Array(this.#domainBytes);
 
         // Build byte array in reverse order to get as big-endian.
-        for (let index = this._domainBytes - 1, reducedValue = value; index >= 0 && reducedValue !== 0n; index--, reducedValue >>= 8n) {
+        for (let index = this.#domainBytes - 1, reducedValue = value; index >= 0 && reducedValue !== 0n; index--, reducedValue >>= 8n) {
             bytes[index] = Number(BigInt.asUintN(8, reducedValue));
         }
 
@@ -459,7 +459,7 @@ export class EncryptionTransformer extends Transformer {
      * @returns
      * Value.
      */
-    private static bytesToValue(bytes: Uint8Array): bigint {
+    static #bytesToValue(bytes: Uint8Array): bigint {
         return bytes.reduce((accumulator, byte) => accumulator << 8n | BigInt(byte), 0n);
     }
 
@@ -493,7 +493,7 @@ export class EncryptionTransformer extends Transformer {
      * @returns
      * Shuffled byte array.
      */
-    private shuffle(bytes: Uint8Array, round: number, forward: boolean): Uint8Array {
+    #shuffle(bytes: Uint8Array, round: number, forward: boolean): Uint8Array {
         const bytesLength = bytes.length;
 
         const determinants = new Uint8Array(bytesLength);
@@ -501,7 +501,7 @@ export class EncryptionTransformer extends Transformer {
         const shuffleIndexes1 = new Array<number>();
         const shuffleIndexes0 = new Array<number>();
 
-        const bit = this._bits[round];
+        const bit = this.#bits[round];
 
         bytes.forEach((byte, index) => {
             const determinant = byte & bit;
@@ -512,7 +512,7 @@ export class EncryptionTransformer extends Transformer {
             (determinant !== 0 ? shuffleIndexes1 : shuffleIndexes0).push(index);
         });
 
-        const inverseBit = this._inverseBits[round];
+        const inverseBit = this.#inverseBits[round];
 
         const shuffleBytes = new Uint8Array(bytesLength);
 
@@ -560,8 +560,8 @@ export class EncryptionTransformer extends Transformer {
      * @returns
      * Xored byte array.
      */
-    private xor(bytes: Uint8Array, round: number, forward: boolean): Uint8Array {
-        let cumulativeXorByte = this._xorBytes[round];
+    #xor(bytes: Uint8Array, round: number, forward: boolean): Uint8Array {
+        let cumulativeXorByte = this.#xorBytes[round];
 
         return bytes.map((byte) => {
             const xorByte = byte ^ cumulativeXorByte;
@@ -576,17 +576,17 @@ export class EncryptionTransformer extends Transformer {
      * @inheritDoc
      */
     protected doForward(value: bigint): bigint {
-        let bytes = this.valueToBytes(value);
+        let bytes = this.#valueToBytes(value);
         let transformedValue: bigint;
 
         // Loop repeats until transformed value is within domain.
         do {
             // Forward operation is shuffle then xor for the number of rounds.
-            for (let round = 0; round < this._rounds; round++) {
-                bytes = this.xor(this.shuffle(bytes, round, true), round, true);
+            for (let round = 0; round < this.#rounds; round++) {
+                bytes = this.#xor(this.#shuffle(bytes, round, true), round, true);
             }
 
-            transformedValue = EncryptionTransformer.bytesToValue(bytes);
+            transformedValue = EncryptionTransformer.#bytesToValue(bytes);
         } while (transformedValue >= this.domain);
 
         return transformedValue;
@@ -596,17 +596,17 @@ export class EncryptionTransformer extends Transformer {
      * @inheritDoc
      */
     protected doReverse(transformedValue: bigint): bigint {
-        let bytes = this.valueToBytes(transformedValue);
+        let bytes = this.#valueToBytes(transformedValue);
         let value: bigint;
 
         // Loop repeats until value is within domain.
         do {
             // Reverse operation is xor then shuffle for the number of rounds in reverse.
-            for (let round = this._rounds - 1; round >= 0; round--) {
-                bytes = this.shuffle(this.xor(bytes, round, false), round, false);
+            for (let round = this.#rounds - 1; round >= 0; round--) {
+                bytes = this.#shuffle(this.#xor(bytes, round, false), round, false);
             }
 
-            value = EncryptionTransformer.bytesToValue(bytes);
+            value = EncryptionTransformer.#bytesToValue(bytes);
         } while (value >= this.domain);
 
         return value;

package/test/character-set.test.ts

@@ -13,7 +13,7 @@ import {
     NUMERIC_CREATOR,
     NUMERIC_VALIDATOR,
     Sequence
-} from "../src";
+} from "../src/index.js";
 
 // Type is used to ensure that testCharacterSet() is not called with creator twice.
 type ValidatorNotCreator<T extends CharacterSetValidator> = T extends CharacterSetCreator ? never : T;

package/test/record.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { RecordValidator } from "../src";
+import { RecordValidator } from "../src/index.js";
 
 describe("Record validator", () => {
     const StringIndexes = {

package/test/reg-exp.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { RegExpValidator } from "../src";
+import { RegExpValidator } from "../src/index.js";
 
 describe("Regular expression validator", () => {
     test("Validation", () => {

package/test/sequence.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { Sequence } from "../src";
+import { Sequence } from "../src/index.js";
 
 describe("Sequence", () => {
     const sequence1 = new Sequence(10, 20);

package/test/setup.ts

@@ -1,4 +1,4 @@
 import { I18nEnvironments } from "@aidc-toolkit/core";
-import { i18nUtilityInit } from "../src";
+import { i18nUtilityInit } from "../src/index.js";
 
 await i18nUtilityInit(I18nEnvironments.CLI);

package/test/transformer.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { EncryptionTransformer, IdentityTransformer, Sequence, Transformer } from "../src";
+import { EncryptionTransformer, IdentityTransformer, Sequence, Transformer } from "../src/index.js";
 
 function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
     const transformer = Transformer.get(domain, tweak);
@@ -120,11 +120,6 @@ describe("Encryption", () => {
     });
 
     test("Byte boundary", () => {
-        expect((Transformer.get(256n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(1);
-        expect((Transformer.get(257n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
-        expect((Transformer.get(65536n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
-        expect((Transformer.get(65537n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(3);
-
         testTransformer(256, 1);
         testTransformer(257, 1);
     });

package/tsconfig-config.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "files": ["./eslint.config.ts", "./tsup.config.ts", "vitest.config.ts"]
+}

package/tsconfig-src.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "include": ["./src/**/*"],
+  "compilerOptions": {
+    // Emit.
+    "outDir": "dist"
+  }
+}

package/tsconfig-test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "include": ["./test/**/*"],
+  "references": [
+    {
+      "path": "./tsconfig-src.json"
+    }
+  ]
+}

package/tsconfig.json

@@ -1,3 +1,14 @@
 {
-  "extends": "@aidc-toolkit/dev/tsconfig.json"
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig-src.json"
+    },
+    {
+      "path": "./tsconfig-test.json"
+    },
+    {
+      "path": "./tsconfig-config.json"
+    }
+  ]
 }

package/tsup.config.ts

@@ -1,3 +1,4 @@
-import { tsupConfigAIDCToolkit } from "@aidc-toolkit/dev";
+import { tsupConfig } from "@aidc-toolkit/dev";
+import { defineConfig } from "tsup";
 
-export default tsupConfigAIDCToolkit;
+export default defineConfig(tsupConfig);