@aidc-toolkit/gs1 1.0.24-beta → 1.0.26-beta

package/test/gtin-validator.test.ts

@@ -1,20 +1,20 @@
 import { describe, expect, test } from "vitest";
 import {
+    type GTINBaseType,
     GTINLevels,
-    type GTINType,
     GTINTypes,
     GTINValidator,
     IdentifierTypes,
     LeaderTypes,
     type PrefixType,
     PrefixTypes
-} from "../src";
-import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
+} from "../src/index.js";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
-export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinType: GTINType): void {
+export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinBaseType: GTINBaseType): void {
     let prefixType: PrefixType;
 
-    switch (gtinType) {
+    switch (gtinBaseType) {
         case GTINTypes.GTIN13:
             prefixType = PrefixTypes.GS1CompanyPrefix;
             break;
@@ -26,14 +26,11 @@ export function validateGTINValidator(validator: GTINValidator, isCreator: boole
         case GTINTypes.GTIN8:
             prefixType = PrefixTypes.GS18Prefix;
             break;
-
-        default:
-            throw new Error("Not supported");
     }
 
-    validateNumericIdentifierValidator(validator, isCreator, IdentifierTypes.GTIN, prefixType, gtinType, LeaderTypes.IndicatorDigit);
+    validateNumericIdentifierValidator(validator, IdentifierTypes.GTIN, prefixType, gtinBaseType, LeaderTypes.IndicatorDigit);
 
-    expect(validator.gtinType).toBe(gtinType);
+    expect(validator.gtinType).toBe(gtinBaseType);
 }
 
 describe("GTIN validation and normalization", () => {

package/test/identifier-creator.ts

@@ -7,11 +7,11 @@ import {
     LeaderTypes,
     type PrefixManager,
     PrefixTypes
-} from "../src";
-import { validateGTINValidator } from "./gtin-validator.test";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator";
-import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator";
+} from "../src/index.js";
+import { validateGTINValidator } from "./gtin-validator.test.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 export function validateIdentifierCreators(prefixManager: PrefixManager): void {
     let gtinType: GTINType;
@@ -33,6 +33,7 @@ export function validateIdentifierCreators(prefixManager: PrefixManager): void {
             break;
     }
 
+    // Validate creator caching.
     expect(prefixManager.gtinCreator).toBe(prefixManager.gtinCreator);
 
     validateGTINValidator(prefixManager.gtinCreator, true, gtinType);

package/test/identifier-validator.ts

@@ -1,7 +1,7 @@
 import { expect } from "vitest";
-import type { IdentifierType, IdentifierValidator, PrefixType } from "../src";
+import type { IdentifierType, IdentifierTypeValidator, PrefixType } from "../src/index.js";
 
-export function validateIdentifierValidator(creator: IdentifierValidator, identifierType: IdentifierType, prefixType: PrefixType, length: number): void {
+export function validateIdentifierValidator<TIdentifierType extends IdentifierType>(creator: IdentifierTypeValidator<TIdentifierType>, identifierType: IdentifierType, prefixType: PrefixType, length: number): void {
     expect(creator.identifierType).toBe(identifierType);
     expect(creator.prefixType).toBe(prefixType);
     expect(creator.length).toBe(length);

package/test/non-gtin-numeric-identifier-creator.ts

@@ -1,98 +1,14 @@
-import { Exclusions, Sequence } from "@aidc-toolkit/utility";
-import { describe, expect, test } from "vitest";
-import {
-    hasValidCheckCharacterPair,
-    type NonGTINNumericIdentifierCreator,
-    type NonNumericIdentifierCreator
-} from "../src";
-import { testNumericIdentifierCreator } from "./numeric-identifier-creator";
+import { expect, test } from "vitest";
+import { isNonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierCreator } from "../src/index.js";
+import { testIdentifierCreatorCallback } from "./identifier-creator.js";
+import { testNumericIdentifierCreator } from "./numeric-identifier-creator.js";
 
 export function testNonGTINNumericIdentifierCreator(creator: NonGTINNumericIdentifierCreator, preTestCallback?: () => void, postTestCallback?: () => void): void {
-    testNumericIdentifierCreator(creator, preTestCallback, postTestCallback);
-}
-
-const TEST_REFERENCE_LENGTH = 2;
-
-export function testNonNumericIdentifierCreator(creator: NonNumericIdentifierCreator): void {
-    describe(creator.identifierType, () => {
-        const prefix = creator.prefix;
-        const prefixLength = prefix.length;
-        const referenceLength = creator.length - prefixLength - 2 * Number(creator.requiresCheckCharacterPair);
-        const referenceCount = creator.referenceCreator.characterSetSize ** TEST_REFERENCE_LENGTH;
-        const referenceSubstringStart = prefixLength;
-        const referenceSubstringEnd = prefixLength + TEST_REFERENCE_LENGTH;
-
-        test("Straight", () => {
-            expect(creator.referenceLength).toBe(referenceLength);
-
-            let index = 0;
-
-            for (const identifier of creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequence(0, referenceCount)))) {
-                expect(() => {
-                    creator.validate(identifier);
-                }).not.toThrow(RangeError);
-
-                expect(Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd)))).toBe(index);
-
-                expect(identifier.length).toBeLessThanOrEqual(creator.length);
-                expect(identifier.substring(0, prefixLength)).toBe(prefix);
-                expect(!creator.requiresCheckCharacterPair || hasValidCheckCharacterPair(identifier)).toBe(true);
-
-                expect(identifier).toBe(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, index, Exclusions.None, undefined, reference => creator.create(reference)));
-
-                index++;
-            }
-
-            expect(index).toBe(referenceCount);
-        });
-
-        test("Sparse", () => {
-            let sequential = true;
-
-            let index = 0;
-
-            for (const identifier of creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequence(0, referenceCount), Exclusions.None, 123456n))) {
-                expect(() => {
-                    creator.validate(identifier);
-                }).not.toThrow(RangeError);
-
-                expect(Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd), Exclusions.None, 123456n))).toBe(index);
-
-                sequential &&= Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd))) === index;
-
-                expect(identifier.length).toBeLessThanOrEqual(creator.length);
-                expect(identifier.substring(0, prefixLength)).toBe(prefix);
-                expect(!creator.requiresCheckCharacterPair || hasValidCheckCharacterPair(identifier)).toBe(true);
-
-                expect(identifier).toBe(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, index, Exclusions.None, 123456n, reference => creator.create(reference)));
-
-                index++;
-            }
-
-            expect(sequential).toBe(false);
-            expect(index).toBe(referenceCount);
-        });
-
-        test("Position offset", () => {
-            expect(() => {
-                creator.validate(creator.create("ABC123"), {
-                    positionOffset: 4
-                });
-            }).not.toThrow(RangeError);
-        });
-
-        test("Not all numeric", () => {
-            expect(() => {
-                creator.validate(creator.create("01234"), {
-                    exclusion: Exclusions.AllNumeric
-                });
-            }).toThrow("Reference can't be all-numeric");
+    testNumericIdentifierCreator(creator, () => {
+        testIdentifierCreatorCallback(preTestCallback);
 
-            expect(() => {
-                creator.validate(creator.create("O1234"), {
-                    exclusion: Exclusions.AllNumeric
-                });
-            }).not.toThrow(RangeError);
+        test("Mapping", () => {
+            expect(isNonGTINNumericIdentifierCreator(creator)).toBe(true);
         });
-    });
+    }, postTestCallback);
 }

