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

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/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-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/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"}

package/dist/abstract-identifier-validator.js

@@ -1,123 +0,0 @@
-import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { AI39_CREATOR, AI82_CREATOR } from "./character-set.js";
-import { ContentCharacterSets } from "./content-character-set.js";
-import { PrefixTypes } from "./prefix-type.js";
-import { PrefixValidator } from "./prefix-validator.js";
-/**
- * Abstract identifier validator. Implements common functionality for an identifier validator.
- *
- * @template TIdentifierDescriptor
- * Identifier descriptor type.
- *
- * @template TIdentifierValidation
- * Identifier validation type.
- */
-export class AbstractIdentifierValidator {
-    static CHARACTER_SET_CREATORS = {
-        [ContentCharacterSets.Numeric]: NUMERIC_CREATOR,
-        [ContentCharacterSets.AI82]: AI82_CREATOR,
-        [ContentCharacterSets.AI39]: AI39_CREATOR
-    };
-    /**
-     * Identifier type.
-     */
-    _identifierType;
-    /**
-     * Length.
-     */
-    _length;
-    /**
-     * Reference character set.
-     */
-    _referenceCharacterSet;
-    /**
-     * Reference creator.
-     */
-    _referenceCreator;
-    /**
-     * Get the character set creator for a character set.
-     *
-     * @param characterSet
-     * Character set.
-     *
-     * @returns
-     * Character set creator.
-     */
-    static creatorFor(characterSet) {
-        return AbstractIdentifierValidator.CHARACTER_SET_CREATORS[characterSet];
-    }
-    /**
-     * Constructor.
-     *
-     * @param identifierDescriptor
-     * Identifier descriptor.
-     */
-    constructor(identifierDescriptor) {
-        this._identifierType = identifierDescriptor.identifierType;
-        this._length = identifierDescriptor.length;
-        this._referenceCharacterSet = identifierDescriptor.referenceCharacterSet;
-        this._referenceCreator = AbstractIdentifierValidator.creatorFor(identifierDescriptor.referenceCharacterSet);
-    }
-    /**
-     * @inheritDoc
-     */
-    get identifierType() {
-        return this._identifierType;
-    }
-    /**
-     * @inheritDoc
-     */
-    get prefixType() {
-        // All identifier types except GTIN support only the GS1 Company Prefix.
-        return PrefixTypes.GS1CompanyPrefix;
-    }
-    /**
-     * @inheritDoc
-     */
-    get length() {
-        return this._length;
-    }
-    /**
-     * @inheritDoc
-     */
-    get referenceCharacterSet() {
-        return this._referenceCharacterSet;
-    }
-    /**
-     * @inheritDoc
-     */
-    get referenceCreator() {
-        return this._referenceCreator;
-    }
-    /**
-     * 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.
-     */
-    padIdentifier(identifier, positionOffset) {
-        // Identifier is returned as is if position offset is undefined.
-        return positionOffset === undefined ? identifier : this.referenceCreator.character(0).repeat(positionOffset).concat(identifier);
-    }
-    /**
-     * Validate the prefix within an identifier.
-     *
-     * @param partialIdentifier
-     * Partial identifier.
-     *
-     * @param positionOffset
-     * Position offset within a larger string.
-     */
-    validatePrefix(partialIdentifier, positionOffset) {
-        // Delegate to prefix validator with support for U.P.C. Company Prefix but not GS1-8 Prefix.
-        PrefixValidator.validate(this.prefixType, true, false, partialIdentifier, true, this.referenceCharacterSet === ContentCharacterSets.Numeric, positionOffset);
-    }
-}
-//# sourceMappingURL=abstract-identifier-validator.js.map

package/dist/abstract-identifier-validator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract-identifier-validator.js","sourceRoot":"","sources":["../src/abstract-identifier-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAA4B,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAG5F,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,OAAgB,2BAA2B;IACrC,MAAM,CAAU,sBAAsB,GAAqD;QAC/F,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,eAAe;QAC/C,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,YAAY;QACzC,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,YAAY;KAC5C,CAAC;IAEF;;OAEG;IACc,eAAe,CAA0C;IAE1E;;OAEG;IACc,OAAO,CAAS;IAEjC;;OAEG;IACc,sBAAsB,CAAiD;IAExF;;OAEG;IACc,iBAAiB,CAAsB;IAExD;;;;;;;;OAQG;IACO,MAAM,CAAC,UAAU,CAAC,YAAiC;QACzD,OAAO,2BAA2B,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;OAKG;IACH,YAAsB,oBAA0C;QAC5D,IAAI,CAAC,eAAe,GAAG,oBAAoB,CAAC,cAAc,CAAC;QAC3D,IAAI,CAAC,OAAO,GAAG,oBAAoB,CAAC,MAAM,CAAC;QAC3C,IAAI,CAAC,sBAAsB,GAAG,oBAAoB,CAAC,qBAAqB,CAAC;QACzE,IAAI,CAAC,iBAAiB,GAAG,2BAA2B,CAAC,UAAU,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;IAChH,CAAC;IAED;;OAEG;IACH,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,IAAI,UAAU;QACV,wEAAwE;QACxE,OAAO,WAAW,CAAC,gBAAgB,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAI,qBAAqB;QACrB,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAClC,CAAC;IAED;;;;;;;;;;;;OAYG;IACO,aAAa,CAAC,UAAkB,EAAE,cAAuB;QAC/D,gEAAgE;QAChE,OAAO,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACpI,CAAC;IAED;;;;;;;;OAQG;IACO,cAAc,CAAC,iBAAyB,EAAE,cAAuB;QACvE,4FAA4F;QAC5F,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,CAAC,qBAAqB,KAAK,oBAAoB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACjK,CAAC"}

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

