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

package/test/creator.test.ts

@@ -1,9 +1,9 @@
 import { describe } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
-import { testGTINCreator } from "./gtin-creator";
-import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
-import { testNonNumericIdentifierCreator } from "./non-numeric-identifier-creator";
-import { testSerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
+import { testGTINCreator } from "./gtin-creator.js";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
+import { testNonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
+import { testSerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
 
 describe("Creators", () => {
     testGTINCreator(PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "952123456").gtinCreator);

package/test/gtin-creator.ts

@@ -1,7 +1,14 @@
 import { CharacterSetCreator, Sequence } from "@aidc-toolkit/utility";
 import { expect, test } from "vitest";
-import { type GTINCreator, GTINTypes, GTINValidator, hasValidCheckDigit, isGTINCreator, PrefixTypes } from "../src";
-import { testNumericIdentifierCreator } from "./numeric-identifier-creator";
+import {
+    type GTINCreator,
+    GTINLengths,
+    GTINValidator,
+    hasValidCheckDigit,
+    isGTINCreator,
+    PrefixTypes
+} from "../src/index.js";
+import { testNumericIdentifierCreator } from "./numeric-identifier-creator.js";
 
 export function testGTINCreator(creator: GTINCreator): void {
     testNumericIdentifierCreator(creator, () => {
@@ -111,7 +118,7 @@ export function testGTINCreator(creator: GTINCreator): void {
             expect(Array.from(creator.createGTIN14("5", randomValues, true))).toStrictEqual(identifiers);
         });
 
-        if (creator.gtinType === GTINTypes.GTIN12) {
+        if (creator.length === GTINLengths.GTIN12) {
             test("Zero-suppress GTIN-12 rule 1", () => {
                 expect(GTINValidator.zeroSuppress("012345000058")).toBe("01234558");
                 expect(GTINValidator.zeroSuppress("012345000065")).toBe("01234565");

package/test/gtin-validator.test.ts

@@ -1,36 +1,34 @@
 import { describe, expect, test } from "vitest";
 import {
-    type GTINBaseType,
+    type GTINBaseLength,
+    GTINLengths,
     GTINLevels,
-    GTINTypes,
     GTINValidator,
     IdentifierTypes,
     LeaderTypes,
     type PrefixType,
     PrefixTypes
-} from "../src";
-import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
+} 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,42 +1,42 @@
 import { expect } from "vitest";
 import {
     ContentCharacterSets,
-    type GTINType,
-    GTINTypes,
+    type GTINLength,
+    GTINLengths,
     IdentifierTypes,
     LeaderTypes,
     type PrefixManager,
     PrefixTypes
-} from "../src";
-import { validateGTINValidator } from "./gtin-validator.test";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator";
-import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator";
+} from "../src/index.js";
+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;
+    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/identifier-validator.ts

@@ -1,5 +1,5 @@
 import { expect } from "vitest";
-import type { IdentifierType, IdentifierTypeValidator, PrefixType } from "../src";
+import type { IdentifierType, IdentifierTypeValidator, PrefixType } from "../src/index.js";
 
 export function validateIdentifierValidator<TIdentifierType extends IdentifierType>(creator: IdentifierTypeValidator<TIdentifierType>, identifierType: IdentifierType, prefixType: PrefixType, length: number): void {
     expect(creator.identifierType).toBe(identifierType);

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

@@ -1,7 +1,7 @@
 import { expect, test } from "vitest";
-import { isNonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierCreator } from "../src";
-import { testIdentifierCreatorCallback } from "./identifier-creator";
-import { testNumericIdentifierCreator } from "./numeric-identifier-creator";
+import { isNonGTINNumericIdentifierCreator, type NonGTINNumericIdentifierCreator } from "../src/index.js";
+import { testIdentifierCreatorCallback } from "./identifier-creator.js";
+import { testNumericIdentifierCreator } from "./numeric-identifier-creator.js";
 
 export function testNonGTINNumericIdentifierCreator(creator: NonGTINNumericIdentifierCreator, preTestCallback?: () => void, postTestCallback?: () => void): void {
     testNumericIdentifierCreator(creator, () => {

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

@@ -1,6 +1,11 @@
-import { type IdentifierType, type LeaderType, type NonGTINNumericIdentifierValidator, PrefixTypes } from "../src";
-import { validateNumericIdentifierValidator } from "./numeric-identifier-validator";
+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-creator.ts

@@ -1,6 +1,6 @@
 import { Exclusions, Sequence } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
-import { hasValidCheckCharacterPair, isNonNumericIdentifierCreator, type NonNumericIdentifierCreator } from "../src";
+import { hasValidCheckCharacterPair, isNonNumericIdentifierCreator, type NonNumericIdentifierCreator } from "../src/index.js";
 
 const TEST_REFERENCE_LENGTH = 2;
 

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

@@ -5,9 +5,9 @@ import {
     type NonNumericIdentifierCreator,
     type NonNumericIdentifierValidator,
     PrefixTypes
-} from "../src";
-import { validateIdentifierValidator } from "./identifier-validator";
-import { creatorFor } from "./utility";
+} from "../src/index.js";
+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);

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
-} from "../src";
-import { testIdentifierCreatorCallback } from "./identifier-creator";
+    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/numeric-identifier-validator.ts

@@ -7,8 +7,8 @@ import {
     type LeaderType,
     type NumericIdentifierType,
     type PrefixType
-} from "../src";
-import { validateIdentifierValidator } from "./identifier-validator";
+} from "../src/index.js";
+import { validateIdentifierValidator } from "./identifier-validator.js";
 
 export function validateNumericIdentifierValidator<TNumericIdentifierType extends NumericIdentifierType>(validator: IdentifierTypeValidator<TNumericIdentifierType>, identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType): void {
     validateIdentifierValidator(validator, identifierType, prefixType, length);

package/test/prefix-manager.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
-import { validateIdentifierCreators } from "./identifier-creator";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
+import { validateIdentifierCreators } from "./identifier-creator.js";
 
 describe("Prefix manager", () => {
     let prefixManager: PrefixManager;

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

@@ -3,8 +3,8 @@ import {
     ContentCharacterSets,
     isSerializableNumericIdentifierCreator,
     type SerializableNumericIdentifierCreator
-} from "../src";
-import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
+} from "../src/index.js";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
 
 export function testSerializableNumericIdentifierCreator(creator: SerializableNumericIdentifierCreator): void {
     testNonGTINNumericIdentifierCreator(creator, () => {

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

@@ -5,9 +5,9 @@ import type {
     LeaderType,
     SerializableNumericIdentifierCreator,
     SerializableNumericIdentifierValidator
-} from "../src";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { creatorFor } from "./utility";
+} from "../src/index.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { creatorFor } 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);

package/test/setup.ts

@@ -1,4 +1,4 @@
 import { I18nEnvironments } from "@aidc-toolkit/core";
-import { i18nGS1Init } from "../src";
+import { i18nGS1Init } from "../src/index.js";
 
 await i18nGS1Init(I18nEnvironments.CLI);

package/test/sparse.test.ts

@@ -1,6 +1,6 @@
 import { Sequence } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
-import { PrefixManager, PrefixTypes } from "../src";
+import { PrefixManager, PrefixTypes } from "../src/index.js";
 
 describe("Sparse creation", () => {
     const prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");

package/test/utility.ts

@@ -1,5 +1,5 @@
 import { type CharacterSetCreator, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
-import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src";
+import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src/index.js";
 
 export function creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
     let creator: 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,17 +12,18 @@ import {
     isGTINValidators,
     isNonGTINNumericIdentifierValidator,
     isNonNumericIdentifierValidator,
+    isNonSerializableNumericIdentifierValidator,
     isNumericIdentifierValidator,
     isSerializableNumericIdentifierValidator,
     LeaderTypes
-} from "../src";
-import { validateGTINValidator } from "./gtin-validator.test";
-import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator";
-import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator";
-import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator";
+} from "../src/index.js";
+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";
 
 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

@@ -5,7 +5,7 @@ import {
     hasValidCheckDigit,
     isValidPriceOrWeightCheckDigit,
     type RCNReference
-} from "../src";
+} from "../src/index.js";
 
 describe("Variable measure RCN", () => {
     test("RCN-12", () => {
@@ -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/tsconfig-config.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "files": ["./eslint.config.ts", "./tsup.config.ts", "vitest.config.ts"]
+}

package/tsconfig-src.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "include": ["./src/**/*"],
+  "compilerOptions": {
+    // Emit.
+    "outDir": "dist"
+  }
+}

package/tsconfig-test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
+  "include": ["./test/**/*"],
+  "references": [
+    {
+      "path": "./tsconfig-src.json"
+    }
+  ]
+}

package/tsconfig.json

@@ -1,3 +1,14 @@
 {
-  "extends": "@aidc-toolkit/dev/tsconfig.json"
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig-src.json"
+    },
+    {
+      "path": "./tsconfig-test.json"
+    },
+    {
+      "path": "./tsconfig-config.json"
+    }
+  ]
 }

package/tsup.config.ts

@@ -1,3 +1,4 @@
-import { tsupConfigAIDCToolkit } from "@aidc-toolkit/dev";
+import { tsupConfig } from "@aidc-toolkit/dev";
+import { defineConfig } from "tsup";
 
-export default tsupConfigAIDCToolkit;
+export default defineConfig(tsupConfig);