@aidc-toolkit/gs1 1.0.23-beta → 1.0.25-beta

package/test/gtin-validator.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "vitest";
 import {
+    type GTINBaseType,
     GTINLevels,
-    type GTINType,
     GTINTypes,
     GTINValidator,
     IdentifierTypes,
@@ -9,12 +9,12 @@ import {
     type PrefixType,
     PrefixTypes
 } from "../src";
-import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
 
-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

@@ -8,10 +8,10 @@ import {
     type PrefixManager,
     PrefixTypes
 } from "../src";
-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";
+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";
 
 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";
 
-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.js";
+import { expect, test } from "vitest";
+import { isNonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierCreator } from "../src";
+import { testIdentifierCreatorCallback } from "./identifier-creator";
+import { testNumericIdentifierCreator } from "./numeric-identifier-creator";
 
 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.js";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
 
 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";
+
+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

@@ -6,8 +6,8 @@ import {
     type NonNumericIdentifierValidator,
     PrefixTypes
 } from "../src";
-import { validateIdentifierValidator } from "./identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { validateIdentifierValidator } from "./identifier-validator";
+import { creatorFor } from "./utility";
 
 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.js";
-
-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";
+import { testIdentifierCreatorCallback } from "./identifier-creator";
+
+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.js";
+import { validateIdentifierValidator } from "./identifier-validator";
 
-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.js";
+import { validateIdentifierCreators } from "./identifier-creator";
 
 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.js";
+import {
+    ContentCharacterSets,
+    isSerializableNumericIdentifierCreator,
+    type SerializableNumericIdentifierCreator
+} from "../src";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
 
 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

@@ -6,8 +6,8 @@ import type {
     SerializableNumericIdentifierCreator,
     SerializableNumericIdentifierValidator
 } from "../src";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
+import { creatorFor } from "./utility";
 
 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/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
+    type IdentifierValidator,
+    IdentifierValidators,
+    isGTINValidator,
+    isGTINValidators,
+    isNonGTINNumericIdentifierValidator,
+    isNonNumericIdentifierValidator,
+    isNumericIdentifierValidator,
+    isSerializableNumericIdentifierValidator,
+    LeaderTypes
 } from "../src";
-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";
+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";
 
 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/tsup.config.ts

@@ -0,0 +1,3 @@
+import { tsupConfigAIDCToolkit } from "@aidc-toolkit/dev";
+
+export default tsupConfigAIDCToolkit;

package/typedoc.json

@@ -3,7 +3,5 @@
   "extends": [
     "@aidc-toolkit/dev/typedoc.json"
   ],
-  "name": "GS1",
-  "tsconfig": "node_modules/@aidc-toolkit/dev/tsconfig-build-dev.json",
-  "gitRevision": "main"
+  "name": "GS1"
 }

package/dist/character-set.d.ts

@@ -1,22 +0,0 @@
-import { CharacterSetCreator, type CharacterSetValidator } from "@aidc-toolkit/utility";
-/**
- * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export declare const AI82_CREATOR: CharacterSetCreator;
-/**
- * GS1 AI encodable character set 82 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export declare const AI82_VALIDATOR: CharacterSetValidator;
-/**
- * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export declare const AI39_CREATOR: CharacterSetCreator;
-/**
- * GS1 AI encodable character set 39 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export declare const AI39_VALIDATOR: CharacterSetValidator;
-//# sourceMappingURL=character-set.d.ts.map

package/dist/character-set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"character-set.d.ts","sourceRoot":"","sources":["../src/character-set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,qBAAqB,EAAc,MAAM,uBAAuB,CAAC;AAEpG;;;GAGG;AACH,eAAO,MAAM,YAAY,qBASA,CAAC;AAE1B;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAmB,qBAAqB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,YAAY,qBAKA,CAAC;AAE1B;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAmB,qBAAqB,CAAC"}

package/dist/character-set.js

@@ -1,36 +0,0 @@
-import { CharacterSetCreator, Exclusions } from "@aidc-toolkit/utility";
-/**
- * GS1 AI encodable character set 82 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export const AI82_CREATOR = new CharacterSetCreator([
-    "!", "\"", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
-    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
-    ":", ";", "<", "=", ">", "?",
-    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
-    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
-    "_",
-    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
-    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
-], Exclusions.AllNumeric);
-/**
- * GS1 AI encodable character set 82 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export const AI82_VALIDATOR = AI82_CREATOR;
-/**
- * GS1 AI encodable character set 39 creator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs | GS1
- * General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export const AI39_CREATOR = new CharacterSetCreator([
-    "#", "-", "/",
-    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
-    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
-    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
-], Exclusions.AllNumeric);
-/**
- * GS1 AI encodable character set 39 validator as defined in section 7.11 of the {@link https://www.gs1.org/genspecs |
- * GS1 General Specifications}. Supports {@linkcode Exclusions.AllNumeric}.
- */
-export const AI39_VALIDATOR = AI39_CREATOR;
-//# sourceMappingURL=character-set.js.map

package/dist/character-set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"character-set.js","sourceRoot":"","sources":["../src/character-set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAA8B,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEpG;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,mBAAmB,CAAC;IAChD,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAChE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAChD,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAC5B,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAC/D,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAC/D,GAAG;IACH,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAC/D,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;CAClE,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;AAE1B;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,YAAqC,CAAC;AAEpE;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,mBAAmB,CAAC;IAChD,GAAG,EAAE,GAAG,EAAE,GAAG;IACb,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAChD,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAC/D,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;CAClE,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;AAE1B;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,YAAqC,CAAC"}