@aidc-toolkit/gs1 0.0.1

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./character_set.js";
+export * from "./check.js";
+export * from "./idkey.js";

package/src/locale/en/locale_strings.ts

@@ -0,0 +1,34 @@
+export const localeStrings = {
+    Check: {
+        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length}} of string for check character pair must be less than or equal to {{maximumLength}}"
+    },
+    IdentificationKey: {
+        identificationKeyTypeLength: "{{identificationKeyType}} must be {{length}} digits long",
+        invalidCheckDigit: "Invalid check digit",
+        invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long",
+        invalidGTIN14Length: "GTIN must be 14 digits long",
+        invalidZeroSuppressedGTIN12: "Invalid zero-suppressed GTIN-12",
+        invalidZeroSuppressibleGTIN12: "GTIN-12 not zero-suppressible",
+        invalidZeroSuppressedGTIN12AsGTIN13: "Invalid zero-suppressed GTIN-12 as GTIN-13",
+        invalidZeroSuppressedGTIN12AsGTIN14: "Invalid zero-suppressed GTIN-12 as GTIN-14",
+        invalidGTIN13AtRetail: "GTIN-13 at retail consumer trade item level can't start with zero",
+        invalidGTINAtRetail: "GTIN not supported at retail consumer trade item level",
+        invalidGTINAtOtherThanRetail: "GTIN not supported at other than retail consumer trade item level",
+        indicatorDigit: "indicator digit",
+        serialComponent: "serial component",
+        reference: "reference",
+        referenceCantBeAllNumeric: "Reference can't be all-numeric",
+        invalidCheckCharacterPair: "Invalid check character pair"
+    },
+    Prefix: {
+        gs1CompanyPrefix: "GS1 Company Prefix",
+        upcCompanyPrefix: "U.P.C. Company Prefix",
+        gs18Prefix: "GS1-8 Prefix",
+        gs1CompanyPrefixCantStartWith0: "GS1 Company Prefix can't start with \"0\"",
+        gs1CompanyPrefixCantStartWith00000: "GS1 Company Prefix can't start with \"00000\"",
+        gs1CompanyPrefixCantStartWith000000: "GS1 Company Prefix can't start with \"000000\"",
+        upcCompanyPrefixCantStartWith0000: "U.P.C. Company Prefix can't start with \"0000\"",
+        gs18PrefixCantStartWith0: "GS1-8 Prefix can't start with \"0\"",
+        identificationKeyTypeNotSupportedByGS18Prefix: "{{identificationKeyType}} not supported by GS1-8 Prefix"
+    }
+} as const;

package/src/locale/i18n.ts

@@ -0,0 +1,8 @@
+import { i18nAddResourceBundle, i18next } from "@aidc-toolkit/core";
+import { localeStrings as enLocaleStrings } from "./en/locale_strings.js";
+
+export const gs1NS = "aidct_gs1";
+
+i18nAddResourceBundle("en", gs1NS, enLocaleStrings);
+
+export default i18next;

package/src/locale/i18next.d.ts

@@ -0,0 +1,10 @@
+import type { localeStrings } from "./en/locale_strings.js";
+
+declare module "i18next" {
+    interface CustomTypeOptions {
+        resources: {
+            // Extract the type from the English locale strings object.
+            aidct_gs1: typeof localeStrings;
+        };
+    }
+}

package/test/check.test.ts

