@aidc-toolkit/gs1 0.9.19-beta → 0.9.21-beta

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

@@ -0,0 +1,56 @@
+import { expect, test } from "vitest";
+import { ContentCharacterSets, type SerializableNumericIdentifierCreator } from "../src";
+import { testNonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
+
+export function testSerializableNumericIdentifierCreator(creator: SerializableNumericIdentifierCreator): void {
+    testNonGTINNumericIdentifierCreator(creator, undefined, () => {
+        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/serializable-numeric-identifier-validator.ts

@@ -0,0 +1,24 @@
+import { expect } from "vitest";
+import type {
+    ContentCharacterSet,
+    IdentifierType,
+    LeaderType,
+    SerializableNumericIdentifierCreator,
+    SerializableNumericIdentifierValidator
+} from "../src";
+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);
+
+    const serialCreator = creatorFor(serialCharacterSet);
+
+    expect(validator.serialComponentLength).toBe(serialLength);
+    expect(validator.serialComponentCharacterSet).toBe(serialCharacterSet);
+    expect(validator.serialComponentCreator).toBe(serialCreator);
+
+    if (isCreator) {
+        expect((validator as SerializableNumericIdentifierCreator).serialComponentCreator).toBe(serialCreator);
+    }
+}

package/test/setup.ts

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

package/test/sparse.test.ts

@@ -0,0 +1,56 @@
+import { Sequence } from "@aidc-toolkit/utility";
+import { describe, expect, test } from "vitest";
+import { PrefixManager, PrefixTypes } from "../src";
+
+describe("Sparse creation", () => {
+    const prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");
+
+    const gtin1 = prefixManager.gtinCreator.create(0, true);
+    const gln1 = prefixManager.glnCreator.create(0, true);
+
+    test("Same length 1, not equal", () => {
+        expect(gln1.length).toBe(gtin1.length);
+        expect(gln1).not.toBe(gtin1);
+    });
+
+    prefixManager.tweakFactor = 123456;
+
+    const gtin2 = prefixManager.gtinCreator.create(0, true);
+    const gln2 = prefixManager.glnCreator.create(0, true);
+
+    test("Same length 2, not equal", () => {
+        expect(gln2.length).toBe(gtin2.length);
+        expect(gln2).not.toBe(gtin2);
+    });
+
+    test("Same types 1 and 2, not equal", () => {
+        expect(gtin2).not.toBe(gtin1);
+        expect(gln2).not.toBe(gln1);
+    });
+
+    prefixManager.resetTweakFactor();
+
+    const gtin3 = prefixManager.gtinCreator.create(0, true);
+    const gln3 = prefixManager.glnCreator.create(0, true);
+
+    test("Same length 3, not equal", () => {
+        expect(gln3.length).toBe(gtin3.length);
+        expect(gln3).not.toBe(gtin3);
+    });
+
+    test("Same types 1 and 3, equal", () => {
+        expect(gtin3).toBe(gtin1);
+        expect(gln3).toBe(gln1);
+    });
+
+    prefixManager.tweakFactor = 0;
+
+    const sparseGTINs = Array.from(prefixManager.gtinCreator.create(new Sequence(0, 10), true));
+    const straightGTINs = Array.from(prefixManager.gtinCreator.create(new Sequence(0, 10)));
+
+    test("Tweak factor 0", () => {
+        expect(sparseGTINs).toStrictEqual(straightGTINs);
+    });
+
+    prefixManager.resetTweakFactor();
+});

package/test/utility.ts

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

package/test/validator.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "vitest";
+import {
+    ContentCharacterSets,
+    CPID_VALIDATOR,
+    GCN_VALIDATOR,
+    GDTI_VALIDATOR,
+    GIAI_VALIDATOR,
+    GINC_VALIDATOR,
+    GLN_VALIDATOR,
+    GMN_VALIDATOR,
+    GRAI_VALIDATOR,
+    GSIN_VALIDATOR,
+    GSRN_VALIDATOR,
+    GTIN12_VALIDATOR,
+    GTIN13_VALIDATOR,
+    GTIN8_VALIDATOR,
+    GTIN_VALIDATORS,
+    GTINTypes,
+    IdentifierTypes,
+    LeaderTypes,
+    PrefixTypes,
+    SSCC_VALIDATOR
+} from "../src";
+import { validateGTINValidator } from "./gtin-validator.test.js";
+import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import { validateNonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import { validateSerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
+
+describe("Validators", () => {
+    test("GTIN", () => {
+        expect(GTIN_VALIDATORS[PrefixTypes.GS1CompanyPrefix]).toBe(GTIN13_VALIDATOR);
+        expect(GTIN_VALIDATORS[PrefixTypes.UPCCompanyPrefix]).toBe(GTIN12_VALIDATOR);
+        expect(GTIN_VALIDATORS[PrefixTypes.GS18Prefix]).toBe(GTIN8_VALIDATOR);
+    });
+
+    test("Structure", () => {
+        validateGTINValidator(GTIN13_VALIDATOR, false, GTINTypes.GTIN13);
+        validateGTINValidator(GTIN12_VALIDATOR, false, GTINTypes.GTIN12);
+        validateGTINValidator(GTIN8_VALIDATOR, false, GTINTypes.GTIN8);
+        validateNonGTINNumericIdentifierValidator(GLN_VALIDATOR, false, IdentifierTypes.GLN, 13, LeaderTypes.None);
+        validateNonGTINNumericIdentifierValidator(SSCC_VALIDATOR, false, IdentifierTypes.SSCC, 18, LeaderTypes.ExtensionDigit);
+        validateSerializableNumericIdentifierValidator(GRAI_VALIDATOR, false, IdentifierTypes.GRAI, 13, LeaderTypes.None, 16, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(GIAI_VALIDATOR, false, IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(GSRN_VALIDATOR, false, IdentifierTypes.GSRN, 18, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(GDTI_VALIDATOR, false, IdentifierTypes.GDTI, 13, LeaderTypes.None, 17, ContentCharacterSets.AI82);
+        validateNonNumericIdentifierValidator(GINC_VALIDATOR, false, IdentifierTypes.GINC, 30, ContentCharacterSets.AI82, false);
+        validateNonGTINNumericIdentifierValidator(GSIN_VALIDATOR, false, IdentifierTypes.GSIN, 17, LeaderTypes.None);
+        validateSerializableNumericIdentifierValidator(GCN_VALIDATOR, false, IdentifierTypes.GCN, 13, LeaderTypes.None, 12, ContentCharacterSets.Numeric);
+        validateNonNumericIdentifierValidator(CPID_VALIDATOR, false, IdentifierTypes.CPID, 30, ContentCharacterSets.AI39, false);
+        validateNonNumericIdentifierValidator(GMN_VALIDATOR, false, IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);
+    });
+});

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

@@ -0,0 +1,201 @@
+import { describe, expect, test } from "vitest";
+import {
+    GTINCreator,
+    GTINValidator,
+    hasValidCheckDigit,
+    isValidPriceOrWeightCheckDigit,
+    type RCNReference
+} from "../src";
+
+describe("Variable measure RCN", () => {
+    test("RCN-12", () => {
+        const rcn1 = GTINCreator.createVariableMeasureRCN("2IIIIIVPPPPC", 12345, 4321);
+
+        expect(rcn1.length).toBe(12);
+        expect(rcn1.charAt(0)).toBe("2");
+        expect(rcn1.substring(1, 6)).toBe("12345");
+        expect(rcn1.substring(7, 11)).toBe("4321");
+        expect(isValidPriceOrWeightCheckDigit(rcn1.substring(7, 11), rcn1.charAt(6))).toBe(true);
+        expect(hasValidCheckDigit(rcn1)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("2IIIIIVPPPPC", rcn1);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("2IIIIIVPPPPC", rcn1)).toEqual({
+            itemReference: 12345,
+            priceOrWeight: 4321
+        } satisfies RCNReference);
+
+        const rcn2 = GTINCreator.createVariableMeasureRCN("2IIIIPPPPPVC", 1234, 54321);
+
+        expect(rcn2.length).toBe(12);
+        expect(rcn2.charAt(0)).toBe("2");
+        expect(rcn2.substring(1, 5)).toBe("1234");
+        expect(rcn2.substring(5, 10)).toBe("54321");
+        expect(isValidPriceOrWeightCheckDigit(rcn2.substring(5, 10), rcn2.charAt(10))).toBe(true);
+        expect(hasValidCheckDigit(rcn2)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("2IIIIPPPPPVC", rcn2);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("2IIIIPPPPPVC", rcn2)).toEqual({
+            itemReference: 1234,
+            priceOrWeight: 54321
+        } satisfies RCNReference);
+
+        const rcn3 = GTINCreator.createVariableMeasureRCN("2PPPPPIIIIIC", 12345, 54321);
+
+        expect(rcn3.length).toBe(12);
+        expect(rcn3.charAt(0)).toBe("2");
+        expect(rcn3.substring(1, 6)).toBe("54321");
+        expect(rcn3.substring(6, 11)).toBe("12345");
+        expect(hasValidCheckDigit(rcn3)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIC", rcn3);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("2PPPPPIIIIIC", rcn3)).toEqual({
+            itemReference: 12345,
+            priceOrWeight: 54321
+        } satisfies RCNReference);
+
+        expect(() => GTINCreator.createVariableMeasureRCN("3PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("20PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "2543211234540");
+        }).toThrow("RCN length must match format length");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "25432112345");
+        }).toThrow("RCN length must match format length");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("3PPPPPIIIIIC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("20PPPPPIIIIC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIII", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIKC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPIIPIIC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPIPPIIIIIC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIC", "25432112345");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPIIIIIIC", "2543211234540");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2PPPPPPPPPPC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("2IIIIIIIIIIC", "254321123454");
+        }).toThrow("Invalid variable measure RCN format");
+    });
+
+    test("RCN-13", () => {
+        const rcn1 = GTINCreator.createVariableMeasureRCN("24IIIIIVPPPPC", 12345, 4321);
+
+        expect(rcn1.length).toBe(13);
+        expect(rcn1.substring(0, 2)).toBe("24");
+        expect(rcn1.substring(2, 7)).toBe("12345");
+        expect(rcn1.substring(8, 12)).toBe("4321");
+        expect(isValidPriceOrWeightCheckDigit(rcn1.substring(8, 12), rcn1.charAt(7))).toBe(true);
+        expect(hasValidCheckDigit(rcn1)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("24IIIIIVPPPPC", rcn1);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("24IIIIIVPPPPC", rcn1)).toEqual({
+            itemReference: 12345,
+            priceOrWeight: 4321
+        } satisfies RCNReference);
+
+        const rcn2 = GTINCreator.createVariableMeasureRCN("21IIIIPPPPPVC", 1234, 54321);
+
+        expect(rcn2.length).toBe(13);
+        expect(rcn2.substring(0, 2)).toBe("21");
+        expect(rcn2.substring(2, 6)).toBe("1234");
+        expect(rcn2.substring(6, 11)).toBe("54321");
+        expect(isValidPriceOrWeightCheckDigit(rcn2.substring(6, 11), rcn2.charAt(11))).toBe(true);
+        expect(hasValidCheckDigit(rcn2)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("21IIIIPPPPPVC", rcn2);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("21IIIIPPPPPVC", rcn2)).toEqual({
+            itemReference: 1234,
+            priceOrWeight: 54321
+        } satisfies RCNReference);
+
+        const rcn3 = GTINCreator.createVariableMeasureRCN("27PPPPPIIIIIC", 12345, 54321);
+
+        expect(rcn3.length).toBe(13);
+        expect(rcn3.substring(0, 2)).toBe("27");
+        expect(rcn3.substring(2, 7)).toBe("54321");
+        expect(rcn3.substring(7, 12)).toBe("12345");
+        expect(hasValidCheckDigit(rcn3)).toBe(true);
+        expect(() => {
+            GTINValidator.parseVariableMeasureRCN("27PPPPPIIIIIC", rcn3);
+        }).not.toThrow(RangeError);
+        expect(GTINValidator.parseVariableMeasureRCN("27PPPPPIIIIIC", rcn3)).toEqual({
+            itemReference: 12345,
+            priceOrWeight: 54321
+        } satisfies RCNReference);
+
+        expect(() => GTINCreator.createVariableMeasureRCN("30PPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("2PPPPPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("20PPPPPIIIIII", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("21PPPPPIIIIKC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("22PPPPPIIPIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("23PPIPPIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("24PPPPPIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("25PPPPPIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("26PPPPPPPPPPC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+        expect(() => GTINCreator.createVariableMeasureRCN("27IIIIIIIIIIC", 12345, 54321)).toThrow("Invalid variable measure RCN format");
+
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "27543211234570");
+        }).toThrow("RCN length must match format length");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "275432112345");
+        }).toThrow("RCN length must match format length");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("30PPPPPIIIIIC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("20PPPPPIIIIII", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("21PPPPPIIIIKC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("22PPPPPIIPIIC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("23PPIPPIIIIIC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("24PPPPPIIIIC", "275432112345");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("25PPPPPIIIIIIC", "27543211234570");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("26PPPPPPPPPPC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+        expect(() => {
+            GTINCreator.parseVariableMeasureRCN("27IIIIIIIIIIC", "2754321123457");
+        }).toThrow("Invalid variable measure RCN format");
+    });
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        setupFiles: ["test/setup.ts"]
+    }
+});