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

package/src/idkey.ts

@@ -2,13 +2,13 @@ import {
     CharacterSetCreator,
     type CharacterSetValidation,
     Exclusion,
+    mapIterable,
     NUMERIC_CREATOR,
     RegExpValidator,
     type StringValidation,
     type StringValidator,
     type TransformerInput,
-    type TransformerOutput,
-    transformIterable
+    type TransformerOutput
 } from "@aidc-toolkit/utility";
 import { Mixin } from "ts-mixer";
 import { AI39_CREATOR, AI82_CREATOR } from "./character-set.js";
@@ -17,7 +17,9 @@ import {
     checkDigit,
     checkDigitSum,
     hasValidCheckCharacterPair,
-    hasValidCheckDigit
+    hasValidCheckDigit,
+    isValidPriceOrWeightCheckDigit,
+    priceOrWeightCheckDigit
 } from "./check.js";
 import { i18nextGS1 } from "./locale/i18n.js";
 
@@ -141,6 +143,9 @@ export interface IdentificationKeyValidation extends StringValidation {
 /**
  * Identification key validator. Validates an identification key against its definition in section 3 of the {@link
  * https://www.gs1.org/genspecs | GS1 General Specifications}.
+ *
+ * @template TIdentificationKeyValidation
+ * Identification key validation type.
  */
 export interface IdentificationKeyValidator<TIdentificationKeyValidation extends IdentificationKeyValidation = IdentificationKeyValidation> extends StringValidator<TIdentificationKeyValidation> {
     /**
@@ -167,7 +172,7 @@ export interface IdentificationKeyValidator<TIdentificationKeyValidation extends
     get referenceCharacterSet(): ContentCharacterSet;
 
     /**
-     * Get the reference validator.
+     * Get the reference creator.
      */
     get referenceCreator(): CharacterSetCreator;
 
@@ -467,6 +472,21 @@ export enum GTINLevel {
     OtherThanRetailConsumer
 }
 
+/**
+ * Restricted Circulation Number reference.
+ */
+export interface RCNReference {
+    /**
+     * Item reference.
+     */
+    itemReference: number;
+
+    /**
+     * Price or weight (whole number only).
+     */
+    priceOrWeight: number;
+}
+
 /**
  * GTIN validator.
  */
@@ -629,10 +649,8 @@ export class GTINValidator extends AbstractNumericIdentificationKeyValidator {
 
         NUMERIC_CREATOR.validate(indicatorDigit, GTINValidator.OPTIONAL_INDICATOR_DIGIT_VALIDATION);
 
-        const gtinLength = gtin.length;
-
         // Check digit doesn't change by prepending zeros.
-        let gtin14 = "0".repeat(GTINType.GTIN14 - gtinLength) + gtin;
+        let gtin14 = gtin.padStart(GTINType.GTIN14, "0");
 
         // If indicator digit provided and is different, recalculate the check digit.
         if (indicatorDigit.length !== 0 && indicatorDigit !== gtin14.charAt(0)) {
@@ -802,6 +820,134 @@ export class GTINValidator extends AbstractNumericIdentificationKeyValidator {
 
         GTINCreator.validateAny(gtin14);
     }
+
+    /**
+     * Parse a Restricted Circulation Number (RCN) using a variable measure trade item format. The format is a 12- or
+     * 13-character string (for RCN-12 or RCN-13 respectively), containing the following:
+     *
+     * - '2' - The first character of the RCN.
+     * - '0'-'9' - The second character of the RCN (RCN-13 only).
+     * - 'I' - One or more, in sequence, for the item reference.
+     * - 'P' - One or more, in sequence, for the price or weight.
+     * - 'V' - Zero or one, for the price or weight check digit.
+     * - 'C' - The check digit of the entire RCN.
+     *
+     * The 'I', 'P', and 'V' formats may be in any order.
+     *
+     * Some examples:
+     *
+     * - 2IIIIIVPPPPC - RCN-12 with a five-digit item reference, a price or weight check digit, and a four-digit price
+     * or weight.
+     * - 23IIIIVPPPPPC - RCN-13 with a four-digit item reference, a price or weight check digit, and a five-digit price
+     * or weight.
+     * - 2IIIIIIPPPPC - RCN-12 with a six-digit item reference and a four-digit price or eight.
+     * - 29IIIIIPPPPPC - RCN-13 with a five-digit item reference and a five-digit price or weight.
+     *
+     * @param format
+     * Format.
+     *
+     * @param rcn
+     * RCN.
+     *
+     * @returns
+     * RCN reference.
+     */
+    static parseVariableMeasureRCN(format: string, rcn: string): RCNReference {
+        const formatLength = format.length;
+
+        if (rcn.length !== formatLength) {
+            throw new RangeError(i18nextGS1.t("IdentificationKey.invalidRCNLength"));
+        }
+
+        let validFormat = formatLength === 12 || formatLength === 13;
+        let validRCNPrefix = true;
+
+        let buildingItemReference = false;
+        let itemReference = "";
+
+        let buildingPriceOrWeight = false;
+        let priceOrWeight = "";
+
+        let priceOrWeightCheckDigit = "";
+
+        for (let index = 0; validFormat && index < formatLength; index++) {
+            const formatChar = format.charAt(index);
+            const rcnChar = rcn.charAt(index);
+
+            if (index === 0) {
+                validFormat = formatChar === "2";
+                validRCNPrefix = rcnChar === "2";
+            } else if (formatLength === 13 && index === 1) {
+                validFormat = NUMERIC_CREATOR.characterIndex(formatChar) !== undefined;
+                validRCNPrefix = rcnChar === 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 = itemReference === "";
+
+                            buildingItemReference = true;
+                            buildingPriceOrWeight = false;
+                        }
+
+                        itemReference += rcnChar;
+                        break;
+
+                    case "P":
+                        if (!buildingPriceOrWeight) {
+                            // Price or weight can't appear more than once.
+                            validFormat = priceOrWeight === "";
+
+                            buildingPriceOrWeight = true;
+                            buildingItemReference = false;
+                        }
+
+                        priceOrWeight += rcnChar;
+                        break;
+
+                    case "V":
+                        // Price or weight check digit can't appear more than once.
+                        validFormat = priceOrWeightCheckDigit === "";
+
+                        buildingItemReference = false;
+                        buildingPriceOrWeight = false;
+
+                        priceOrWeightCheckDigit = rcnChar;
+                        break;
+
+                    default:
+                        validFormat = false;
+                        break;
+                }
+            }
+        }
+
+        validFormat &&= itemReference !== "" && priceOrWeight !== "";
+
+        if (!validFormat) {
+            throw new RangeError(i18nextGS1.t("IdentificationKey.invalidVariableMeasureRCNFormat"));
+        }
+
+        if (!validRCNPrefix) {
+            throw new RangeError(i18nextGS1.t("IdentificationKey.invalidVariableMeasureRCNPrefix"));
+        }
+
+        if (priceOrWeightCheckDigit !== "" && !isValidPriceOrWeightCheckDigit(priceOrWeight, priceOrWeightCheckDigit)) {
+            throw new RangeError(i18nextGS1.t("IdentificationKey.invalidVariableMeasurePriceOrWeight"));
+        }
+
+        if (!hasValidCheckDigit(rcn)) {
+            throw new RangeError(i18nextGS1.t("IdentificationKey.invalidCheckDigit"));
+        }
+
+        return {
+            itemReference: Number(itemReference),
+            priceOrWeight: Number(priceOrWeight)
+        };
+    }
 }
 
 /**
@@ -1194,6 +1340,9 @@ export interface NumericIdentificationKeyCreator extends NumericIdentificationKe
      * Create identification key(s) with reference(s) based on numeric value(s). The value(s) is/are converted to
      * references of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param valueOrValues
      * Numeric value(s).
      *
@@ -1219,7 +1368,8 @@ export interface NumericIdentificationKeyCreator extends NumericIdentificationKe
 }
 
 /**
- * Abstract numeric identification key creator. Implements common functionality for a numeric identification key creator.
+ * Abstract numeric identification key creator. Implements common functionality for a numeric identification key
+ * creator.
  */
 abstract class AbstractNumericIdentificationKeyCreator extends AbstractIdentificationKeyCreator implements NumericIdentificationKeyCreator {
     /**
@@ -1405,6 +1555,9 @@ export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentificat
      * Create GTIN-14(s) with an indicator digit and reference(s) based on numeric value(s). The value(s) is/are
      * converted to reference(s) of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param indicatorDigit
      * Indicator digit.
      *
@@ -1426,6 +1579,122 @@ export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentificat
             return partialIdentificationKey + checkDigit(partialIdentificationKey);
         });
     }
+
+    /**
+     * 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("IdentificationKey.invalidVariableMeasureRCNFormat"));
+        }
+
+        itemReferenceString = NUMERIC_CREATOR.create(itemReferenceLength, itemReference);
+        priceOrWeightString = NUMERIC_CREATOR.create(priceOrWeightLength, priceOrWeight);
+
+        rcnBuilders.push(checkDigitBuilder);
+
+        return rcnBuilders.reduce((partialRCN, rcnBuilder) => rcnBuilder(partialRCN), "");
+    }
 }
 
 /**
@@ -1487,6 +1756,9 @@ export class SerializableNumericIdentificationKeyCreator extends Mixin(Serializa
     /**
      * Concatenate a validated base identification key with serial component(s).
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param baseIdentificationKey
      * Base identification key.
      *
@@ -1521,7 +1793,7 @@ export class SerializableNumericIdentificationKeyCreator extends Mixin(Serializa
         if (typeof serialComponentOrComponents !== "object") {
             result = validateAndConcatenate(serialComponentOrComponents);
         } else {
-            result = transformIterable(serialComponentOrComponents, validateAndConcatenate);
+            result = mapIterable(serialComponentOrComponents, validateAndConcatenate);
         }
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled above.
@@ -1532,6 +1804,9 @@ export class SerializableNumericIdentificationKeyCreator extends Mixin(Serializa
      * Create serialized identification key(s) with a reference based on a numeric value concatenated with serial
      * component(s). The value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param value
      * Numeric value of the reference.
      *
@@ -1551,6 +1826,9 @@ export class SerializableNumericIdentificationKeyCreator extends Mixin(Serializa
     /**
      * Concatenate a base identification key with serial component(s).
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param baseIdentificationKey
      * Base identification key.
      *
@@ -1618,6 +1896,9 @@ export class NonNumericIdentificationKeyCreator extends Mixin(NonNumericIdentifi
     /**
      * Create identification key(s) with reference(s).
      *
+     * @template TTransformerInput
+     * Transformer input type.
+     *
      * @param referenceOrReferences
      * Reference(s).
      *
@@ -1653,7 +1934,7 @@ export class NonNumericIdentificationKeyCreator extends Mixin(NonNumericIdentifi
         if (typeof referenceOrReferences !== "object") {
             result = validateAndCreate(referenceOrReferences);
         } else {
-            result = transformIterable(referenceOrReferences, validateAndCreate);
+            result = mapIterable(referenceOrReferences, validateAndCreate);
         }
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled above.
@@ -1913,7 +2194,7 @@ export class PrefixManager {
 
         // Creator tweak factor is defined for numeric identification keys only.
         if (creatorTweakFactor !== undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Explicit cast without testing is necessary as "instanceof" doesn't work for mixin types.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion,no-param-reassign -- Explicit cast without testing is necessary as "instanceof" doesn't work for mixin types. Method purpose is to set the tweak.
             (creator as AbstractNumericIdentificationKeyCreator).tweak = this.tweakFactor * creatorTweakFactor;
         }
     }
@@ -2089,7 +2370,7 @@ export class PrefixManager {
      */
     private getIdentificationKeyCreator<TIdentificationKeyCreator extends IdentificationKeyCreator>(identificationKeyType: IdentificationKeyType, constructorCallback: () => TIdentificationKeyCreator): TIdentificationKeyCreator {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type is paired with constructor callback.
-        let creator = this._identificationKeyCreatorsMap.get(identificationKeyType) as (TIdentificationKeyCreator | undefined);
+        let creator = this._identificationKeyCreatorsMap.get(identificationKeyType) as TIdentificationKeyCreator | undefined;
 
         if (creator === undefined) {
             if (this.prefixType === PrefixType.GS18Prefix && identificationKeyType !== IdentificationKeyType.GTIN) {

package/src/locale/en/locale-strings.ts

@@ -1,11 +1,11 @@
 export const localeStrings = {
     Check: {
-        lengthOfStringForPriceOrWeightMustBeExactly: "Length {{length}} of string for price or weight sum must be exactly {{exactLength}}",
+        lengthOfStringForPriceOrWeightMustBeExactly: "Length {{length, number}} of string for price or weight must be 4 or 5",
         priceOrWeightComponent: "price or weight",
-        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length}} of string for check character pair must be less than or equal to {{maximumLength}}"
+        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "Length {{length, number}} of string for check character pair must be less than or equal to {{maximumLength, number}}"
     },
     IdentificationKey: {
-        identificationKeyTypeLength: "{{identificationKeyType}} must be {{length}} digits long",
+        identificationKeyTypeLength: "{{identificationKeyType}} must be {{length, number}} digits long",
         invalidCheckDigit: "Invalid check digit",
         invalidGTINLength: "GTIN must be 13, 12, 8, or 14 digits long",
         invalidGTIN14Length: "GTIN must be 14 digits long",
@@ -16,6 +16,10 @@ export const localeStrings = {
         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",
+        invalidRCNLength: "RCN length must match format length",
+        invalidVariableMeasureRCNFormat: "Invalid variable measure RCN format",
+        invalidVariableMeasureRCNPrefix: "Invalid variable measure RCN prefix",
+        invalidVariableMeasurePriceOrWeight: "Invalid variable measure price or weight",
         indicatorDigit: "indicator digit",
         serialComponent: "serial component",
         reference: "reference",

package/src/locale/fr/locale-strings.ts

@@ -1,11 +1,11 @@
 export const localeStrings = {
     Check: {
-        lengthOfStringForPriceOrWeightMustBeExactly: "La longueur {{longueur}} de la chaîne pour le prix ou la somme du poids doit être exactement {{exactLength}}",
+        lengthOfStringForPriceOrWeightMustBeExactly: "La longueur {{length, number}} de la chaîne pour le prix ou le poids doit être 4 ou 5",
         priceOrWeightComponent: "prix ou poids",
-        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "La longueur {{length}} de la chaîne pour la paire de caractères de vérification doit être inférieure ou égale à {{maximum Length}}"
+        lengthOfStringForCheckCharacterPairMustBeLessThanOrEqualTo: "La longueur {{length, number}} de la chaîne pour la paire de caractères de vérification doit être inférieure ou égale à {{maximum Length}}"
     },
     IdentificationKey: {
-        identificationKeyTypeLength: "{{identificationKeyType}} doit comporter {{length}} chiffres",
+        identificationKeyTypeLength: "{{identificationKeyType}} doit comporter {{length, number}} chiffres",
         invalidCheckDigit: "Chiffre de contrôle non valide",
         invalidGTINLength: "Le GTIN doit comporter 13, 12, 8 ou 14 chiffres",
         invalidGTIN14Length: "Le GTIN doit comporter 14 chiffres",
@@ -16,6 +16,10 @@ export const localeStrings = {
         invalidGTIN13AtRetail: "Le GTIN-13 au niveau des articles de consommation au détail ne peut pas commencer par zéro",
         invalidGTINAtRetail: "Le GTIN n'est pas pris en charge au niveau des articles de consommation au détail",
         invalidGTINAtOtherThanRetail: "Le GTIN n'est pas pris en charge à d'autres niveaux que ceux des articles de consommation au détail",
+        invalidRCNLength: "La longueur du RCN doit correspondre à la longueur du format",
+        invalidVariableMeasureRCNFormat: "Format RCN de mesure variable non valide",
+        invalidVariableMeasureRCNPrefix: "Préfixe RCN de mesure variable non valide",
+        invalidVariableMeasurePriceOrWeight: "Mesure variable invalide : prix ou poids",
         indicatorDigit: "chiffre indicateur",
         serialComponent: "composant série",
         reference: "référence",

package/src/locale/i18n.ts

@@ -1,6 +1,6 @@
-import { i18nAssertValidResources, i18nCoreInit, type I18NEnvironment } from "@aidc-toolkit/core";
+import { i18nAssertValidResources, i18nCoreInit, type I18nEnvironment } from "@aidc-toolkit/core";
 import { i18nUtilityInit, utilityResources } from "@aidc-toolkit/utility";
-import i18next, { type i18n } from "i18next";
+import i18next, { type i18n, type Resource } from "i18next";
 import { localeStrings as enLocaleStrings } from "./en/locale-strings.js";
 import { localeStrings as frLocaleStrings } from "./fr/locale-strings.js";
 
@@ -16,7 +16,7 @@ i18nAssertValidResources(enLocaleStrings, "fr", frLocaleStrings);
 /**
  * GS1 resources.
  */
-export const gs1Resources = {
+export const gs1Resources: Resource = {
     en: {
         aidct_gs1: enLocaleStrings
     },
@@ -40,7 +40,7 @@ export const i18nextGS1: i18n = i18next.createInstance();
  * @returns
  * Void promise.
  */
-export async function i18nGS1Init(environment: I18NEnvironment, debug = false): Promise<void> {
+export async function i18nGS1Init(environment: I18nEnvironment, debug = false): Promise<void> {
     await i18nUtilityInit(environment, debug);
     await i18nCoreInit(i18nextGS1, environment, debug, gs1NS, utilityResources, gs1Resources);
 }

package/test/check.test.ts

@@ -1,18 +1,18 @@
-import { I18NEnvironment } from "@aidc-toolkit/core";
+import { I18nEnvironment } from "@aidc-toolkit/core";
 import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { describe, expect, test } from "vitest";
 import {
     checkCharacterPair,
     checkDigit,
     checkDigitSum,
-    fiveDigitPriceWeightCheckDigit,
-    fourDigitPriceWeightCheckDigit,
     hasValidCheckCharacterPair,
     hasValidCheckDigit,
-    i18nGS1Init
+    i18nGS1Init,
+    isValidPriceOrWeightCheckDigit,
+    priceOrWeightCheckDigit
 } from "../src";
 
-await i18nGS1Init(I18NEnvironment.CLI, true);
+await i18nGS1Init(I18nEnvironment.CLI, true);
 
 describe("Check digit", () => {
     const testNumericString = "1234567890";
@@ -40,7 +40,7 @@ describe("Check digit", () => {
     });
 });
 
-describe("Price/weight check digit", () => {
+describe("Price or weight check digit", () => {
     function weight2Minus(characterIndex: number): number {
         const product = characterIndex * 2;
 
@@ -69,7 +69,10 @@ describe("Price/weight check digit", () => {
 
         const sum = weight2Minus(characterIndexes[0]) + weight2Minus(characterIndexes[1]) + weight3(characterIndexes[2]) + weight5Minus(characterIndexes[3]);
 
-        expect(fourDigitPriceWeightCheckDigit(s)).toBe(NUMERIC_CREATOR.character(sum * 3 % 10));
+        const checkDigit = priceOrWeightCheckDigit(s);
+
+        expect(checkDigit).toBe(NUMERIC_CREATOR.character(sum * 3 % 10));
+        expect(isValidPriceOrWeightCheckDigit(s, checkDigit)).toBe(true);
     }
 
     function testFiveDigitPriceWeightCheckDigit(s: string): void {
@@ -78,7 +81,10 @@ describe("Price/weight check digit", () => {
 
         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);
+        const checkDigit = priceOrWeightCheckDigit(s);
+
+        expect(weight5Minus(Number(checkDigit))).toBe(9 - (sum + 9) % 10);
+        expect(isValidPriceOrWeightCheckDigit(s, checkDigit)).toBe(true);
     }
 
     test("Four-digit", () => {
@@ -92,10 +98,6 @@ describe("Price/weight check digit", () => {
         testFourDigitPriceWeightCheckDigit("7890");
         testFourDigitPriceWeightCheckDigit("8901");
         testFourDigitPriceWeightCheckDigit("9012");
-
-        expect(() => fourDigitPriceWeightCheckDigit("l234")).toThrow("Invalid character 'l' at position 1");
-        expect(() => fourDigitPriceWeightCheckDigit("123")).toThrow("Length 3 of string for price or weight sum must be exactly 4");
-        expect(() => fourDigitPriceWeightCheckDigit("12345")).toThrow("Length 5 of string for price or weight sum must be exactly 4");
     });
 
     test("Five-digit", () => {
@@ -109,10 +111,12 @@ describe("Price/weight check digit", () => {
         testFiveDigitPriceWeightCheckDigit("78901");
         testFiveDigitPriceWeightCheckDigit("89012");
         testFiveDigitPriceWeightCheckDigit("90123");
+    });
 
-        expect(() => fiveDigitPriceWeightCheckDigit("l2345")).toThrow("Invalid character 'l' at position 1 of price or weight");
-        expect(() => fiveDigitPriceWeightCheckDigit("1234")).toThrow("Length 4 of string for price or weight sum must be exactly 5");
-        expect(() => fiveDigitPriceWeightCheckDigit("123456")).toThrow("Length 6 of string for price or weight sum must be exactly 5");
+    test("Invalid", () => {
+        expect(() => priceOrWeightCheckDigit("l2345")).toThrow("Invalid character 'l' at position 1 of price or weight");
+        expect(() => priceOrWeightCheckDigit("123")).toThrow("Length 3 of string for price or weight must be 4 or 5");
+        expect(() => priceOrWeightCheckDigit("123456")).toThrow("Length 6 of string for price or weight must be 4 or 5");
     });
 });