package/test/non-gtin-numeric-identifier-validator.ts

@@ -1,6 +1,6 @@
-import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierValidator, PrefixTypes } from "../src";
-import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
+import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierValidator, PrefixTypes } from "../src/index.js";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
 export function validateNonGTINNumericIdentifierValidator(validator: NonGTINNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, leaderType: LeaderType): void {
-    validateNumericIdentifierValidator(validator, isCreator, identifierType, PrefixTypes.GS1CompanyPrefix, length, leaderType);
+    validateNumericIdentifierValidator(validator, identifierType, PrefixTypes.GS1CompanyPrefix, length, leaderType);
 }

package/test/non-numeric-identifier-creator.ts

@@ -0,0 +1,93 @@
+import { Exclusions, Sequence } from "@aidc-toolkit/utility";
+import { describe, expect, test } from "vitest";
+import { hasValidCheckCharacterPair, isNonNumericIdentifierCreator, type NonNumericIdentifierCreator } from "../src/index.js";
+
+const TEST_REFERENCE_LENGTH = 2;
+
+export function testNonNumericIdentifierCreator(creator: NonNumericIdentifierCreator): void {
+    describe(creator.identifierType, () => {
+        const prefix = creator.prefix;
+        const prefixLength = prefix.length;
+        const referenceLength = creator.length - prefixLength - 2 * Number(creator.requiresCheckCharacterPair);
+        const referenceCount = creator.referenceCreator.characterSetSize ** TEST_REFERENCE_LENGTH;
+        const referenceSubstringStart = prefixLength;
+        const referenceSubstringEnd = prefixLength + TEST_REFERENCE_LENGTH;
+
+        test("Mapping", () => {
+            expect(isNonNumericIdentifierCreator(creator)).toBe(true);
+        });
+
+        test("Straight", () => {
+            expect(creator.referenceLength).toBe(referenceLength);
+
+            let index = 0;
+
+            for (const identifier of creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequence(0, referenceCount)))) {
+                expect(() => {
+                    creator.validate(identifier);
+                }).not.toThrow(RangeError);
+
+                expect(Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd)))).toBe(index);
+
+                expect(identifier.length).toBeLessThanOrEqual(creator.length);
+                expect(identifier.substring(0, prefixLength)).toBe(prefix);
+                expect(!creator.requiresCheckCharacterPair || hasValidCheckCharacterPair(identifier)).toBe(true);
+
+                expect(identifier).toBe(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, index, Exclusions.None, undefined, reference => creator.create(reference)));
+
+                index++;
+            }
+
+            expect(index).toBe(referenceCount);
+        });
+
+        test("Sparse", () => {
+            let sequential = true;
+
+            let index = 0;
+
+            for (const identifier of creator.create(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, new Sequence(0, referenceCount), Exclusions.None, 123456n))) {
+                expect(() => {
+                    creator.validate(identifier);
+                }).not.toThrow(RangeError);
+
+                expect(Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd), Exclusions.None, 123456n))).toBe(index);
+
+                sequential &&= Number(creator.referenceCreator.valueFor(identifier.substring(referenceSubstringStart, referenceSubstringEnd))) === index;
+
+                expect(identifier.length).toBeLessThanOrEqual(creator.length);
+                expect(identifier.substring(0, prefixLength)).toBe(prefix);
+                expect(!creator.requiresCheckCharacterPair || hasValidCheckCharacterPair(identifier)).toBe(true);
+
+                expect(identifier).toBe(creator.referenceCreator.create(TEST_REFERENCE_LENGTH, index, Exclusions.None, 123456n, reference => creator.create(reference)));
+
+                index++;
+            }
+
+            expect(sequential).toBe(false);
+            expect(index).toBe(referenceCount);
+        });
+
+        test("Position offset", () => {
+            expect(() => {
+                creator.validate(creator.create("ABC123"), {
+                    positionOffset: 4
+                });
+            }).not.toThrow(RangeError);
+        });
+
+        test("Not all numeric", () => {
+            expect(() => {
+                creator.validate(creator.create("01234"), {
+                    exclusion: Exclusions.AllNumeric
+                });
+            }).toThrow("Reference can't be all-numeric");
+
+            expect(() => {
+                creator.validate(creator.create("O1234"), {
+                    exclusion: Exclusions.AllNumeric
+                });
+            }).not.toThrow(RangeError);
+        });
+    });
+}

