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

package/test/gtin-validator.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from "vitest";
 import {
-    type GTINBaseType,
+    type GTINBaseLength,
+    GTINLengths,
     GTINLevels,
-    GTINTypes,
     GTINValidator,
     IdentifierTypes,
     LeaderTypes,
@@ -11,26 +11,24 @@ import {
 } from "../src/index.js";
 import { validateNumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
-export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinBaseType: GTINBaseType): void {
+export function validateGTINValidator(validator: GTINValidator, isCreator: boolean, gtinBaseLength: GTINBaseLength): void {
     let prefixType: PrefixType;
 
-    switch (gtinBaseType) {
-        case GTINTypes.GTIN13:
+    switch (gtinBaseLength) {
+        case GTINLengths.GTIN13:
             prefixType = PrefixTypes.GS1CompanyPrefix;
             break;
 
-        case GTINTypes.GTIN12:
+        case GTINLengths.GTIN12:
             prefixType = PrefixTypes.UPCCompanyPrefix;
             break;
 
-        case GTINTypes.GTIN8:
+        case GTINLengths.GTIN8:
             prefixType = PrefixTypes.GS18Prefix;
             break;
     }
 
-    validateNumericIdentifierValidator(validator, IdentifierTypes.GTIN, prefixType, gtinBaseType, LeaderTypes.IndicatorDigit);
-
-    expect(validator.gtinType).toBe(gtinBaseType);
+    validateNumericIdentifierValidator(validator, IdentifierTypes.GTIN, prefixType, gtinBaseLength, LeaderTypes.IndicatorDigit);
 }
 
 describe("GTIN validation and normalization", () => {

package/test/identifier-creator.ts

@@ -1,8 +1,8 @@
 import { expect } from "vitest";
 import {
     ContentCharacterSets,
-    type GTINType,
-    GTINTypes,
+    type GTINLength,
+    GTINLengths,
     IdentifierTypes,
     LeaderTypes,
     type PrefixManager,
@@ -14,29 +14,29 @@ import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-
 import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 export function validateIdentifierCreators(prefixManager: PrefixManager): void {
-    let gtinType: GTINType;
+    let gtinLength: GTINLength;
 
     switch (prefixManager.prefixType) {
         case PrefixTypes.GS1CompanyPrefix:
             expect(prefixManager.prefix).toBe(prefixManager.gs1CompanyPrefix);
-            gtinType = GTINTypes.GTIN13;
+            gtinLength = GTINLengths.GTIN13;
             break;
 
         case PrefixTypes.UPCCompanyPrefix:
             expect(prefixManager.prefix).toBe(prefixManager.upcCompanyPrefix);
-            gtinType = GTINTypes.GTIN12;
+            gtinLength = GTINLengths.GTIN12;
             break;
 
         case PrefixTypes.GS18Prefix:
             expect(prefixManager.prefix).toBe(prefixManager.gs18Prefix);
-            gtinType = GTINTypes.GTIN8;
+            gtinLength = GTINLengths.GTIN8;
             break;
     }
 
     // Validate creator caching.
     expect(prefixManager.gtinCreator).toBe(prefixManager.gtinCreator);
 
-    validateGTINValidator(prefixManager.gtinCreator, true, gtinType);
+    validateGTINValidator(prefixManager.gtinCreator, true, gtinLength);
 
     if (prefixManager.prefixType !== PrefixTypes.GS18Prefix) {
         // Validate creator caching.

package/test/mixin.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+import {
+    GTINBaseLengths,
+    type IdentifierCreator,
+    IdentifierTypes,
+    IdentifierValidators,
+    PrefixManager,
+    PrefixTypes
+} from "../src/index.js";
+
+describe("Mixins", () => {
+    function validate<TValidator extends object, TCreator extends TValidator & IdentifierCreator>(validator: TValidator, creator: TCreator): void {
+        for (const key of Object.keys(validator)) {
+            expect(key in creator, key).toBe(true);
+        }
+    }
+
+    const prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");
+
+    test(IdentifierTypes.GTIN, () => {
+        validate(IdentifierValidators.GTIN[GTINBaseLengths.GTIN13], prefixManager.gtinCreator);
+    });
+
+    test("Non-serialized numeric", () => {
+        validate(IdentifierValidators.GLN, prefixManager.glnCreator);
+    });
+
+    test("Serialized numeric", () => {
+        validate(IdentifierValidators.GRAI, prefixManager.graiCreator);
+    });
+
+    test("Non-numeric", () => {
+        validate(IdentifierValidators.GIAI, prefixManager.giaiCreator);
+    });
+});

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

@@ -1,6 +1,11 @@
-import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierValidator, PrefixTypes } from "../src/index.js";
+import {
+    type IdentifierType,
+    type LeaderType,
+    type NonSerializableNumericIdentifierValidator,
+    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 {
+export function validateNonGTINNumericIdentifierValidator(validator: NonSerializableNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, leaderType: LeaderType): void {
     validateNumericIdentifierValidator(validator, identifierType, PrefixTypes.GS1CompanyPrefix, length, leaderType);
 }

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

@@ -7,12 +7,12 @@ import {
     PrefixTypes
 } from "../src/index.js";
 import { validateIdentifierValidator } from "./identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { characterSetCreatorFor } 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);
+    const referenceCreator = characterSetCreatorFor(referenceCharacterSet);
 
     expect(validator.referenceCharacterSet).toBe(referenceCharacterSet);
     expect(validator.referenceCreator).toBe(referenceCreator);

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

@@ -0,0 +1,64 @@
+import { expect, test } from "vitest";
+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, () => {
+        test("Mapping", () => {
+            expect(isSerializableNumericIdentifierCreator(creator)).toBe(true);
+        });
+    }, () => {
+        test("Serialization", () => {
+            const identifier = creator.create(0, true);
+            const serial = "12345678";
+            const serializedIdentifier = identifier + serial;
+            const serials = [serial, "23456789", "34567890", "456789012"];
+            const serializedIdentifiers = serials.map(serial => identifier + serial);
+
+            expect(creator.createSerialized(0, serial, true)).toBe(serializedIdentifier);
+            expect(creator.concatenate(identifier, serial)).toBe(serializedIdentifier);
+            expect(Array.from(creator.createSerialized(0, serials, true))).toStrictEqual(serializedIdentifiers);
+            expect(Array.from(creator.concatenate(identifier, serials))).toStrictEqual(serializedIdentifiers);
+
+            const fullLengthSerial = "0".repeat(creator.serialComponentLength);
+            const fullLengthPlusOneSerial = fullLengthSerial + "0";
+            const fullLengthPlusOneSerialErrorMessage = `Length ${creator.serialComponentLength + 1} of serial component must be less than or equal to ${creator.serialComponentLength}`;
+
+            expect(() => creator.createSerialized(0, fullLengthSerial, true)).not.toThrow(RangeError);
+            expect(() => creator.concatenate(identifier, fullLengthSerial)).not.toThrow(RangeError);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthSerial], true))).not.toThrow(RangeError);
+            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthSerial]))).not.toThrow(RangeError);
+            expect(() => creator.createSerialized(0, fullLengthPlusOneSerial, true)).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => creator.concatenate(identifier, fullLengthPlusOneSerial)).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, fullLengthPlusOneSerial], true))).toThrow(fullLengthPlusOneSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(identifier, [...serials, fullLengthPlusOneSerial]))).toThrow(fullLengthPlusOneSerialErrorMessage);
+
+            let invalidSerial: string;
+
+            switch (creator.serialComponentCharacterSet) {
+                case ContentCharacterSets.Numeric:
+                    invalidSerial = "1234A5678";
+                    break;
+
+                case ContentCharacterSets.AI82:
+                    invalidSerial = "ABCD~1234";
+                    break;
+
+                case ContentCharacterSets.AI39:
+                    invalidSerial = "ABCD%1234";
+                    break;
+            }
+
+            const invalidSerialErrorMessage = `Invalid character '${invalidSerial.charAt(4)}' at position 5 of serial component`;
+
+            expect(() => creator.createSerialized(0, invalidSerial, true)).toThrow(invalidSerialErrorMessage);
+            expect(() => creator.concatenate(identifier, invalidSerial)).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.createSerialized(0, [...serials, invalidSerial], true))).toThrow(invalidSerialErrorMessage);
+            expect(() => Array.from(creator.concatenate(identifier, [...serials, invalidSerial]))).toThrow(invalidSerialErrorMessage);
+        });
+    });
+}

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

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