@@ -1,35 +0,0 @@
-import { AbstractIdentifierValidator } from "./abstract-identifier-validator.js";
-import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
-import type { NumericIdentifierValidation, NumericIdentifierValidator } from "./numeric-identifier-validator.js";
-/**
- * Abstract numeric identifier validator.
- *
- * @template TNumericIdentifierDescriptor
- * Numeric identifier descriptor type.
- */
-export declare abstract class AbstractNumericIdentifierValidator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor> extends AbstractIdentifierValidator<TNumericIdentifierDescriptor, NumericIdentifierValidation> implements NumericIdentifierValidator<TNumericIdentifierDescriptor> {
-    /**
-     * Leader type.
-     */
-    private readonly _leaderType;
-    /**
-     * Prefix position, determined by the leader type.
-     */
-    private readonly _prefixPosition;
-    /**
-     * Constructor.
-     *
-     * @param identifierDescriptor
-     * Identifier descriptor.
-     */
-    constructor(identifierDescriptor: NumericIdentifierDescriptor);
-    /**
-     * @inheritDoc
-     */
-    get leaderType(): TNumericIdentifierDescriptor["leaderType"];
-    /**
-     * @inheritDoc
-     */
-    validate(identifier: string, validation?: NumericIdentifierValidation): void;
-}
-//# sourceMappingURL=abstract-numeric-identifier-validator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"abstract-numeric-identifier-validator.d.ts","sourceRoot":"","sources":["../src/abstract-numeric-identifier-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAGjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEtF,OAAO,KAAK,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAEjH;;;;;GAKG;AACH,8BAAsB,kCAAkC,CAAC,4BAA4B,SAAS,2BAA2B,CAAE,SAAQ,2BAA2B,CAAC,4BAA4B,EAAE,2BAA2B,CAAE,YAAW,0BAA0B,CAAC,4BAA4B,CAAC;IACzR;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6C;IAEzE;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC;;;;;OAKG;gBACS,oBAAoB,EAAE,2BAA2B;IAO7D;;OAEG;IACH,IAAI,UAAU,IAAI,4BAA4B,CAAC,YAAY,CAAC,CAE3D;IAED;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,2BAA2B,GAAG,IAAI;CAqB/E"}

package/dist/abstract-numeric-identifier-validator.js

@@ -1,61 +0,0 @@
-import { AbstractIdentifierValidator } from "./abstract-identifier-validator.js";
-import { hasValidCheckDigit } from "./check.js";
-import { i18nextGS1 } from "./locale/i18n.js";
-import { LeaderTypes } from "./numeric-identifier-type.js";
-/**
- * Abstract numeric identifier validator.
- *
- * @template TNumericIdentifierDescriptor
- * Numeric identifier descriptor type.
- */
-export class AbstractNumericIdentifierValidator extends AbstractIdentifierValidator {
-    /**
-     * Leader type.
-     */
-    _leaderType;
-    /**
-     * Prefix position, determined by the leader type.
-     */
-    _prefixPosition;
-    /**
-     * Constructor.
-     *
-     * @param identifierDescriptor
-     * Identifier descriptor.
-     */
-    constructor(identifierDescriptor) {
-        super(identifierDescriptor);
-        this._leaderType = identifierDescriptor.leaderType;
-        this._prefixPosition = Number(this.leaderType === LeaderTypes.ExtensionDigit);
-    }
-    /**
-     * @inheritDoc
-     */
-    get leaderType() {
-        return this._leaderType;
-    }
-    /**
-     * @inheritDoc
-     */
-    validate(identifier, validation) {
-        // Validate the prefix, with care taken for its position within the identifier.
-        if (this._prefixPosition === 0) {
-            super.validatePrefix(identifier, validation?.positionOffset);
-        }
-        else {
-            super.validatePrefix(identifier.substring(this._prefixPosition), validation?.positionOffset === undefined ? this._prefixPosition : validation.positionOffset + this._prefixPosition);
-        }
-        // Validate the length.
-        if (identifier.length !== this.length) {
-            throw new RangeError(i18nextGS1.t("Identifier.identifierTypeLength", {
-                identifierType: this.identifierType,
-                length: this.length
-            }));
-        }
-        // Validating the check digit will also validate the characters.
-        if (!hasValidCheckDigit(this.padIdentifier(identifier, validation?.positionOffset))) {
-            throw new RangeError(i18nextGS1.t("Identifier.invalidCheckDigit"));
-        }
-    }
-}
-//# sourceMappingURL=abstract-numeric-identifier-validator.js.map