@aidc-toolkit/gs1 1.0.31-beta → 1.0.32-beta

package/src/gcp-length.ts

@@ -0,0 +1,418 @@
+import { omit } from "@aidc-toolkit/core";
+import type { GCPLengthCache } from "./gcp-length-cache.js";
+import type { GCPLengthData, GCPLengthHeader } from "./gcp-length-data.js";
+import { GTINLengths } from "./gtin-length.js";
+import { GTINValidator } from "./gtin-validator.js";
+import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
+import { IdentifierValidators, isNumericIdentifierValidator } from "./identifier-validators.js";
+import { LeaderTypes } from "./leader-type.js";
+
+/**
+ * GS1 Company Prefix length JSON source file format.
+ */
+interface GCPLengthJSON {
+    /**
+     * Disclaimer.
+     */
+    _disclaimer: string[];
+
+    /**
+     * Format list.
+     */
+    GCPPrefixFormatList: {
+        /**
+         * ISO data/time the table was last updated.
+         */
+        date: string;
+
+        /**
+         * Entries.
+         */
+        entry: Array<{
+            /**
+             * Identification key prefix start.
+             */
+            prefix: string;
+
+            /**
+             * Length of GS1 Company Prefix.
+             */
+            gcpLength: number;
+        }>;
+    };
+}
+
+/**
+ * Leaf of GS1 Company Prefix length tree.
+ */
+export interface Leaf {
+    length: number;
+}
+
+/**
+ * Branch of GS1 Company Prefix length tree.
+ */
+export interface Branch {
+    childNodes: Array<Node | undefined>;
+}
+
+/**
+ * Root of GS1 Company Prefix length tree.
+ */
+export interface Root extends GCPLengthHeader, Branch {
+}
+
+/**
+ * Node in GS1 Company Prefix length tree.
+ */
+export type Node = Root | Branch | Leaf;
+
+/**
+ * Determine if a node is a leaf.
+ *
+ * @param node
+ * Node.
+ *
+ * @returns
+ * True if node is a leaf.
+ */
+export function isLeaf(node: Node): node is Leaf {
+    return "length" in node;
+}
+
+/**
+ * Entry in binary data to indicate that child node is undefined.
+ */
+const BINARY_UNDEFINED = 0x0F;
+
+/**
+ * Entry in binary data to indicate that child node is a branch.
+ */
+const BINARY_BRANCH = 0x0E;
+
+/**
+ * Build the GS1 Company Prefix length tree from a binary data array.
+ *
+ * @param binaryData
+ * Binary data array.
+ *
+ * @param childNodes
+ * Child nodes array to fill.
+ *
+ * @param startIndex
+ * Start index into binary data array.
+ *
+ * @returns
+ * End index into binary data array.
+ */
+function fromBinary(binaryData: Uint8Array, childNodes: Array<Node | undefined>, startIndex: number): number {
+    let endIndex = startIndex;
+
+    const decompressedLengths = new Array<number>(10);
+
+    // Decompress lengths for the child nodes.
+    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
+        const byte = binaryData[endIndex++];
+
+        decompressedLengths[childNodeIndex] = byte >> 4;
+        decompressedLengths[childNodeIndex + 1] = byte & 0x0F;
+    }
+
+    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex++) {
+        const length = decompressedLengths[childNodeIndex];
+
+        if (length !== BINARY_UNDEFINED) {
+            let childNode: Node;
+
+            if (length === BINARY_BRANCH) {
+                childNode = {
+                    childNodes: []
+                };
+
+                endIndex = fromBinary(binaryData, childNode.childNodes, endIndex);
+            } else {
+                childNode = {
+                    length
+                };
+            }
+
+            // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+            childNodes[childNodeIndex] = childNode;
+        }
+    }
+
+    return endIndex;
+}
+
+/**
+ * Add an entry to the tree by recursively walking the tree to a leaf.
+ *
+ * @param branch
+ * Current branch.
+ *
+ * @param prefix
+ * Remainder of current prefix.
+ *
+ * @param length
+ * Current prefix length.
+ *
+ * @returns
+ * Number of branches added; used to determine size of binary array.
+ */
+function addEntry(branch: Branch, prefix: string, length: number): number {
+    const digit = Number(prefix.charAt(0));
+
+    const existingChildNode = branch.childNodes[digit];
+
+    let branchesAdded = 0;
+
+    if (prefix.length !== 1) {
+        let childBranch: Branch;
+
+        if (existingChildNode === undefined) {
+            childBranch = {
+                childNodes: []
+            };
+
+            branchesAdded++;
+        } else {
+            if (isLeaf(existingChildNode)) {
+                // File format error or application bug; localization not necessary.
+                throw new Error("Overlapping entry");
+            }
+
+            childBranch = existingChildNode;
+        }
+
+        // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+        branch.childNodes[digit] = childBranch;
+
+        // Continue with remainder of prefix.
+        branchesAdded += addEntry(childBranch, prefix.substring(1), length);
+    } else {
+        if (existingChildNode !== undefined) {
+            // File format error or application bug; localization not necessary.
+            throw new Error("Duplicate entry");
+        }
+
+        // eslint-disable-next-line no-param-reassign -- Purpose is to build tree.
+        branch.childNodes[digit] = {
+            length
+        };
+    }
+
+    return branchesAdded;
+}
+
+/**
+ * Get the length of a child node if defined and it's a leaf, otherwise mark it with 0x0E if defined (branch) or 0x0F
+ * (no branch) if not.
+ *
+ * @param childNode
+ * Child node.
+ *
+ * @returns
+ * Child node length, 0x0E (branch), or 0x0F (undefined).
+ */
+function childNodeValue(childNode: Node | undefined): number {
+    return childNode !== undefined ? isLeaf(childNode) ? childNode.length : BINARY_BRANCH : BINARY_UNDEFINED;
+}
+
+/**
+ * Add a branch to a binary data array.
+ *
+ * @param binaryData
+ * Binary data array.
+ *
+ * @param branch
+ * Branch.
+ *
+ * @param startIndex
+ * Start index into binary data array.
+ *
+ * @returns
+ * End index into binary data array.
+ */
+function toBinary(binaryData: Uint8Array, branch: Branch, startIndex: number): number {
+    let endIndex = startIndex;
+
+    const childNodes = branch.childNodes;
+
+    // Add length or non-leaf indicators, compressing 10 nibbles into 5 bytes.
+    for (let childNodeIndex = 0; childNodeIndex < 10; childNodeIndex += 2) {
+        // eslint-disable-next-line no-param-reassign -- Purpose is to build array.
+        binaryData[endIndex++] = (childNodeValue(childNodes[childNodeIndex]) << 4) | childNodeValue(childNodes[childNodeIndex + 1]);
+    }
+
+    // Process child nodes.
+    for (const childNode of childNodes) {
+        if (childNode !== undefined && !isLeaf(childNode)) {
+            endIndex = toBinary(binaryData, childNode, endIndex);
+        }
+    }
+
+    return endIndex;
+}
+
+/**
+ * Add days to a date.
+ *
+ * @param date
+ * Date.
+ *
+ * @param days
+ * Days.
+ *
+ * @returns
+ * New date.
+ */
+function addDays(date: Date, days: number): Date {
+    const futureDate = new Date(date);
+    futureDate.setDate(futureDate.getDate() + days);
+
+    return futureDate;
+}
+
+/**
+ * Load the GS1 Company Prefix length data.
+ *
+ * @param gcpLengthCache
+ * GS1 Company Prefix length cache.
+ *
+ * @returns
+ * Root of tree.
+ */
+export async function loadData(gcpLengthCache: GCPLengthCache): Promise<Root | undefined> {
+    let root: Root | undefined = undefined;
+
+    let nextCheckDateTime = await gcpLengthCache.nextCheckDateTime;
+    let cacheDateTime = await gcpLengthCache.cacheDateTime;
+
+    const now = new Date();
+    const tomorrow = addDays(now, 1);
+
+    if (nextCheckDateTime === undefined || nextCheckDateTime.getTime() <= now.getTime()) {
+        const sourceDateTime = await gcpLengthCache.sourceDateTime;
+
+        if (cacheDateTime === undefined || cacheDateTime.getTime() < sourceDateTime.getTime()) {
+            const sourceData = await gcpLengthCache.sourceData;
+
+            let cacheData: GCPLengthData;
+
+            if (typeof sourceData !== "string") {
+                root = {
+                    dateTime: sourceData.dateTime,
+                    disclaimer: sourceData.disclaimer,
+                    childNodes: []
+                };
+
+                fromBinary(sourceData.data, root.childNodes, 0);
+
+                cacheData = sourceData;
+            } else {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- File format is known.
+                const gcpLength = JSON.parse(sourceData) as GCPLengthJSON;
+
+                root = {
+                    dateTime: new Date(gcpLength.GCPPrefixFormatList.date),
+                    // Join disclaimer as a single string.
+                    disclaimer: `${gcpLength._disclaimer.reduce<string[]>((lines, line) => {
+                        if (lines.length === 0 || lines[lines.length - 1] === "" || line === "") {
+                            lines.push(line);
+                        } else {
+                            // Lines are part of the same paragraph.
+                            lines.push(`${lines.pop()} ${line}`);
+                        }
+
+                        return lines;
+                    }, []).join("\n")}\n`,
+                    childNodes: []
+                };
+
+                let branchesAdded = 1;
+
+                for (const entry of gcpLength.GCPPrefixFormatList.entry) {
+                    branchesAdded += addEntry(root, entry.prefix, entry.gcpLength);
+                }
+
+                // Each branch has ten (some possibly undefined) entries, two per byte.
+                const data = new Uint8Array(branchesAdded * 5);
+
+                toBinary(data, root, 0);
+
+                cacheData = {
+                    ...omit(root, "childNodes"),
+                    data
+                };
+            }
+
+            // Next check date/time is a week from source date/time or tomorrow, whichever is later.
+            nextCheckDateTime = addDays(sourceDateTime, 7);
+            if (nextCheckDateTime.getTime() < tomorrow.getTime()) {
+                nextCheckDateTime = tomorrow;
+            }
+
+            cacheDateTime = sourceDateTime;
+
+            await gcpLengthCache.update(nextCheckDateTime, cacheDateTime, cacheData);
+        } else {
+            // Next check date/time is tomorrow.
+            await gcpLengthCache.update(tomorrow);
+        }
+    }
+
+    // Root is undefined if cache data is still valid or retrying after prior failure.
+    if (root === undefined && cacheDateTime !== undefined) {
+        const cacheData = await gcpLengthCache.cacheData;
+
+        root = {
+            ...omit(cacheData, "data"),
+            childNodes: []
+        };
+
+        fromBinary(cacheData.data, root.childNodes, 0);
+    }
+
+    return root;
+}
+
+/**
+ * Get the length of a GS1 Company Prefix for an identifier.
+ *
+ * @param root
+ * Root of tree.
+ *
+ * @param identifierType
+ * Identifier type.
+ *
+ * @param identifier
+ * Identifier.
+ *
+ * @returns
+ * Length of GS1 Company Prefix, 0 if not a GS1 Company Prefix, or -1 if not found.
+ */
+export function getFor(root: Root, identifierType: IdentifierType, identifier: string): number {
+    let identifierPrefix: string;
+
+    if (identifierType === IdentifierTypes.GTIN) {
+        // Normalize the GTIN, pad to 14 digits, and extract the identifier prefix at the first character.
+        identifierPrefix = GTINValidator.normalize(identifier).padStart(GTINLengths.GTIN14, "0").substring(1);
+    } else {
+        const identifierValidator = IdentifierValidators[identifierType];
+
+        identifierValidator.validate(identifier);
+
+        identifierPrefix = !isNumericIdentifierValidator(identifierValidator) || identifierValidator.leaderType !== LeaderTypes.ExtensionDigit ? identifier : identifier.substring(1);
+    }
+
+    let node: Node | undefined = root;
+
+    let digitIndex = 0;
+
+    // Traverse tree until exhausted or at a leaf.
+    while (node !== undefined && !isLeaf(node)) {
+        node = node.childNodes[Number(identifierPrefix.charAt(digitIndex++))];
+    }
+
+    return node?.length ?? -1;
+}