@@ -0,0 +1,148 @@
+import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
+import { describe, expect, test } from "vitest";
+import { I18NEnvironment, i18nInit } from "../../core/dist/index.js";
+import {
+    checkCharacterPair,
+    checkDigit,
+    checkDigitSum,
+    fiveDigitPriceWeightCheckDigit,
+    fourDigitPriceWeightCheckDigit,
+    hasValidCheckCharacterPair,
+    hasValidCheckDigit
+} from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+describe("Check digit", () => {
+    const testNumericString = "1234567890";
+
+    test("Basic check digit sum", () => {
+        expect(checkDigitSum(false, testNumericString)).toBe((1 + 3 + 5 + 7 + 9) * 1 + (2 + 4 + 6 + 8 + 0) * 3);
+        expect(checkDigitSum(true, testNumericString)).toBe((1 + 3 + 5 + 7 + 9) * 3 + (2 + 4 + 6 + 8 + 0) * 1);
+    });
+
+    test("Calculation and validation", () => {
+        const calculatedCheckDigit = String(9 - ((checkDigitSum(true, testNumericString) + 9) % 10));
+
+        expect(checkDigitSum(true, testNumericString + calculatedCheckDigit) % 10).toBe(0);
+        expect(checkDigit(testNumericString)).toBe(calculatedCheckDigit);
+        expect(hasValidCheckDigit(testNumericString + checkDigit(testNumericString))).toBe(true);
+        expect(hasValidCheckDigit(testNumericString.replace("5", "6") + calculatedCheckDigit)).toBe(false);
+    });
+
+    test("Exception", () => {
+        const testNonNumericString = "123456789O";
+
+        expect(() => checkDigitSum(false, testNonNumericString)).toThrow("Invalid character 'O' at position 10");
+        expect(() => checkDigit(testNonNumericString)).toThrow("Invalid character 'O' at position 10");
+        expect(() => hasValidCheckDigit(testNonNumericString)).toThrow("Invalid character 'O' at position 10");
+    });
+});
+
+describe("Price/weight check digit", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function weight2Minus(characterIndex: number): number {
+        const product = characterIndex * 2;
+
+        return (product - Math.trunc(product / 10)) % 10;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function weight3(characterIndex: number): number {
+        return characterIndex * 3 % 10;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function weight5Plus(characterIndex: number): number {
+        const product = characterIndex * 5;
+
+        return (product + Math.trunc(product / 10)) % 10;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function weight5Minus(characterIndex: number): number {
+        const product = characterIndex * 5;
+
+        return (product - Math.trunc(product / 10)) % 10;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function testFourDigitPriceWeightCheckDigit(s: string): void {
+        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s);
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const sum = weight2Minus(characterIndexes[0]!) + weight2Minus(characterIndexes[1]!) + weight3(characterIndexes[2]!) + weight5Minus(characterIndexes[3]!);
+
+        expect(fourDigitPriceWeightCheckDigit(s)).toBe(NUMERIC_CREATOR.character(sum * 3 % 10));
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function testFiveDigitPriceWeightCheckDigit(s: string): void {
+        const characterIndexes = NUMERIC_CREATOR.characterIndexes(s);
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const sum = weight5Plus(characterIndexes[0]!) + weight2Minus(characterIndexes[1]!) + weight5Minus(characterIndexes[2]!) + weight5Plus(characterIndexes[3]!) + weight2Minus(characterIndexes[4]!);
+
+        expect(weight5Minus(Number(fiveDigitPriceWeightCheckDigit(s)))).toBe(9 - (sum + 9) % 10);
+    }
+
+    test("Four-digit", () => {
+        testFourDigitPriceWeightCheckDigit("0123");
+        testFourDigitPriceWeightCheckDigit("1234");
+        testFourDigitPriceWeightCheckDigit("2345");
+        testFourDigitPriceWeightCheckDigit("3456");
+        testFourDigitPriceWeightCheckDigit("4567");
+        testFourDigitPriceWeightCheckDigit("5678");
+        testFourDigitPriceWeightCheckDigit("6789");
+        testFourDigitPriceWeightCheckDigit("7890");
+        testFourDigitPriceWeightCheckDigit("8901");
+        testFourDigitPriceWeightCheckDigit("9012");
+
+        expect(() => fourDigitPriceWeightCheckDigit("l234")).toThrow("Invalid character 'l' at position 1");
+        expect(() => fourDigitPriceWeightCheckDigit("123")).toThrow("String for price or weight sum must be exactly 4 characters");
+        expect(() => fourDigitPriceWeightCheckDigit("12345")).toThrow("String for price or weight sum must be exactly 4 characters");
+    });
+
+    test("Five-digit", () => {
+        testFiveDigitPriceWeightCheckDigit("01234");
+        testFiveDigitPriceWeightCheckDigit("12345");
+        testFiveDigitPriceWeightCheckDigit("23456");
+        testFiveDigitPriceWeightCheckDigit("34567");
+        testFiveDigitPriceWeightCheckDigit("45678");
+        testFiveDigitPriceWeightCheckDigit("56789");
+        testFiveDigitPriceWeightCheckDigit("67890");
+        testFiveDigitPriceWeightCheckDigit("78901");
+        testFiveDigitPriceWeightCheckDigit("89012");
+        testFiveDigitPriceWeightCheckDigit("90123");
+
+        expect(() => fiveDigitPriceWeightCheckDigit("l2345")).toThrow("Invalid character 'l' at position 1");
+        expect(() => fiveDigitPriceWeightCheckDigit("1234")).toThrow("String for price or weight sum must be exactly 5 characters");
+        expect(() => fiveDigitPriceWeightCheckDigit("123456")).toThrow("String for price or weight sum must be exactly 5 characters");
+    });
+});
+
+describe("Check character pair", () => {
+    test("Calculation and validation", () => {
+        expect(checkCharacterPair("95212349521234")).toBe("R9");
+        expect(checkCharacterPair("9521234ABCDEFabcdef")).toBe("8T");
+
+        expect(checkCharacterPair("!\"%&'()*+,-./0123456789:;<=>")).toBe("TH");
+        expect(checkCharacterPair("?ABCDEFGHIJKLMNOPQRSTUVWXYZ_")).toBe("EP");
+        expect(checkCharacterPair("abcdefghijklmnopqrstuvwxyz")).toBe("5A");
+
+        expect(hasValidCheckCharacterPair("95212349521234R9")).toBe(true);
+        expect(hasValidCheckCharacterPair("9521234ABCDEFabcdef8T")).toBe(true);
+
+        expect(hasValidCheckCharacterPair("!\"%&'()*+,-./0123456789:;<=>TH")).toBe(true);
+        expect(hasValidCheckCharacterPair("?ABCDEFGHIJKLMNOPQRSTUVWXYZ_EP")).toBe(true);
+        expect(hasValidCheckCharacterPair("abcdefghijklmnopqrstuvwxyz5A")).toBe(true);
+        expect(hasValidCheckCharacterPair("abcdefghijklmnopqrstuvwxyz5B")).toBe(false);
+        expect(hasValidCheckCharacterPair("abcdefghijklmnopqrstuvwxyz5~")).toBe(false);
+    });
+
+    test("Exception", () => {
+        expect(() => checkCharacterPair("?ABCDEFGHIJKLMNOPQRSTUVWXYZ_!")).toThrow("Length 29 of string for check character pair must be less than or equal to 28");
+        expect(() => checkCharacterPair("abcdefghijklmnopqrstuvwxyz~")).toThrow("Invalid character '~' at position 27");
+        expect(() => hasValidCheckCharacterPair("~abcdefghijklmnopqrstuvwxyz")).toThrow("Invalid character '~' at position 1");
+    });
+});