package/test/non-numeric-identifier-validator.ts

@@ -5,9 +5,9 @@ import {
     type NonNumericIdentifierCreator,
     type NonNumericIdentifierValidator,
     PrefixTypes
-} from "../src";
-import { validateIdentifierValidator } from "./identifier-validator";
-import { creatorFor } from "./utility";
+} from "../src/index.js";
+import { validateIdentifierValidator } from "./identifier-validator.js";
+import { creatorFor } from "./utility.js";
 
 export function validateNonNumericIdentifierValidator(validator: NonNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, referenceCharacterSet: ContentCharacterSet, requiresCheckCharacterPair: boolean): void {
     validateIdentifierValidator(validator, identifierType, PrefixTypes.GS1CompanyPrefix, length);

package/test/numeric-identifier-creator.ts

@@ -1,10 +1,16 @@
 import { CharacterSetCreator, Sequence } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
-import { hasValidCheckDigit, IdentifierTypes, LeaderTypes, type NumericIdentifierCreator } from "../src";
-import { testIdentifierCreatorCallback } from "./identifier-creator";
-
-export function testNumericIdentifierCreator(creator: NumericIdentifierCreator, preTestCallback?: () => void, postTestCallback?: () => void): void {
-    describe(creator.identifierType === IdentifierTypes.GTIN ? `${creator.identifierType}-${creator.length}` : creator.identifierType, () => {
+import {
+    hasValidCheckDigit,
+    isGTINCreator,
+    LeaderTypes,
+    type NumericIdentifierCreator,
+    type NumericIdentifierDescriptor
+} from "../src/index.js";
+import { testIdentifierCreatorCallback } from "./identifier-creator.js";
+
+export function testNumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor>(creator: NumericIdentifierCreator<TNumericIdentifierDescriptor>, preTestCallback?: () => void, postTestCallback?: () => void): void {
+    describe(isGTINCreator(creator) ? `${creator.identifierType}-${creator.length}` : creator.identifierType as string, () => {
         testIdentifierCreatorCallback(preTestCallback);
 
         const prefix = creator.prefix;

package/test/numeric-identifier-validator.ts

@@ -3,21 +3,17 @@ import { expect } from "vitest";
 import {
     ContentCharacterSets,
     type IdentifierType,
+    type IdentifierTypeValidator,
     type LeaderType,
-    type NumericIdentifierCreator,
-    type NumericIdentifierValidator,
+    type NumericIdentifierType,
     type PrefixType
-} from "../src";
-import { validateIdentifierValidator } from "./identifier-validator";
+} from "../src/index.js";
+import { validateIdentifierValidator } from "./identifier-validator.js";
 
-export function validateNumericIdentifierValidator(validator: NumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType): void {
+export function validateNumericIdentifierValidator<TNumericIdentifierType extends NumericIdentifierType>(validator: IdentifierTypeValidator<TNumericIdentifierType>, identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType): void {
     validateIdentifierValidator(validator, identifierType, prefixType, length);
 
     expect(validator.leaderType).toBe(leaderType);
     expect(validator.referenceCharacterSet).toBe(ContentCharacterSets.Numeric);
     expect(validator.referenceCreator).toBe(NUMERIC_CREATOR);
-
-    if (isCreator) {
-        expect((validator as NumericIdentifierCreator).referenceCreator).toBe(NUMERIC_CREATOR);
-    }
 }

package/test/prefix-manager.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
-import { validateIdentifierCreators } from "./identifier-creator";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
+import { validateIdentifierCreators } from "./identifier-creator.js";
 
 describe("Prefix manager", () => {
     let prefixManager: PrefixManager;

package/test/serializable-numeric-identifier-creator.ts

@@ -1,9 +1,17 @@
 import { expect, test } from "vitest";
-import { ContentCharacterSets, type SerializableNumericIdentifierCreator } from "../src";
-import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
+import {
+    ContentCharacterSets,
+    isSerializableNumericIdentifierCreator,
+    type SerializableNumericIdentifierCreator
+} from "../src/index.js";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
 
 export function testSerializableNumericIdentifierCreator(creator: SerializableNumericIdentifierCreator): void {
-    testNonGTINNumericIdentifierCreator(creator, undefined, () => {
+    testNonGTINNumericIdentifierCreator(creator, () => {
+        test("Mapping", () => {
+            expect(isSerializableNumericIdentifierCreator(creator)).toBe(true);
+        });
+    }, () => {
         test("Serialization", () => {
             const identifier = creator.create(0, true);
             const serial = "12345678";

package/test/serializable-numeric-identifier-validator.ts

@@ -5,9 +5,9 @@ import type {
     LeaderType,
     SerializableNumericIdentifierCreator,
     SerializableNumericIdentifierValidator
-} from "../src";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { creatorFor } from "./utility";
+} from "../src/index.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { creatorFor } from "./utility.js";
 
 export function validateSerializableNumericIdentifierValidator(validator: SerializableNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, leaderType: LeaderType, serialLength: number, serialCharacterSet: ContentCharacterSet): void {
     validateNonGTINNumericIdentifierValidator(validator, isCreator, identifierType, length, leaderType);

package/test/setup.ts

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

package/test/sparse.test.ts

@@ -1,6 +1,6 @@
 import { Sequence } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
 
 describe("Sparse creation", () => {
     const prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");

package/test/utility.ts

@@ -1,5 +1,5 @@
 import { type CharacterSetCreator, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src";
+import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src/index.js";
 
 export function creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
     let creator: CharacterSetCreator;

package/test/validator.test.ts

@@ -1,52 +1,76 @@
 import { describe, expect, test } from "vitest";
 import {
     ContentCharacterSets,
-    CPID_VALIDATOR,
-    GCN_VALIDATOR,
-    GDTI_VALIDATOR,
-    GIAI_VALIDATOR,
-    GINC_VALIDATOR,
-    GLN_VALIDATOR,
-    GMN_VALIDATOR,
-    GRAI_VALIDATOR,
-    GSIN_VALIDATOR,
-    GSRN_VALIDATOR,
-    GTIN12_VALIDATOR,
-    GTIN13_VALIDATOR,
-    GTIN8_VALIDATOR,
-    GTIN_VALIDATORS,
+    type GTINBaseType,
     GTINTypes,
+    type GTINValidator,
+    type IdentifierType,
     IdentifierTypes,
-    LeaderTypes,
-    PrefixTypes,
-    SSCC_VALIDATOR
-} from "../src";
-import { validateGTINValidator } from "./gtin-validator.test";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator";
-import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator";
+    type IdentifierValidator,
+    IdentifierValidators,
+    isGTINValidator,
+    isGTINValidators,
+    isNonGTINNumericIdentifierValidator,
+    isNonNumericIdentifierValidator,
+    isNumericIdentifierValidator,
+    isSerializableNumericIdentifierValidator,
+    LeaderTypes
+} from "../src/index.js";
+import { validateGTINValidator } from "./gtin-validator.test.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 describe("Validators", () => {
-    test("GTIN", () => {
-        expect(GTIN_VALIDATORS[PrefixTypes.GS1CompanyPrefix]).toBe(GTIN13_VALIDATOR);
-        expect(GTIN_VALIDATORS[PrefixTypes.UPCCompanyPrefix]).toBe(GTIN12_VALIDATOR);
-        expect(GTIN_VALIDATORS[PrefixTypes.GS18Prefix]).toBe(GTIN8_VALIDATOR);
+    function validateMapping(identifierType: IdentifierType, expectedIdentifierValidatorsOrValidator: Readonly<Record<GTINBaseType, GTINValidator>> | IdentifierValidator, ...isIdentifierValidatorTypes: Array<(validator: IdentifierValidator) => boolean>): void {
+        test(identifierType, () => {
+            const validatorsOrValidator = IdentifierValidators[identifierType];
+
+            expect(validatorsOrValidator).toBe(expectedIdentifierValidatorsOrValidator);
+
+            if (isGTINValidators(validatorsOrValidator)) {
+                for (const validator of Object.values(validatorsOrValidator)) {
+                    for (const isIdentifierValidatorType of isIdentifierValidatorTypes) {
+                        expect(isIdentifierValidatorType(validator)).toBe(true);
+                    }
+                }
+            } else {
+                for (const isIdentifierValidatorType of isIdentifierValidatorTypes) {
+                    expect(isIdentifierValidatorType(validatorsOrValidator)).toBe(true);
+                }
+            }
+        });
+    }
+
+    describe("Mapping", () => {
+        validateMapping(IdentifierTypes.GTIN, IdentifierValidators.GTIN, isNumericIdentifierValidator, isGTINValidator);
+        validateMapping(IdentifierTypes.GLN, IdentifierValidators.GLN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.SSCC, IdentifierValidators.SSCC, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GRAI, IdentifierValidators.GRAI, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GIAI, IdentifierValidators.GIAI, isNonNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GSRN, IdentifierValidators.GSRN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GDTI, IdentifierValidators.GDTI, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GINC, IdentifierValidators.GINC, isNonNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GSIN, IdentifierValidators.GSIN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GCN, IdentifierValidators.GCN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.CPID, IdentifierValidators.CPID, isNonNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GMN, IdentifierValidators.GMN, isNonNumericIdentifierValidator);
     });
 
     test("Structure", () => {
-        validateGTINValidator(GTIN13_VALIDATOR, false, GTINTypes.GTIN13);
-        validateGTINValidator(GTIN12_VALIDATOR, false, GTINTypes.GTIN12);
-        validateGTINValidator(GTIN8_VALIDATOR, false, GTINTypes.GTIN8);
-        validateNonGTINNumericIdentifierValidator(GLN_VALIDATOR, false, IdentifierTypes.GLN, 13, LeaderTypes.None);
-        validateNonGTINNumericIdentifierValidator(SSCC_VALIDATOR, false, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
-        validateSerializableNumericIdentifierValidator(GRAI_VALIDATOR, false, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
-        validateNonNumericIdentifierValidator(GIAI_VALIDATOR, false, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(GSRN_VALIDATOR, false, IdentifierTypes.GSRN, 18, LeaderTypes.None);
-        validateSerializableNumericIdentifierValidator(GDTI_VALIDATOR, false, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
-        validateNonNumericIdentifierValidator(GINC_VALIDATOR, false, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
-        validateNonGTINNumericIdentifierValidator(GSIN_VALIDATOR, false, IdentifierTypes.GSIN, 17, LeaderTypes.None);
-        validateSerializableNumericIdentifierValidator(GCN_VALIDATOR, false, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
-        validateNonNumericIdentifierValidator(CPID_VALIDATOR, false, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
-        validateNonNumericIdentifierValidator(GMN_VALIDATOR, false, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN13], false, GTINTypes.GTIN13);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN12], false, GTINTypes.GTIN12);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN8], false, GTINTypes.GTIN8);
+        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GLN, false, IdentifierTypes.GLN, 13, LeaderTypes.None);
+        validateNonGTINNumericIdentifierValidator(IdentifierValidators.SSCC, false, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
+        validateSerializableNumericIdentifierValidator(IdentifierValidators.GRAI, false, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(IdentifierValidators.GIAI, false, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GSRN, false, IdentifierTypes.GSRN, 18, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(IdentifierValidators.GDTI, false, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(IdentifierValidators.GINC, false, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(IdentifierValidators.GSIN, false, IdentifierTypes.GSIN, 17, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(IdentifierValidators.GCN, false, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
+        validateNonNumericIdentifierValidator(IdentifierValidators.CPID, false, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
+        validateNonNumericIdentifierValidator(IdentifierValidators.GMN, false, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);
     });
 });

package/test/variable-measure-rcn.test.ts

@@ -5,7 +5,7 @@ import {
     hasValidCheckDigit,
     isValidPriceOrWeightCheckDigit,
     type RCNReference
-} from "../src";
+} from "../src/index.js";
 
 describe("Variable measure RCN", () => {
     test("RCN-12", () => {

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