package/src/gtin-creator.ts

@@ -6,7 +6,7 @@ import {
     type TransformerOutput
 } from "@aidc-toolkit/utility";
 import { MixinAbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
-import { checkDigit, priceOrWeightCheckDigit } from "./check.js";
+import { checkDigit } from "./check.js";
 import { type GTINBaseLength, GTINLengths } from "./gtin-length.js";
 import type { GTINType } from "./gtin-type.js";
 import { GTINValidator } from "./gtin-validator.js";
@@ -76,120 +76,4 @@ export class GTINCreator extends MixinAbstractNumericIdentifierCreator<
             return partialIdentifier + checkDigit(partialIdentifier);
         });
     }
-
-    /**
-     * Create a Restricted Circulation Number (RCN) using a variable measure trade item format. See {@linkcode
-     * GTINValidator.parseVariableMeasureRCN} for format details.
-     *
-     * @param format
-     * Format.
-     *
-     * @param itemReference
-     * Item reference.
-     *
-     * @param priceOrWeight
-     * Price or weight (whole number only).
-     *
-     * @returns
-     * RCN-12 or RCN-13.
-     */
-    static createVariableMeasureRCN(format: string, itemReference: number, priceOrWeight: number): string {
-        const formatLength = format.length;
-
-        let validFormat = formatLength === 12 || formatLength === 13;
-
-        let rcnPrefix = "";
-
-        let buildingItemReference = false;
-        let itemReferenceString = "";
-        let itemReferenceLength = 0;
-
-        let buildingPriceOrWeight = false;
-        let priceOrWeightString = "";
-        let priceOrWeightLength = 0;
-
-        let calculatePriceOrWeightCheckDigit = false;
-
-        // RCN may be built in almost any order, so defer to builders that will be in ordered array.
-        const rcnPrefixBuilder = (partialRCN: string): string => partialRCN + rcnPrefix;
-        const itemReferenceBuilder = (partialRCN: string): string => partialRCN + itemReferenceString;
-        const priceOrWeightBuilder = (partialRCN: string): string => partialRCN + priceOrWeightString;
-        const priceOrWeightCheckDigitBuilder = (partialRCN: string): string => partialRCN + priceOrWeightCheckDigit(priceOrWeightString);
-        const checkDigitBuilder = (partialRCN: string): string => partialRCN + checkDigit(partialRCN);
-
-        const rcnBuilders = [rcnPrefixBuilder];
-
-        for (let index = 0; validFormat && index < formatLength; index++) {
-            const formatChar = format.charAt(index);
-
-            if (index === 0) {
-                validFormat = formatChar === "2";
-                rcnPrefix = formatChar;
-            } else if (formatLength === 13 && index === 1) {
-                validFormat = NUMERIC_CREATOR.characterIndex(formatChar) !== undefined;
-                rcnPrefix += formatChar;
-            } else if (index === formatLength - 1) {
-                validFormat = formatChar === "C";
-            } else {
-                switch (formatChar) {
-                    case "I":
-                        if (!buildingItemReference) {
-                            // Item reference can't appear more than once.
-                            validFormat = itemReferenceLength === 0;
-
-                            buildingItemReference = true;
-                            buildingPriceOrWeight = false;
-
-                            rcnBuilders.push(itemReferenceBuilder);
-                        }
-
-                        itemReferenceLength++;
-                        break;
-
-                    case "P":
-                        if (!buildingPriceOrWeight) {
-                            // Price or weight can't appear more than once.
-                            validFormat = priceOrWeightLength === 0;
-
-                            buildingPriceOrWeight = true;
-                            buildingItemReference = false;
-
-                            rcnBuilders.push(priceOrWeightBuilder);
-                        }
-
-                        priceOrWeightLength++;
-                        break;
-
-                    case "V":
-                        // Price or weight check digit can't appear more than once.
-                        validFormat = !calculatePriceOrWeightCheckDigit;
-
-                        buildingItemReference = false;
-                        buildingPriceOrWeight = false;
-
-                        calculatePriceOrWeightCheckDigit = true;
-
-                        rcnBuilders.push(priceOrWeightCheckDigitBuilder);
-                        break;
-
-                    default:
-                        validFormat = false;
-                        break;
-                }
-            }
-        }
-
-        validFormat &&= itemReferenceLength !== 0 && priceOrWeightLength !== 0;
-
-        if (!validFormat) {
-            throw new RangeError(i18nextGS1.t("Identifier.invalidVariableMeasureRCNFormat"));
-        }
-
-        itemReferenceString = NUMERIC_CREATOR.create(itemReferenceLength, itemReference);
-        priceOrWeightString = NUMERIC_CREATOR.create(priceOrWeightLength, priceOrWeight);
-
-        rcnBuilders.push(checkDigitBuilder);
-
-        return rcnBuilders.reduce((partialRCN, rcnBuilder) => rcnBuilder(partialRCN), "");
-    }
 }