package/test/numeric-identifier-creator.ts

@@ -3,16 +3,21 @@ import { describe, expect, test } from "vitest";
 import {
     hasValidCheckDigit,
     isGTINCreator,
+    isNumericIdentifierCreator,
     LeaderTypes,
     type NumericIdentifierCreator,
-    type NumericIdentifierDescriptor
+    type NumericIdentifierType
 } from "../src/index.js";
 import { testIdentifierCreatorCallback } from "./identifier-creator.js";
 
-export function testNumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor>(creator: NumericIdentifierCreator<TNumericIdentifierDescriptor>, preTestCallback?: () => void, postTestCallback?: () => void): void {
+export function testNumericIdentifierCreator<TNumericIdentifierType extends NumericIdentifierType>(creator: NumericIdentifierCreator<TNumericIdentifierType>, preTestCallback?: () => void, postTestCallback?: () => void): void {
     describe(isGTINCreator(creator) ? `${creator.identifierType}-${creator.length}` : creator.identifierType as string, () => {
         testIdentifierCreatorCallback(preTestCallback);
 
+        test("Mapping", () => {
+            expect(isNumericIdentifierCreator(creator)).toBe(true);
+        });
+
         const prefix = creator.prefix;
         const prefixLength = prefix.length;
         const hasExtensionDigit = creator.leaderType === LeaderTypes.ExtensionDigit;

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

@@ -7,12 +7,12 @@ import type {
     SerializableNumericIdentifierValidator
 } from "../src/index.js";
 import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { characterSetCreatorFor } 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);
 
-    const serialCreator = creatorFor(serialCharacterSet);
+    const serialCreator = characterSetCreatorFor(serialCharacterSet);
 
     expect(validator.serialComponentLength).toBe(serialLength);
     expect(validator.serialComponentCharacterSet).toBe(serialCharacterSet);

package/test/utility.ts

@@ -1,22 +1,22 @@
 import { type CharacterSetCreator, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src/index.js";
 
-export function creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
-    let creator: CharacterSetCreator;
+export function characterSetCreatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
+    let characterSetCreator: CharacterSetCreator;
 
     switch (characterSet) {
         case ContentCharacterSets.Numeric:
-            creator = NUMERIC_CREATOR;
+            characterSetCreator = NUMERIC_CREATOR;
             break;
 
         case ContentCharacterSets.AI82:
-            creator = AI82_CREATOR;
+            characterSetCreator = AI82_CREATOR;
             break;
 
         case ContentCharacterSets.AI39:
-            creator = AI39_CREATOR;
+            characterSetCreator = AI39_CREATOR;
             break;
     }
 
-    return creator;
+    return characterSetCreator;
 }

package/test/validator.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from "vitest";
 import {
     ContentCharacterSets,
-    type GTINBaseType,
-    GTINTypes,
+    type GTINBaseLength,
+    GTINLengths,
     type GTINValidator,
     type IdentifierType,
     IdentifierTypes,
@@ -12,6 +12,7 @@ import {
     isGTINValidators,
     isNonGTINNumericIdentifierValidator,
     isNonNumericIdentifierValidator,
+    isNonSerializableNumericIdentifierValidator,
     isNumericIdentifierValidator,
     isSerializableNumericIdentifierValidator,
     LeaderTypes
@@ -22,7 +23,7 @@ import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-
 import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
 
 describe("Validators", () => {
-    function validateMapping(identifierType: IdentifierType, expectedIdentifierValidatorsOrValidator: Readonly<Record<GTINBaseType, GTINValidator>> | IdentifierValidator, ...isIdentifierValidatorTypes: Array<(validator: IdentifierValidator) => boolean>): void {
+    function validateMapping(identifierType: IdentifierType, expectedIdentifierValidatorsOrValidator: Readonly<Record<GTINBaseLength, GTINValidator>> | IdentifierValidator, ...isIdentifierValidatorTypes: Array<(validator: IdentifierValidator) => boolean>): void {
         test(identifierType, () => {
             const validatorsOrValidator = IdentifierValidators[identifierType];
 
@@ -44,23 +45,23 @@ describe("Validators", () => {
 
     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.GLN, IdentifierValidators.GLN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isNonSerializableNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.SSCC, IdentifierValidators.SSCC, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isNonSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GRAI, IdentifierValidators.GRAI, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GIAI, IdentifierValidators.GIAI, isNonNumericIdentifierValidator);
-        validateMapping(IdentifierTypes.GSRN, IdentifierValidators.GSRN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GSRN, IdentifierValidators.GSRN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isNonSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GDTI, IdentifierValidators.GDTI, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GINC, IdentifierValidators.GINC, isNonNumericIdentifierValidator);
-        validateMapping(IdentifierTypes.GSIN, IdentifierValidators.GSIN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator);
+        validateMapping(IdentifierTypes.GSIN, IdentifierValidators.GSIN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isNonSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GCN, IdentifierValidators.GCN, isNumericIdentifierValidator, isNonGTINNumericIdentifierValidator, isSerializableNumericIdentifierValidator);
         validateMapping(IdentifierTypes.CPID, IdentifierValidators.CPID, isNonNumericIdentifierValidator);
         validateMapping(IdentifierTypes.GMN, IdentifierValidators.GMN, isNonNumericIdentifierValidator);
     });
 
     test("Structure", () => {
-        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN13], false, GTINTypes.GTIN13);
-        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN12], false, GTINTypes.GTIN12);
-        validateGTINValidator(IdentifierValidators.GTIN[GTINTypes.GTIN8], false, GTINTypes.GTIN8);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN13], false, GTINLengths.GTIN13);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN12], false, GTINLengths.GTIN12);
+        validateGTINValidator(IdentifierValidators.GTIN[GTINLengths.GTIN8], false, GTINLengths.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);

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

@@ -68,40 +68,40 @@ describe("Variable measure RCN", () => {
         expect(() => GTINCreator.createVariableMeasureRCN("2IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
 
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "2543211234540");
+            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "2543211234540");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "25432112345");
+            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "25432112345");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("3PPPPPIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("20PPPPPIIIIC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("20PPPPPIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIII", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIII", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIKC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIKC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPIIPIIC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIPIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPIPPIIIIIC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2PPIPPIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIC", "25432112345");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIC", "25432112345");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIIIC", "2543211234540");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIIC", "2543211234540");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2PPPPPPPPPPC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2PPPPPPPPPPC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("2IIIIIIIIIIC", "254321123454");
+            GTINValidator.parseVariableMeasureRCN("2IIIIIIIIIIC", "254321123454");
         }).toThrow("Invalid variable measure RCN format");
     });
 
