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

package/test/identifier-creator.ts

@@ -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 { 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

@@ -2,5 +2,5 @@ import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierVali
 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/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 {
+    hasValidCheckDigit,
+    isGTINCreator,
+    LeaderTypes,
+    type NumericIdentifierCreator,
+    type NumericIdentifierDescriptor
+} 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, () => {
+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";
 
-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/serializable-numeric-identifier-creator.ts

@@ -1,9 +1,17 @@
 import { expect, test } from "vitest";
-import { ContentCharacterSets, type SerializableNumericIdentifierCreator } from "../src";
+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/validator.test.ts

@@ -1,25 +1,20 @@
 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";
 import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
@@ -27,26 +22,55 @@ import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-
 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);
     });
 });