@aidc-toolkit/utility 1.0.26-beta → 1.0.28-beta

package/src/character-set.ts

@@ -42,7 +42,7 @@ export interface CharacterSetValidation extends StringValidation {
  * Character set validator. Validates a string against a specified character set.
  */
 export class CharacterSetValidator implements StringValidator<CharacterSetValidation> {
-    private static readonly NOT_ALL_NUMERIC_VALIDATOR = new class extends RegExpValidator {
+    static readonly #NOT_ALL_NUMERIC_VALIDATOR = new class extends RegExpValidator {
         /**
          * Create an error message for an all-numeric string.
          *
@@ -60,18 +60,18 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
     /**
      * Character set.
      */
-    private readonly _characterSet: readonly string[];
+    readonly #characterSet: readonly string[];
 
     /**
      * Character set map, mapping each character in the character set to its index such that
      * `_characterSetMap.get(_characterSet[index]) === index`.
      */
-    private readonly _characterSetMap: ReadonlyMap<string, number>;
+    readonly #characterSetMap: ReadonlyMap<string, number>;
 
     /**
      * Exclusions supported by the character set.
      */
-    private readonly _exclusionSupport: readonly Exclusion[];
+    readonly #exclusionSupport: readonly Exclusion[];
 
     /**
      * Constructor.
@@ -84,7 +84,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * Exclusions supported by the character set. All character sets implicitly support {@linkcode Exclusions.None}.
      */
     constructor(characterSet: readonly string[], ...exclusionSupport: readonly Exclusion[]) {
-        this._characterSet = characterSet;
+        this.#characterSet = characterSet;
 
         const characterSetMap = new Map<string, number>();
 
@@ -92,30 +92,30 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
             characterSetMap.set(c, index);
         });
 
-        this._characterSetMap = characterSetMap;
+        this.#characterSetMap = characterSetMap;
 
-        this._exclusionSupport = exclusionSupport;
+        this.#exclusionSupport = exclusionSupport;
     }
 
     /**
      * Get the character set.
      */
     get characterSet(): readonly string[] {
-        return this._characterSet;
+        return this.#characterSet;
     }
 
     /**
      * Get the character set size.
      */
     get characterSetSize(): number {
-        return this._characterSet.length;
+        return this.#characterSet.length;
     }
 
     /**
      * Get the exclusions supported by the character set.
      */
     get exclusionSupport(): readonly Exclusion[] {
-        return this._exclusionSupport;
+        return this.#exclusionSupport;
     }
 
     /**
@@ -128,7 +128,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * Character at the index.
      */
     character(index: number): string {
-        return this._characterSet[index];
+        return this.#characterSet[index];
     }
 
     /**
@@ -141,7 +141,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * Index for the character or undefined if the character is not in the character set.
      */
     characterIndex(c: string): number | undefined {
-        return this._characterSetMap.get(c);
+        return this.#characterSetMap.get(c);
     }
 
     /**
@@ -154,7 +154,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * Array of indexes for each character or undefined if the character is not in the character set.
      */
     characterIndexes(s: string): ReadonlyArray<number | undefined> {
-        return Array.from(s).map(c => this._characterSetMap.get(c));
+        return Array.from(s).map(c => this.#characterSetMap.get(c));
     }
 
     /**
@@ -167,7 +167,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * @returns
      * Component as a string or undefined.
      */
-    private static componentToString(component: string | (() => string) | undefined): string | undefined {
+    static #componentToString(component: string | (() => string) | undefined): string | undefined {
         return typeof component === "function" ? component() : component;
     }
 
@@ -178,7 +178,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
      * Exclusion.
      */
     protected validateExclusion(exclusion: Exclusion): void {
-        if (exclusion !== Exclusions.None && !this._exclusionSupport.includes(exclusion)) {
+        if (exclusion !== Exclusions.None && !this.#exclusionSupport.includes(exclusion)) {
             throw new RangeError(i18nextUtility.t("CharacterSetValidator.exclusionNotSupported", {
                 exclusion
             }));
@@ -206,13 +206,13 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
 
             if (maximumLength !== undefined && maximumLength === minimumLength) {
                 errorMessage = i18nextUtility.t(validation?.component === undefined ? "CharacterSetValidator.lengthMustBeEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeEqualTo", {
-                    component: CharacterSetValidator.componentToString(validation?.component),
+                    component: CharacterSetValidator.#componentToString(validation?.component),
                     length,
                     exactLength: minimumLength
                 });
             } else {
                 errorMessage = i18nextUtility.t(validation?.component === undefined ? "CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeGreaterThanOrEqualTo", {
-                    component: CharacterSetValidator.componentToString(validation?.component),
+                    component: CharacterSetValidator.#componentToString(validation?.component),
                     length,
                     minimumLength
                 });
@@ -223,7 +223,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
 
         if (maximumLength !== undefined && length > maximumLength) {
             throw new RangeError(i18nextUtility.t(validation?.component === undefined ? "CharacterSetValidator.lengthMustBeLessThanOrEqualTo" : "CharacterSetValidator.lengthOfComponentMustBeLessThanOrEqualTo", {
-                component: CharacterSetValidator.componentToString(validation?.component),
+                component: CharacterSetValidator.#componentToString(validation?.component),
                 length,
                 maximumLength
             }));
@@ -234,7 +234,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
 
         if (index !== -1) {
             throw new RangeError(i18nextUtility.t(validation?.component === undefined ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
-                component: CharacterSetValidator.componentToString(validation?.component),
+                component: CharacterSetValidator.#componentToString(validation?.component),
                 c: s.charAt(index),
                 position: index + (validation?.positionOffset ?? 0) + 1
             }));
@@ -250,7 +250,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
                 case Exclusions.FirstZero:
                     if (s.startsWith("0")) {
                         throw new RangeError(i18nextUtility.t(validation.component === undefined ? "CharacterSetValidator.invalidCharacterAtPosition" : "CharacterSetValidator.invalidCharacterAtPositionOfComponent", {
-                            component: CharacterSetValidator.componentToString(validation.component),
+                            component: CharacterSetValidator.#componentToString(validation.component),
                             c: "0",
                             position: (validation.positionOffset ?? 0) + 1
                         }));
@@ -258,7 +258,7 @@ export class CharacterSetValidator implements StringValidator<CharacterSetValida
                     break;
 
                 case Exclusions.AllNumeric:
-                    CharacterSetValidator.NOT_ALL_NUMERIC_VALIDATOR.validate(s);
+                    CharacterSetValidator.#NOT_ALL_NUMERIC_VALIDATOR.validate(s);
                     break;
             }
         }
@@ -277,7 +277,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
     /**
      * Powers of 10 from 1 (`10**0`) to `10**MAXIMUM_STRING_LENGTH`.
      */
-    private static readonly _powersOf10: readonly bigint[] = CharacterSetCreator.createPowersOf(10);
+    static #POWERS_OF_10?: readonly bigint[];
 
     /**
      * Create powers of a given base from 1 (`base**0`) to `base**MAXIMUM_STRING_LENGTH`.
@@ -288,7 +288,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * @returns
      * Array of powers of base.
      */
-    private static createPowersOf(base: number): readonly bigint[] {
+    static #createPowersOf(base: number): readonly bigint[] {
         const powersOf = new Array<bigint>(this.MAXIMUM_STRING_LENGTH + 1);
 
         const baseN = BigInt(base);
@@ -310,28 +310,31 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * `10**power`.
      */
     static powerOf10(power: number): bigint {
-        return this._powersOf10[power];
+        // Initialization is here due to order in which class is constructed causing errors reading undefined.
+        CharacterSetCreator.#POWERS_OF_10 ??= CharacterSetCreator.#createPowersOf(10);
+
+        return CharacterSetCreator.#POWERS_OF_10[power];
     }
 
     /**
      * Character set size as big integer, cached for performance purposes.
      */
-    private readonly _characterSetSizeN: bigint;
+    readonly #characterSetSizeN: bigint;
 
     /**
      * Character set size minus 1 as big integer, cached for performance purposes.
      */
-    private readonly _characterSetSizeMinusOneN: bigint;
+    readonly #characterSetSizeMinusOneN: bigint;
 
     /**
      * Domains for every length for every supported {@linkcode Exclusions}.
      */
-    private readonly _exclusionDomains: ReadonlyArray<readonly bigint[]>;
+    readonly #exclusionDomains: ReadonlyArray<readonly bigint[]>;
 
     /**
      * Values that would generate all zeros in the created string.
      */
-    private readonly _allZerosValues: readonly bigint[];
+    readonly #allZerosValues: readonly bigint[];
 
     /**
      * Constructor.
@@ -346,12 +349,12 @@ export class CharacterSetCreator extends CharacterSetValidator {
     constructor(characterSet: readonly string[], ...exclusionSupport: readonly Exclusion[]) {
         super(characterSet, ...exclusionSupport);
 
-        this._characterSetSizeN = BigInt(this.characterSetSize);
-        this._characterSetSizeMinusOneN = BigInt(this.characterSetSize - 1);
+        this.#characterSetSizeN = BigInt(this.characterSetSize);
+        this.#characterSetSizeMinusOneN = BigInt(this.characterSetSize - 1);
 
         const exclusionDomains: Array<readonly bigint[]> = [];
 
-        const exclusionNoneDomains = CharacterSetCreator.createPowersOf(this.characterSetSize);
+        const exclusionNoneDomains = CharacterSetCreator.#createPowersOf(this.characterSetSize);
 
         exclusionDomains[Exclusions.None] = exclusionNoneDomains;
 
@@ -367,7 +370,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
 
             for (let index = 1; index <= CharacterSetCreator.MAXIMUM_STRING_LENGTH; index++) {
                 // Domain excludes zero as the first character and so works with previous exclusion none domain.
-                exclusionFirstZeroDomains[index] = this._characterSetSizeMinusOneN * exclusionNoneDomains[index - 1];
+                exclusionFirstZeroDomains[index] = this.#characterSetSizeMinusOneN * exclusionNoneDomains[index - 1];
             }
 
             exclusionDomains[Exclusions.FirstZero] = exclusionFirstZeroDomains;
@@ -412,18 +415,18 @@ export class CharacterSetCreator extends CharacterSetValidator {
 
                 allZerosValues[index] = allZerosValue;
 
-                allZerosValue = allZerosValue * this._characterSetSizeN + zeroIndex;
+                allZerosValue = allZerosValue * this.#characterSetSizeN + zeroIndex;
             }
 
-            this._allZerosValues = allZerosValues;
+            this.#allZerosValues = allZerosValues;
 
             exclusionDomains[Exclusions.AllNumeric] = exclusionAllNumericDomains;
         } else {
             // Empty array obviates need for non-null assertion while still forcing error if indexed due to a bug.
-            this._allZerosValues = [];
+            this.#allZerosValues = [];
         }
 
-        this._exclusionDomains = exclusionDomains;
+        this.#exclusionDomains = exclusionDomains;
     }
 
     /**
@@ -435,8 +438,8 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * @returns
      * `characterSetSize**power`.
      */
-    private powerOfSize(power: number): bigint {
-        return this._exclusionDomains[Exclusions.None][power];
+    #powerOfSize(power: number): bigint {
+        return this.#exclusionDomains[Exclusions.None][power];
     }
 
     /**
@@ -454,7 +457,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * @returns
      * Shift required to skip all all-numeric strings.
      */
-    private allNumericShift(shiftForward: boolean, length: number, value: bigint): bigint {
+    #allNumericShift(shiftForward: boolean, length: number, value: bigint): bigint {
         let shift: bigint;
 
         if (length === 0) {
@@ -466,7 +469,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
             // Now dealing with individual characters; shift by 10 to skip numeric characters.
             shift = 10n;
         } else {
-            const powerOfSize = this.powerOfSize(length);
+            const powerOfSize = this.#powerOfSize(length);
             const powerOf10 = CharacterSetCreator.powerOf10(length);
 
             // Calculate the gap to the next numeric string of equal length with incremental first character.
@@ -480,7 +483,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
                 shift = CharacterSetCreator.powerOf10(length + 1);
             } else {
                 // Shift is the number of gaps times the current power of 10 plus the shift for the next length down with value adjusted by the number of gaps times the gap.
-                shift = gaps * powerOf10 + this.allNumericShift(shiftForward, length - 1, value - gaps * gap);
+                shift = gaps * powerOf10 + this.#allNumericShift(shiftForward, length - 1, value - gaps * gap);
             }
         }
 
@@ -493,7 +496,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * @param length
      * Length.
      */
-    private validateLength(length: number): void {
+    #validateLength(length: number): void {
         if (length < 0) {
             throw new RangeError(i18nextUtility.t("CharacterSetValidator.lengthMustBeGreaterThanOrEqualTo", {
                 length,
@@ -537,13 +540,13 @@ export class CharacterSetCreator extends CharacterSetValidator {
      * String(s) created from the value(s).
      */
     create<TTransformerInput extends TransformerInput<number | bigint>>(length: number, valueOrValues: TTransformerInput, exclusion: Exclusion = Exclusions.None, tweak?: number | bigint, creatorCallback?: IndexedCallback<string, string>): TransformerOutput<TTransformerInput, string> {
-        this.validateLength(length);
+        this.#validateLength(length);
         this.validateExclusion(exclusion);
 
         // Zero value in ternary else obviates need for non-null assertion.
-        const allZerosValue = exclusion === Exclusions.AllNumeric ? this._allZerosValues[length] : 0n;
+        const allZerosValue = exclusion === Exclusions.AllNumeric ? this.#allZerosValues[length] : 0n;
 
-        const transformer = Transformer.get(this._exclusionDomains[exclusion][length], tweak);
+        const transformer = Transformer.get(this.#exclusionDomains[exclusion][length], tweak);
 
         return transformer.forward(valueOrValues, (transformedValue, index) => {
             let s = "";
@@ -554,21 +557,21 @@ export class CharacterSetCreator extends CharacterSetValidator {
 
                 if (exclusion === Exclusions.AllNumeric && convertValue >= allZerosValue) {
                     // Value to convert is shifted by the number of all-numeric strings that occur at or prior to it.
-                    convertValue += this.allNumericShift(true, length, convertValue - allZerosValue);
+                    convertValue += this.#allNumericShift(true, length, convertValue - allZerosValue);
                 }
 
                 // Build string from right to left excluding the first character.
                 for (let position = length - 1; position > 0; position--) {
-                    const nextConvertValue = convertValue / this._characterSetSizeN;
+                    const nextConvertValue = convertValue / this.#characterSetSizeN;
 
                     // First step is effectively a modulus calculation.
-                    s = this.character(Number(convertValue - nextConvertValue * this._characterSetSizeN)) + s;
+                    s = this.character(Number(convertValue - nextConvertValue * this.#characterSetSizeN)) + s;
 
                     convertValue = nextConvertValue;
                 }
 
                 // Zero is first in the character set for those that support excluding first zero.
-                s = this.character(exclusion === Exclusions.FirstZero ? Number(convertValue % this._characterSetSizeMinusOneN) + 1 : Number(convertValue % this._characterSetSizeN)) + s;
+                s = this.character(exclusion === Exclusions.FirstZero ? Number(convertValue % this.#characterSetSizeMinusOneN) + 1 : Number(convertValue % this.#characterSetSizeN)) + s;
             }
 
             return creatorCallback === undefined ? s : creatorCallback(s, index);
@@ -594,7 +597,7 @@ export class CharacterSetCreator extends CharacterSetValidator {
     valueFor(s: string, exclusion: Exclusion = Exclusions.None, tweak?: number | bigint): bigint {
         const length = s.length;
 
-        this.validateLength(length);
+        this.#validateLength(length);
         this.validateExclusion(exclusion);
 
         const characterSetSizeN = BigInt(this.characterSetSize);
@@ -628,15 +631,15 @@ export class CharacterSetCreator extends CharacterSetValidator {
         }, 0n);
 
         if (exclusion === Exclusions.AllNumeric) {
-            const allZerosValue = this._allZerosValues[length];
+            const allZerosValue = this.#allZerosValues[length];
 
             if (value >= allZerosValue) {
                 // Call will ensure that string is not all-numeric.
-                value -= this.allNumericShift(false, length, value - allZerosValue);
+                value -= this.#allNumericShift(false, length, value - allZerosValue);
             }
         }
 
-        return Transformer.get(this._exclusionDomains[exclusion][length], tweak).reverse(value);
+        return Transformer.get(this.#exclusionDomains[exclusion][length], tweak).reverse(value);
     }
 }
 

package/src/record.ts

@@ -12,12 +12,12 @@ export class RecordValidator<T> implements StringValidator {
     /**
      * Type name for error message.
      */
-    private readonly _typeName: string;
+    readonly #typeName: string;
 
     /**
      * Record in which to look up keys.
      */
-    private readonly _record: Readonly<Record<string, T>>;
+    readonly #record: Readonly<Record<string, T>>;
 
     /**
      * Constructor.
@@ -29,22 +29,22 @@ export class RecordValidator<T> implements StringValidator {
      * Record in which to look up keys.
      */
     constructor(typeName: string, record: Readonly<Record<string, T>>) {
-        this._typeName = typeName;
-        this._record = record;
+        this.#typeName = typeName;
+        this.#record = record;
     }
 
     /**
      * Get the type name.
      */
     get typeName(): string {
-        return this._typeName;
+        return this.#typeName;
     }
 
     /**
      * Get the record.
      */
     get record(): Readonly<Record<string, T>> {
-        return this._record;
+        return this.#record;
     }
 
     /**

package/src/reg-exp.ts

@@ -14,7 +14,7 @@ export class RegExpValidator implements StringValidator {
     /**
      * Regular expression.
      */
-    private readonly _regExp: RegExp;
+    readonly #regExp: RegExp;
 
     /**
      * Constructor.
@@ -23,14 +23,14 @@ export class RegExpValidator implements StringValidator {
      * Regular expression. See {@link RegExpValidator | class documentation} for notes.
      */
     constructor(regExp: RegExp) {
-        this._regExp = regExp;
+        this.#regExp = regExp;
     }
 
     /**
      * Get the regular expression.
      */
     get regExp(): RegExp {
-        return this._regExp;
+        return this.#regExp;
     }
 
     /**
@@ -53,7 +53,7 @@ export class RegExpValidator implements StringValidator {
      * @inheritDoc
      */
     validate(s: string): void {
-        if (!this._regExp.test(s)) {
+        if (!this.#regExp.test(s)) {
             throw new RangeError(this.createErrorMessage(s));
         }
     }

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;
         }
     }