@aidc-toolkit/utility 0.9.17-beta → 0.9.19-beta

package/src/locale/fr/locale-strings.ts

@@ -1,11 +1,11 @@
 export const localeStrings = {
     Transformer: {
-        domainMustBeGreaterThanZero: "Le domaine {{domain}} doit être supérieur à 0",
-        tweakMustBeGreaterThanOrEqualToZero: "Le réglage {{tweak}} doit être supérieur ou égal à 0",
-        valueMustBeGreaterThanOrEqualToZero: "La valeur {{value}} doit être supérieure ou égale à 0",
-        valueMustBeLessThan: "La valeur {{value}} doit être inférieure à {{domain}}",
-        minimumValueMustBeGreaterThanOrEqualToZero: "La valeur minimale {{minimumValue}} doit être supérieure ou égale à 0",
-        maximumValueMustBeLessThan: "La valeur maximale {{maximumValue}} doit être inférieure à {{domain}}"
+        domainMustBeGreaterThanZero: "Le domaine {{domain, number}} doit être supérieur à 0",
+        tweakMustBeGreaterThanOrEqualToZero: "Le réglage {{tweak, number}} doit être supérieur ou égal à 0",
+        valueMustBeGreaterThanOrEqualToZero: "La valeur {{value, number}} doit être supérieure ou égale à 0",
+        valueMustBeLessThan: "La valeur {{value, number}} doit être inférieure à {{domain, number}}",
+        minimumValueMustBeGreaterThanOrEqualToZero: "La valeur minimale {{minimumValue, number}} doit être supérieure ou égale à 0",
+        maximumValueMustBeLessThan: "La valeur maximale {{maximumValue, number}} doit être inférieure à {{domain, number}}"
     },
     RegExpValidator: {
         stringDoesNotMatchPattern: "La chaîne {{s}} ne correspond pas au modèle"
@@ -14,17 +14,16 @@ export const localeStrings = {
         firstZeroFirstCharacter: "Le jeu de caractères doit prendre en charge zéro comme premier caractère",
         allNumericAllNumericCharacters: "Le jeu de caractères doit prendre en charge tous les caractères numériques en séquence",
         stringMustNotBeAllNumeric: "La chaîne ne doit pas être entièrement numérique",
-        lengthMustBeGreaterThanOrEqualTo: "La longueur {{length}} doit être supérieure ou égale à {{minimumLength}}",
-        lengthMustBeLessThanOrEqualTo: "La longueur {{length}} doit être inférieure ou égale à {{maximumLength}}",
-        lengthMustBeEqualTo: "La longueur {{length}} doit être égale à {{exactLength}}",
-        lengthOfComponentMustBeGreaterThanOrEqualTo: "La longueur {{length}} de {{component}} doit être supérieure ou égale à {{minimumLength}}",
-        lengthOfComponentMustBeLessThanOrEqualTo: "La longueur {{length}} de {{component}} doit être inférieure ou égale à {{maximumLength}}",
-        lengthOfComponentMustBeEqualTo: "La longueur {{length}} de {{component}} doit être égale à {{exactLength}}",
-        invalidCharacterAtPosition: "Caractère non valide '{{c}}' à la position {{position}}",
-        invalidCharacterAtPositionOfComponent: "Caractère non valide '{{c}}' à la position {{position}} de {{component}}",
-        exclusionNotSupported: "La valeur d'exclusion de {{exclusion}} n'est pas prise en charge",
-        invalidTweakWithAllNumericExclusion: "Le réglage ne doit pas être utilisé avec une exclusion entièrement numérique",
-        endSequenceValueMustBeLessThanOrEqualTo: "La valeur de la séquence de fin (valeur de la séquence de début + nombre - 1) doit être inférieure à {{domaine}}"
+        lengthMustBeGreaterThanOrEqualTo: "La longueur {{length, number}} doit être supérieure ou égale à {{minimumLength, number}}",
+        lengthMustBeLessThanOrEqualTo: "La longueur {{length, number}} doit être inférieure ou égale à {{maximumLength, number}}",
+        lengthMustBeEqualTo: "La longueur {{length, number}} doit être égale à {{exactLength, number}}",
+        lengthOfComponentMustBeGreaterThanOrEqualTo: "La longueur {{length, number}} de {{component}} doit être supérieure ou égale à {{minimumLength, number}}",
+        lengthOfComponentMustBeLessThanOrEqualTo: "La longueur {{length, number}} de {{component}} doit être inférieure ou égale à {{maximumLength, number}}",
+        lengthOfComponentMustBeEqualTo: "La longueur {{length, number}} de {{component}} doit être égale à {{exactLength, number}}",
+        invalidCharacterAtPosition: "Caractère non valide '{{c}}' à la position {{position, number}}",
+        invalidCharacterAtPositionOfComponent: "Caractère non valide '{{c}}' à la position {{position, number}} de {{component}}",
+        exclusionNotSupported: "La valeur d'exclusion de {{exclusion, number}} n'est pas prise en charge",
+        endSequenceValueMustBeLessThanOrEqualTo: "La valeur de la séquence de fin (valeur de la séquence de début + nombre - 1) doit être inférieure à {{domain, number}}"
     },
     RecordValidator: {
         typeNameKeyNotFound: "{{typeName}} \"{{key}}\" introuvable"

package/src/locale/i18n.ts

@@ -1,4 +1,4 @@
-import { i18nAssertValidResources, i18nCoreInit, type I18NEnvironment } from "@aidc-toolkit/core";
+import { i18nAssertValidResources, i18nCoreInit, type I18nEnvironment } from "@aidc-toolkit/core";
 import i18next, { type i18n, type Resource } from "i18next";
 import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
 import { localeStrings as frLocaleStrings } from "./fr/locale-strings.js";
@@ -39,6 +39,6 @@ export const i18nextUtility: i18n = i18next.createInstance();
  * @returns
  * Void promise.
  */
-export async function i18nUtilityInit(environment: I18NEnvironment, debug = false): Promise<void> {
+export async function i18nUtilityInit(environment: I18nEnvironment, debug = false): Promise<void> {
     await i18nCoreInit(i18nextUtility, environment, debug, utilityNS, utilityResources);
 }

package/src/record.ts

@@ -4,6 +4,9 @@ import type { StringValidator } from "./string.js";
 /**
  * Record validator. Validation is performed against a record with a string key type and throws an error if the key is
  * not found.
+ *
+ * @template T
+ * Property type.
  */
 export class RecordValidator<T> implements StringValidator {
     /**

package/src/string.ts

@@ -7,6 +7,9 @@ export interface StringValidation {
 
 /**
  * String validator interface.
+ *
+ * @template V
+ * String validation type.
  */
 export interface StringValidator<V extends StringValidation = StringValidation> {
     /**

package/src/transformer.ts

@@ -1,3 +1,4 @@
+import { type IndexedCallback, mapIterable } from "./iterable-utility.js";
 import { i18nextUtility } from "./locale/i18n.js";
 import { Sequence } from "./sequence.js";
 
@@ -10,38 +11,18 @@ export type TransformerPrimitive = string | number | bigint | boolean;
  * Transformer input type, one of:
  *
  * - TInput (primitive type)
- * - Iterable<TInput>
+ * - Iterable\<TInput\>
  *
  * @template TInput
  * Transformer input primitive type.
  */
 export type TransformerInput<TInput extends TransformerPrimitive> = TInput | Iterable<TInput>;
 
-/**
- * Transformer callback, used to convert transformed value to its final value.
- *
- * @template TInput
- * Transformer input primitive type.
- *
- * @template TOutput
- * Transformer output type.
- *
- * @param input
- * Input value.
- *
- * @param index
- * Index in sequence (0 for single transformation).
- *
- * @returns
- * Output value.
- */
-export type TransformerCallback<TInput extends TransformerPrimitive, TOutput> = (input: TInput, index: number) => TOutput;
-
 /**
  * Transformer output, based on transformer input:
  *
  * - If type TTransformerInput is primitive, result is type TOutput.
- * - If type TTransformerInput is Iterable, result is type Iterable<TOutput>.
+ * - If type TTransformerInput is Iterable, result is type Iterable\<TOutput\>.
  *
  * @template TTransformerInput
  * Transformer input type.
@@ -49,38 +30,7 @@ export type TransformerCallback<TInput extends TransformerPrimitive, TOutput> =
  * @template TOutput
  * Output base type.
  */
-export type TransformerOutput<TTransformerInput extends TransformerInput<TransformerPrimitive>, TOutput> =
-    TTransformerInput extends (TTransformerInput extends TransformerInput<infer TInput> ? TInput : never) ? TOutput : Iterable<TOutput>;
-
-/**
- * Transform an input iterable to an output iterable that applies a transformer callback to each value in the input.
- *
- * @param values
- * Input values iterable.
- *
- * @param transformerCallback
- * Callback to transform input value to output value.
- *
- * @returns
- * Output values iterable.
- */
-export function transformIterable<TInput extends TransformerPrimitive, TOutput>(values: Iterable<TInput>, transformerCallback: TransformerCallback<TInput, TOutput>): Iterable<TOutput> {
-    return {
-        /**
-         * Iterable implementation.
-         *
-         * @yields
-         * Next output value.
-         */
-        * [Symbol.iterator](): Generator<TOutput> {
-            let index = 0;
-
-            for (const value of values) {
-                yield transformerCallback(value, index++);
-            }
-        }
-    };
-}
+export type TransformerOutput<TTransformerInput extends TransformerInput<TransformerPrimitive>, TOutput> = TTransformerInput extends (TTransformerInput extends TransformerInput<infer TInput> ? TInput : never) ? TOutput : Iterable<TOutput>;
 
 /**
  * Transformer that transforms values in a numeric domain to values in a range equal to the domain or to another range
@@ -234,7 +184,7 @@ export abstract class Transformer {
      * @returns
      * Transformed value.
      */
-    private validateDoForwardCallback<TOutput>(transformerCallback: TransformerCallback<bigint, TOutput>, value: number | bigint, index: number): TOutput {
+    private validateDoForwardCallback<TOutput>(transformerCallback: IndexedCallback<bigint, TOutput>, value: number | bigint, index?: number): TOutput {
         return transformerCallback(this.validateDoForward(value), index);
     };
 
@@ -272,15 +222,15 @@ export abstract class Transformer {
      * @returns
      * Transformed value(s).
      */
-    forward<TTransformerInput extends TransformerInput<number | bigint>, TOutput>(valueOrValues: TTransformerInput, transformerCallback: TransformerCallback<bigint, TOutput>): TransformerOutput<TTransformerInput, TOutput>;
+    forward<TTransformerInput extends TransformerInput<number | bigint>, TOutput>(valueOrValues: TTransformerInput, transformerCallback: IndexedCallback<bigint, TOutput>): TransformerOutput<TTransformerInput, TOutput>;
 
     // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
-    forward<TTransformerInput extends TransformerInput<number | bigint>, TOutput>(valueOrValues: TTransformerInput, transformerCallback?: TransformerCallback<bigint, TOutput>): TransformerOutput<TTransformerInput, TOutput> {
+    forward<TTransformerInput extends TransformerInput<number | bigint>, TOutput>(valueOrValues: TTransformerInput, transformerCallback?: IndexedCallback<bigint, TOutput>): TransformerOutput<TTransformerInput, TOutput> {
         // TODO Refactor type when https://github.com/microsoft/TypeScript/pull/56941 released.
         let result: bigint | TOutput | Iterable<bigint> | Iterable<TOutput>;
 
         if (typeof valueOrValues !== "object") {
-            result = transformerCallback === undefined ? this.validateDoForward(valueOrValues) : this.validateDoForwardCallback(transformerCallback, valueOrValues, 0);
+            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", {
@@ -295,9 +245,9 @@ export abstract class Transformer {
                 }));
             }
 
-            result = transformerCallback === undefined ? transformIterable(valueOrValues, value => this.doForward(value)) : transformIterable(valueOrValues, (value, index) => transformerCallback(this.doForward(value), index));
+            result = transformerCallback === undefined ? mapIterable(valueOrValues, value => this.doForward(value)) : mapIterable(valueOrValues, (value, index) => transformerCallback(this.doForward(value), index));
         } else {
-            result = transformerCallback === undefined ? transformIterable(valueOrValues, value => this.validateDoForward(value)) : transformIterable(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.

package/test/character-set.test.ts

@@ -1,20 +1,27 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+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";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+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();
@@ -77,6 +84,9 @@ function testCharacterSetCreator(name: string, characterSetCreator: CharacterSet
 
                 expect(s.length).toBe(length);
 
+                expect(() => {
+                    characterSetValidator.validate(s);
+                }).not.toThrow(RangeError);
                 expect(characterSetCreator.valueFor(s, exclusion)).toBe(BigInt(index));
 
                 index++;
@@ -104,6 +114,9 @@ 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));
 
                 index++;
@@ -198,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,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, RecordValidator } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Record validator", () => {
     enum StringEnum {

package/test/reg-exp.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, RegExpValidator } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Regular expression validator", () => {
     test("Validation", () => {

package/test/sequence.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { i18nUtilityInit, Sequence } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 describe("Sequence", () => {
     const sequence1 = new Sequence(10, 20);

package/test/transformer.test.ts

@@ -1,8 +1,8 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { describe, expect, test } from "vitest";
 import { EncryptionTransformer, i18nUtilityInit, IdentityTransformer, Sequence, Transformer } from "../src";
 
-await i18nUtilityInit(I18NEnvironment.CLI);
+await i18nUtilityInit(I18nEnvironment.CLI);
 
 function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
     const transformer = Transformer.get(domain, tweak);
@@ -59,7 +59,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", () => {
@@ -84,7 +84,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);