@aidc-toolkit/gs1 0.9.20-beta → 1.0.22-beta

package/test/gtin-validator.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "vitest";
+import {
+    GTINLevels,
+    type GTINType,
+    GTINTypes,
+    GTINValidator,
+    IdentifierTypes,
+    LeaderTypes,
+    type PrefixType,
+    PrefixTypes
+} from "../src";
+import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
+
+export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinType: GTINType): void {
+    let prefixType: PrefixType;
+
+    switch (gtinType) {
+        case GTINTypes.GTIN13:
+            prefixType = PrefixTypes.GS1CompanyPrefix;
+            break;
+
+        case GTINTypes.GTIN12:
+            prefixType = PrefixTypes.UPCCompanyPrefix;
+            break;
+
+        case GTINTypes.GTIN8:
+            prefixType = PrefixTypes.GS18Prefix;
+            break;
+
+        default:
+            throw new Error("Not supported");
+    }
+
+    validateNumericIdentifierValidator(validator, isCreator, IdentifierTypes.GTIN, prefixType, gtinType, LeaderTypes.IndicatorDigit);
+
+    expect(validator.gtinType).toBe(gtinType);
+}
+
+describe("GTIN validation and normalization", () => {
+    test("Validation", () => {
+        expect(() => {
+            GTINValidator.validateAny("9521873000122", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("19521873000129", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("9521873000160", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("95216843", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("95217800031", GTINLevels.Any);
+        }).toThrow("GTIN must be 13, 12, 8, or 14 digits long");
+        expect(() => {
+            GTINValidator.validateAny("614141773985", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("614141773991", GTINLevels.Any);
+        }).toThrow("Invalid check digit");
+        expect(() => {
+            GTINValidator.validateAny("09867539", GTINLevels.Any);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("09800037", GTINLevels.Any);
+        }).toThrow("Invalid zero-suppressed GTIN-12");
+        expect(() => {
+            GTINValidator.validateAny("9521873000122", GTINLevels.RetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("19521873000129", GTINLevels.RetailConsumer);
+        }).toThrow("GTIN not supported at retail consumer trade item level");
+        expect(() => {
+            GTINValidator.validateAny("9521873000160", GTINLevels.RetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("95216843", GTINLevels.RetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("95217800031", GTINLevels.RetailConsumer);
+        }).toThrow("GTIN must be 13, 12, 8, or 14 digits long");
+        expect(() => {
+            GTINValidator.validateAny("614141773985", GTINLevels.RetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("0614141773985", GTINLevels.RetailConsumer);
+        }).toThrow("GTIN-13 at retail consumer trade item level can't start with zero");
+        expect(() => {
+            GTINValidator.validateAny("614141773991", GTINLevels.RetailConsumer);
+        }).toThrow("Invalid check digit");
+        expect(() => {
+            GTINValidator.validateAny("09867539", GTINLevels.RetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("09800037", GTINLevels.RetailConsumer);
+        }).toThrow("Invalid zero-suppressed GTIN-12");
+        expect(() => {
+            GTINValidator.validateAny("9521873000122", GTINLevels.OtherThanRetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("19521873000129", GTINLevels.OtherThanRetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("9521873000160", GTINLevels.OtherThanRetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("95216843", GTINLevels.OtherThanRetailConsumer);
+        }).toThrow("GTIN not supported at other than retail consumer trade item level");
+        expect(() => {
+            GTINValidator.validateAny("95217800031", GTINLevels.OtherThanRetailConsumer);
+        }).toThrow("GTIN must be 13, 12, 8, or 14 digits long");
+        expect(() => {
+            GTINValidator.validateAny("614141773985", GTINLevels.OtherThanRetailConsumer);
+        }).not.toThrow(RangeError);
+        expect(() => {
+            GTINValidator.validateAny("614141773991", GTINLevels.OtherThanRetailConsumer);
+        }).toThrow("Invalid check digit");
+        expect(() => {
+            GTINValidator.validateAny("09867539", GTINLevels.OtherThanRetailConsumer);
+        }).toThrow("GTIN not supported at other than retail consumer trade item level");
+        expect(() => {
+            GTINValidator.validateAny("09800037", GTINLevels.OtherThanRetailConsumer);
+        }).toThrow("Invalid zero-suppressed GTIN-12");
+    });
+
+    test("Normalization", () => {
+        // GTIN-14.
+        expect(GTINValidator.normalize("09526543219996")).toBe("9526543219996");
+        expect(GTINValidator.normalize("00614141009992")).toBe("614141009992");
+        expect(() => GTINValidator.normalize("00000001234505")).toThrow("Invalid zero-suppressed GTIN-12 as GTIN-14");
+        expect(GTINValidator.normalize("00000095209999")).toBe("95209999");
+        expect(GTINValidator.normalize("49526543219994")).toBe("49526543219994");
+
+        // GTIN-13.
+        expect(GTINValidator.normalize("9526543219996")).toBe("9526543219996");
+        expect(GTINValidator.normalize("0614141009992")).toBe("614141009992");
+        expect(() => GTINValidator.normalize("0000001234505")).toThrow("Invalid zero-suppressed GTIN-12 as GTIN-13");
+        expect(GTINValidator.normalize("0000095209999")).toBe("95209999");
+
+        // GTIN-12.
+        expect(GTINValidator.normalize("614141009992")).toBe("614141009992");
+        expect(GTINValidator.normalize("01234505")).toBe("012000003455");
+        expect(() => GTINValidator.normalize("09800037")).toThrow("Invalid zero-suppressed GTIN-12");
+
+        // GTIN-8.
+        expect(GTINValidator.normalize("95209999")).toBe("95209999");
+    });
+});

package/test/identifier-creator.ts

@@ -0,0 +1,84 @@
+import { expect } from "vitest";
+import {
+    ContentCharacterSets,
+    type GTINType,
+    GTINTypes,
+    IdentifierTypes,
+    LeaderTypes,
+    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";
+
+export function validateIdentifierCreators(prefixManager: PrefixManager): void {
+    let gtinType: GTINType;
+
+    switch (prefixManager.prefixType) {
+        case PrefixTypes.GS1CompanyPrefix:
+            expect(prefixManager.prefix).toBe(prefixManager.gs1CompanyPrefix);
+            gtinType = GTINTypes.GTIN13;
+            break;
+
+        case PrefixTypes.UPCCompanyPrefix:
+            expect(prefixManager.prefix).toBe(prefixManager.upcCompanyPrefix);
+            gtinType = GTINTypes.GTIN12;
+            break;
+
+        case PrefixTypes.GS18Prefix:
+            expect(prefixManager.prefix).toBe(prefixManager.gs18Prefix);
+            gtinType = GTINTypes.GTIN8;
+            break;
+    }
+
+    expect(prefixManager.gtinCreator).toBe(prefixManager.gtinCreator);
+
+    validateGTINValidator(prefixManager.gtinCreator, true, gtinType);
+
+    if (prefixManager.prefixType !== PrefixTypes.GS18Prefix) {
+        // Validate creator caching.
+        expect(prefixManager.glnCreator).toBe(prefixManager.glnCreator);
+        expect(prefixManager.ssccCreator).toBe(prefixManager.ssccCreator);
+        expect(prefixManager.graiCreator).toBe(prefixManager.graiCreator);
+        expect(prefixManager.giaiCreator).toBe(prefixManager.giaiCreator);
+        expect(prefixManager.gsrnCreator).toBe(prefixManager.gsrnCreator);
+        expect(prefixManager.gdtiCreator).toBe(prefixManager.gdtiCreator);
+        expect(prefixManager.gincCreator).toBe(prefixManager.gincCreator);
+        expect(prefixManager.gsinCreator).toBe(prefixManager.gsinCreator);
+        expect(prefixManager.gcnCreator).toBe(prefixManager.gcnCreator);
+        expect(prefixManager.cpidCreator).toBe(prefixManager.cpidCreator);
+        expect(prefixManager.gmnCreator).toBe(prefixManager.gmnCreator);
+
+        validateNonGTINNumericIdentifierValidator(prefixManager.glnCreator, true, IdentifierTypes.GLN, 13, LeaderTypes.None);
+        validateNonGTINNumericIdentifierValidator(prefixManager.ssccCreator, true, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
+        validateSerializableNumericIdentifierValidator(prefixManager.graiCreator, true, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(prefixManager.giaiCreator, true, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(prefixManager.gsrnCreator, true, IdentifierTypes.GSRN, 18, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(prefixManager.gdtiCreator, true, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(prefixManager.gincCreator, true, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(prefixManager.gsinCreator, true, IdentifierTypes.GSIN, 17, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(prefixManager.gcnCreator, true, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
+        validateNonNumericIdentifierValidator(prefixManager.cpidCreator, true, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
+        validateNonNumericIdentifierValidator(prefixManager.gmnCreator, true, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);
+    } else {
+        expect(() => prefixManager.glnCreator).toThrow("GLN not supported by GS1-8 Prefix");
+        expect(() => prefixManager.ssccCreator).toThrow("SSCC not supported by GS1-8 Prefix");
+        expect(() => prefixManager.graiCreator).toThrow("GRAI not supported by GS1-8 Prefix");
+        expect(() => prefixManager.giaiCreator).toThrow("GIAI not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gsrnCreator).toThrow("GSRN not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gdtiCreator).toThrow("GDTI not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gincCreator).toThrow("GINC not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gsinCreator).toThrow("GSIN not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gcnCreator).toThrow("GCN not supported by GS1-8 Prefix");
+        expect(() => prefixManager.cpidCreator).toThrow("CPID not supported by GS1-8 Prefix");
+        expect(() => prefixManager.gmnCreator).toThrow("GMN not supported by GS1-8 Prefix");
+    }
+}
+
+export function testIdentifierCreatorCallback(callback?: () => void): void {
+    if (callback !== undefined) {
+        callback();
+    }
+}

package/test/identifier-validator.ts

@@ -0,0 +1,8 @@
+import { expect } from "vitest";
+import type { IdentifierType, IdentifierValidator, PrefixType } from "../src";
+
+export function validateIdentifierValidator(creator: IdentifierValidator, 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

@@ -0,0 +1,98 @@
+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";
+
+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");
+
+            expect(() => {
+                creator.validate(creator.create("O1234"), {
+                    exclusion: Exclusions.AllNumeric
+                });
+            }).not.toThrow(RangeError);
+        });
+    });
+}

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

@@ -0,0 +1,6 @@
+import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierValidator, PrefixTypes } from "../src";
+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);
+}

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

@@ -0,0 +1,24 @@
+import { expect } from "vitest";
+import {
+    type ContentCharacterSet,
+    type IdentifierType,
+    type NonNumericIdentifierCreator,
+    type NonNumericIdentifierValidator,
+    PrefixTypes
+} from "../src";
+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);
+
+    const referenceCreator = creatorFor(referenceCharacterSet);
+
+    expect(validator.referenceCharacterSet).toBe(referenceCharacterSet);
+    expect(validator.referenceCreator).toBe(referenceCreator);
+    expect(validator.requiresCheckCharacterPair).toBe(requiresCheckCharacterPair);
+
+    if (isCreator) {
+        expect((validator as NonNumericIdentifierCreator).referenceCreator).toBe(referenceCreator);
+    }
+}

package/test/numeric-identifier-creator.ts

@@ -0,0 +1,132 @@
+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, () => {
+        testIdentifierCreatorCallback(preTestCallback);
+
+        const prefix = creator.prefix;
+        const prefixLength = prefix.length;
+        const hasExtensionDigit = creator.leaderType === LeaderTypes.ExtensionDigit;
+        const prefixSubstringStart = Number(hasExtensionDigit);
+        const prefixSubstringEnd = prefixSubstringStart + prefixLength;
+        const referenceLength = creator.length - prefixLength - 1;
+        const referenceCount = Number(CharacterSetCreator.powerOf10(referenceLength));
+        const referenceSubstringStart = prefixSubstringEnd;
+        const referenceSubstringEnd = referenceSubstringStart + referenceLength - prefixSubstringStart;
+
+        function validate(identifier: string, index: number, sparse: boolean): void {
+            expect(() => {
+                creator.validate(identifier);
+            }).not.toThrow(RangeError);
+            expect(identifier).toBe(creator.create(index, sparse));
+
+            expect(identifier.length).toBe(creator.length);
+            expect(identifier.substring(prefixSubstringStart, prefixSubstringEnd)).toBe(prefix);
+            expect(hasValidCheckDigit(identifier)).toBe(true);
+        }
+
+        test("Straight", {
+            // Test can take a long time.
+            timeout: 20 * 1000
+        }, () => {
+            expect(creator.referenceLength).toBe(referenceLength);
+            expect(creator.capacity).toBe(Number(CharacterSetCreator.powerOf10(referenceLength)));
+
+            const sequenceIterator = creator.create(new Sequence(0, referenceCount))[Symbol.iterator]();
+
+            let index = 0;
+
+            for (const identifier of creator.createAll()) {
+                validate(identifier, index, false);
+
+                expect(Number((hasExtensionDigit ? identifier.charAt(0) : "") + identifier.substring(referenceSubstringStart, referenceSubstringEnd))).toBe(index);
+                expect(sequenceIterator.next().value).toBe(identifier);
+
+                index++;
+            }
+
+            expect(index).toBe(referenceCount);
+            expect(sequenceIterator.next().value).toBeUndefined();
+
+            const randomValues = new Array<number>();
+            const identifiers = new Array<string>();
+
+            for (let i = 0; i < 1000; i++) {
+                const randomValue = Math.floor(Math.random() * creator.capacity);
+
+                randomValues.push(randomValue);
+                identifiers.push(creator.create(randomValue));
+            }
+
+            expect(Array.from(creator.create(randomValues))).toStrictEqual(identifiers);
+        });
+
+        test("Sparse", () => {
+            const sparseReferenceCount = Math.min(referenceCount, 1000);
+
+            // Reference count of 1 is neither sequential nor sparse so treat it as sparse.
+            let sequential = sparseReferenceCount !== 1;
+
+            const sequenceSet = new Set<string>();
+
+            let index = 0;
+
+            for (const identifier of creator.create(new Sequence(0, sparseReferenceCount), true)) {
+                validate(identifier, index, true);
+
+                sequential &&= Number((hasExtensionDigit ? identifier.charAt(0) : "") + identifier.substring(referenceSubstringStart, referenceSubstringEnd)) === index;
+
+                expect(sequenceSet.has(identifier)).toBe(false);
+                sequenceSet.add(identifier);
+
+                index++;
+            }
+
+            expect(sequential).toBe(false);
+            expect(index).toBe(sparseReferenceCount);
+
+            const randomValues = new Array<number>();
+            const identifiers = new Array<string>();
+
+            for (let i = 0; i < 1000; i++) {
+                const randomValue = Math.floor(Math.random() * creator.capacity);
+
+                randomValues.push(randomValue);
+                identifiers.push(creator.create(randomValue, true));
+            }
+
+            expect(Array.from(creator.create(randomValues, true))).toStrictEqual(identifiers);
+        });
+
+        test("Validation position", () => {
+            const identifier = creator.create(0);
+
+            const badIdentifier1 = `${identifier.substring(0, identifier.length - 2)}O${identifier.substring(identifier.length - 1)}`;
+
+            expect(badIdentifier1.length).toBe(creator.length);
+            expect(() => {
+                creator.validate(badIdentifier1);
+            }).toThrow(`Invalid character 'O' at position ${creator.length - 1}`);
+
+            const badIdentifier2 = `${identifier.substring(0, 2)}O${identifier.substring(3)}`;
+
+            expect(badIdentifier2.length).toBe(creator.length);
+            expect(() => {
+                creator.validate(badIdentifier2);
+            }).toThrow("Invalid character 'O' at position 3");
+        });
+
+        test("Position offset", () => {
+            expect(() => {
+                creator.validate(creator.create(0), {
+                    positionOffset: 4
+                });
+            }).not.toThrow(RangeError);
+        });
+
+        testIdentifierCreatorCallback(postTestCallback);
+    });
+}

package/test/numeric-identifier-validator.ts

@@ -0,0 +1,23 @@
+import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
+import { expect } from "vitest";
+import {
+    ContentCharacterSets,
+    type IdentifierType,
+    type LeaderType,
+    type NumericIdentifierCreator,
+    type NumericIdentifierValidator,
+    type PrefixType
+} from "../src";
+import { validateIdentifierValidator } from "./identifier-validator.js";
+
+export function validateNumericIdentifierValidator(validator: NumericIdentifierValidator, isCreator: boolean, 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

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "vitest";
+import { PrefixManager, PrefixTypes } from "../src";
+import { validateIdentifierCreators } from "./identifier-creator.js";
+
+describe("Prefix manager", () => {
+    let prefixManager: PrefixManager;
+
+    function validateGTINStartsWithPrefix(length: number): void {
+        expect(prefixManager.gtinCreator.length).toBe(length);
+
+        const gtin = prefixManager.gtinCreator.create(0);
+
+        expect(gtin.startsWith(prefixManager.prefix)).toBe(true);
+        expect(gtin.length).toBe(length);
+
+        const gtin14 = prefixManager.gtinCreator.createGTIN14("5", 0);
+
+        expect(gtin14.startsWith("5" + prefixManager.gs1CompanyPrefix)).toBe(true);
+        expect(gtin14.length).toBe(14);
+    }
+
+    function validateNonGTINStartsWithGS1CompanyPrefix(): void {
+        const gln = prefixManager.glnCreator.create(0);
+
+        expect(gln.startsWith(prefixManager.gs1CompanyPrefix)).toBe(true);
+        expect(gln.length).toBe(prefixManager.glnCreator.length);
+
+        const grai = prefixManager.graiCreator.createSerialized(0, "1234");
+
+        expect(grai.startsWith(prefixManager.gs1CompanyPrefix)).toBe(true);
+        expect(grai.length).toBe(prefixManager.graiCreator.length + 4);
+
+        const giai = prefixManager.giaiCreator.create("1234");
+
+        expect(giai.startsWith(prefixManager.gs1CompanyPrefix)).toBe(true);
+        expect(giai.length).toBe(prefixManager.gs1CompanyPrefix.length + 4);
+    }
+
+    test("Prefix equivalence", () => {
+        expect(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234")).toBe(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234"));
+
+        expect(PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "614141")).toBe(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "0614141"));
+
+        expect(PrefixManager.get(PrefixTypes.GS18Prefix, "952")).toBe(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "00000952"));
+    });
+
+    test("GS1 Company Prefix 9521234", () => {
+        prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");
+
+        expect(prefixManager.prefixType).toBe(PrefixTypes.GS1CompanyPrefix);
+        expect(prefixManager.prefix).toBe("9521234");
+        expect(prefixManager.gs1CompanyPrefix).toBe(prefixManager.prefix);
+        expect(prefixManager.upcCompanyPrefix).toBeUndefined();
+        expect(prefixManager.gs18Prefix).toBeUndefined();
+
+        validateGTINStartsWithPrefix(13);
+        validateNonGTINStartsWithGS1CompanyPrefix();
+
+        validateIdentifierCreators(prefixManager);
+    });
+
+    test("U.P.C. Company Prefix 614141", () => {
+        prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "0614141");
+
+        expect(prefixManager.prefixType).toBe(PrefixTypes.UPCCompanyPrefix);
+        expect(prefixManager.prefix).toBe("614141");
+        expect(prefixManager.gs1CompanyPrefix).toBe("0" + prefixManager.prefix);
+        expect(prefixManager.upcCompanyPrefix).toBe(prefixManager.prefix);
+        expect(prefixManager.gs18Prefix).toBeUndefined();
+
+        validateGTINStartsWithPrefix(12);
+        validateNonGTINStartsWithGS1CompanyPrefix();
+
+        validateIdentifierCreators(prefixManager);
+    });
+
+    test("GS1-8 Prefix 952", () => {
+        prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "00000952");
+
+        expect(prefixManager.prefixType).toBe(PrefixTypes.GS18Prefix);
+        expect(prefixManager.prefix).toBe("952");
+        expect(prefixManager.gs1CompanyPrefix).toBe("00000" + prefixManager.prefix);
+        expect(prefixManager.upcCompanyPrefix).toBeUndefined();
+        expect(prefixManager.gs18Prefix).toBe(prefixManager.prefix);
+
+        validateGTINStartsWithPrefix(8);
+
+        validateIdentifierCreators(prefixManager);
+    });
+
+    test("Prefix validation", () => {
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952")).toThrow("Length 3 of GS1 Company Prefix must be greater than or equal to 4");
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9520")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952123456789")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234567890")).toThrow("Length 13 of GS1 Company Prefix must be less than or equal to 12");
+
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952123A56789")).toThrow("Invalid character 'A' at position 7 of GS1 Company Prefix");
+
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "61414")).toThrow("Length 5 of U.P.C. Company Prefix must be greater than or equal to 6");
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "614141")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "61414112345")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "614141123456")).toThrow("Length 12 of U.P.C. Company Prefix must be less than or equal to 11");
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "000614")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.UPCCompanyPrefix, "000061")).toThrow("U.P.C. Company Prefix can't start with \"0000\"");
+
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "00000952")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "000000952")).toThrow("GS1 Company Prefix can't start with \"000000\"");
+
+        expect(() => PrefixManager.get(PrefixTypes.GS18Prefix, "952")).not.toThrow(RangeError);
+        expect(() => PrefixManager.get(PrefixTypes.GS18Prefix, "0952")).toThrow("GS1-8 Prefix can't start with \"0\"");
+    });
+});