@@ -165,37 +165,37 @@ describe("Variable measure RCN", () => {
         expect(() => GTINCreator.createVariableMeasureRCN("27IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
 
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "27543211234570");
+            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "27543211234570");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "275432112345");
+            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "275432112345");
         }).toThrow("RCN length must match format length");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("30PPPPPIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("20PPPPPIIIIII", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("20PPPPPIIIIII", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("21PPPPPIIIIKC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("21PPPPPIIIIKC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("22PPPPPIIPIIC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("22PPPPPIIPIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("23PPIPPIIIIIC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("23PPIPPIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("24PPPPPIIIIC", "275432112345");
+            GTINValidator.parseVariableMeasureRCN("24PPPPPIIIIC", "275432112345");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("25PPPPPIIIIIIC", "27543211234570");
+            GTINValidator.parseVariableMeasureRCN("25PPPPPIIIIIIC", "27543211234570");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("26PPPPPPPPPPC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("26PPPPPPPPPPC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
         expect(() => {
-            GTINCreator.parseVariableMeasureRCN("27IIIIIIIIIIC", "2754321123457");
+            GTINValidator.parseVariableMeasureRCN("27IIIIIIIIIIC", "2754321123457");
         }).toThrow("Invalid variable measure RCN format");
     });
 });

package/dist/abstract-identifier-validator.d.ts

@@ -1,95 +0,0 @@
-import { type CharacterSetCreator } from "@aidc-toolkit/utility";
-import { type ContentCharacterSet } from "./content-character-set.js";
-import type { IdentifierDescriptor } from "./identifier-descriptor.js";
-import type { IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
-/**
- * Abstract identifier validator. Implements common functionality for an identifier validator.
- *
- * @template TIdentifierDescriptor
- * Identifier descriptor type.
- *
- * @template TIdentifierValidation
- * Identifier validation type.
- */
-export declare abstract class AbstractIdentifierValidator<TIdentifierDescriptor extends IdentifierDescriptor, TIdentifierValidation extends IdentifierValidation> implements IdentifierValidator<TIdentifierDescriptor, TIdentifierValidation> {
-    private static readonly CHARACTER_SET_CREATORS;
-    /**
-     * Identifier type.
-     */
-    private readonly _identifierType;
-    /**
-     * Length.
-     */
-    private readonly _length;
-    /**
-     * Reference character set.
-     */
-    private readonly _referenceCharacterSet;
-    /**
-     * Reference creator.
-     */
-    private readonly _referenceCreator;
-    /**
-     * Get the character set creator for a character set.
-     *
-     * @param characterSet
-     * Character set.
-     *
-     * @returns
-     * Character set creator.
-     */
-    protected static creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator;
-    /**
-     * Constructor.
-     *
-     * @param identifierDescriptor
-     * Identifier descriptor.
-     */
-    protected constructor(identifierDescriptor: IdentifierDescriptor);
-    /**
-     * @inheritDoc
-     */
-    get identifierType(): TIdentifierDescriptor["identifierType"];
-    /**
-     * @inheritDoc
-     */
-    get prefixType(): TIdentifierDescriptor["prefixType"];
-    /**
-     * @inheritDoc
-     */
-    get length(): number;
-    /**
-     * @inheritDoc
-     */
-    get referenceCharacterSet(): TIdentifierDescriptor["referenceCharacterSet"];
-    /**
-     * @inheritDoc
-     */
-    get referenceCreator(): CharacterSetCreator;
-    /**
-     * Pad an identifier on the left with zero-value character for validation purposes. This is done to align an
-     * identifier with a position offset for any error message that may be thrown by the reference validator.
-     *
-     * @param identifier
-     * Identifier.
-     *
-     * @param positionOffset
-     * Position offset within a larger string.
-     *
-     * @returns
-     * Padded identifier.
-     */
-    protected padIdentifier(identifier: string, positionOffset?: number): string;
-    /**
-     * Validate the prefix within an identifier.
-     *
-     * @param partialIdentifier
-     * Partial identifier.
-     *
-     * @param positionOffset
-     * Position offset within a larger string.
-     */
-    protected validatePrefix(partialIdentifier: string, positionOffset?: number): void;
-    abstract validate(identifier: string, validation?: TIdentifierValidation): void;
-}
-//# sourceMappingURL=abstract-identifier-validator.d.ts.map

package/dist/abstract-identifier-validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract-identifier-validator.d.ts","sourceRoot":"","sources":["../src/abstract-identifier-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAmB,MAAM,uBAAuB,CAAC;AAElF,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,4BAA4B,CAAC;AAC5F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAI3F;;;;;;;;GAQG;AACH,8BAAsB,2BAA2B,CAAC,qBAAqB,SAAS,oBAAoB,EAAE,qBAAqB,SAAS,oBAAoB,CAAE,YAAW,mBAAmB,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IAClO,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAI5C;IAEF;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAE1E;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAiD;IAExF;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;IAExD;;;;;;;;OAQG;IACH,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,EAAE,mBAAmB,GAAG,mBAAmB;IAInF;;;;;OAKG;IACH,SAAS,aAAa,oBAAoB,EAAE,oBAAoB;IAOhE;;OAEG;IACH,IAAI,cAAc,IAAI,qBAAqB,CAAC,gBAAgB,CAAC,CAE5D;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,qBAAqB,CAAC,YAAY,CAAC,CAGpD;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;OAEG;IACH,IAAI,qBAAqB,IAAI,qBAAqB,CAAC,uBAAuB,CAAC,CAE1E;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,mBAAmB,CAE1C;IAED;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM;IAK5E;;;;;;;;OAQG;IACH,SAAS,CAAC,cAAc,CAAC,iBAAiB,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAKlF,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,qBAAqB,GAAG,IAAI;CAClF"}