@aidc-toolkit/gs1 1.0.26-beta → 1.0.28-beta

package/src/abstract-numeric-identifier-creator.ts

@@ -1,3 +1,4 @@
+import type { AbstractConstructor } from "@aidc-toolkit/core";
 import {
     CharacterSetCreator,
     Exclusions,
@@ -5,164 +6,215 @@ import {
     type TransformerInput,
     type TransformerOutput
 } from "@aidc-toolkit/utility";
-import { AbstractIdentifierCreator } from "./abstract-identifier-creator.js";
+import { type IdentifierCreatorConstructor, MixinAbstractIdentifierCreator } from "./abstract-identifier-creator.js";
 import { checkDigit, checkDigitSum } from "./check.js";
+import type { IdentifierTypeValidator, IdentifierValidatorConstructorsEntry } from "./identifier-validators.js";
+import { LeaderTypes } from "./leader-type.js";
 import type { NumericIdentifierCreator } from "./numeric-identifier-creator.js";
-import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
-import { type LeaderType, LeaderTypes } from "./numeric-identifier-type.js";
-import type { NumericIdentifierValidation } from "./numeric-identifier-validator.js";
+import type { NumericIdentifierType } from "./numeric-identifier-type.js";
+import type { NumericIdentifierValidation, NumericIdentifierValidator } from "./numeric-identifier-validator.js";
 import type { PrefixProvider } from "./prefix-provider.js";
 
 /**
- * Abstract numeric identifier creator. Implements common functionality for a numeric identifier creator.
+ * Numeric identifier creator constructor type, which delegates to a numeric identifier validator constructor.
  *
- * @template TNumericIdentifierDescriptor
- * Numeric identifier descriptor type.
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
+ *
+ * @template TNumericIdentifierValidator
+ * Numeric identifier validator type.
  */
-export abstract class AbstractNumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor> extends AbstractIdentifierCreator<TNumericIdentifierDescriptor, NumericIdentifierValidation> implements NumericIdentifierCreator<TNumericIdentifierDescriptor> {
-    /**
-     * Capacity.
-     */
-    private _capacity!: number;
-
-    /**
-     * Tweak for sparse creation.
-     */
-    private _tweak = 0n;
+export type NumericIdentifierCreatorConstructor<
+    TNumericIdentifierType extends NumericIdentifierType,
+    TNumericIdentifierValidator extends NumericIdentifierValidator<TNumericIdentifierType>
+> = AbstractConstructor<
+    [prefixProvider: PrefixProvider, prefix: string, ...args: ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>],
+    TNumericIdentifierValidator & NumericIdentifierCreator<TNumericIdentifierType>
+>;
 
+/**
+ * Mixin implementation of {@linkcode NumericIdentifierCreator} with an appropriate numeric identifier validator base.
+ *
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
+ *
+ * @param NumericIdentifierValidatorConstructor
+ * Numeric identifier validator base.
+ *
+ * @returns
+ * Numeric identifier creator class.
+ */
+export function MixinAbstractNumericIdentifierCreator<
+    TNumericIdentifierType extends NumericIdentifierType
+>(NumericIdentifierValidatorConstructor: AbstractConstructor<
+    ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>,
+    IdentifierTypeValidator<TNumericIdentifierType>
+>): NumericIdentifierCreatorConstructor<
+    TNumericIdentifierType,
+    IdentifierTypeValidator<TNumericIdentifierType>
+> {
     /**
-     * Initialize the prefix provider. This method is in lieu of a constructor due to the mixin architecture.
-     *
-     * @param prefixProvider
-     * Prefix provider.
-     *
-     * @param prefix
-     * Prefix within prefix manager to use to calculate reference length.
+     * Abstract numeric identifier creator. Implements common functionality for a numeric identifier creator, mixed in
+     * with a matching numeric identifier validator.
      */
-    protected override init(prefixProvider: PrefixProvider, prefix: string): void {
-        super.init(prefixProvider, prefix, 1);
-
-        // Capacity is always in number range.
-        this._capacity = Number(CharacterSetCreator.powerOf10(this.referenceLength));
-    }
+    abstract class AbstractNumericIdentifierCreator extends (
+        MixinAbstractIdentifierCreator(NumericIdentifierValidatorConstructor) as IdentifierCreatorConstructor<
+            TNumericIdentifierType,
+            NumericIdentifierValidation,
+            NumericIdentifierValidator<TNumericIdentifierType>
+        >
+    ) implements NumericIdentifierCreator<TNumericIdentifierType> {
+        /**
+         * Capacity.
+         */
+        readonly #capacity: number;
+
+        /**
+         * Tweak for sparse creation.
+         */
+        #tweak = 0n;
+
+        /**
+         * Constructor.
+         *
+         * @param prefixProvider
+         * Prefix provider.
+         *
+         * @param prefix
+         * Prefix within prefix provider to use to calculate reference length.
+         *
+         * @param args
+         * Originating constructor arguments.
+         */
+        constructor(prefixProvider: PrefixProvider, prefix: string, ...args: ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>) {
+            super(prefixProvider, prefix, 1, ...args);
+
+            // Capacity is always in number range.
+            this.#capacity = Number(CharacterSetCreator.powerOf10(this.referenceLength));
+        }
 
-    /**
-     * Get the leader type.
-     */
-    abstract get leaderType(): LeaderType;
+        /**
+         * @inheritDoc
+         */
+        get capacity(): number {
+            return this.#capacity;
+        }
 
-    /**
-     * @inheritDoc
-     */
-    get capacity(): number {
-        return this._capacity;
-    }
+        /**
+         * @inheritDoc
+         */
+        get tweak(): bigint {
+            return this.#tweak;
+        }
 
-    /**
-     * @inheritDoc
-     */
-    get tweak(): bigint {
-        return this._tweak;
-    }
+        /**
+         * @inheritDoc
+         */
+        set tweak(value: bigint) {
+            this.#tweak = value;
+        }
 
-    /**
-     * @inheritDoc
-     */
-    set tweak(value: bigint) {
-        this._tweak = value;
-    }
+        /**
+         * Build an identifier from a reference by merging it with the prefix and adding the check digit.
+         *
+         * @param reference
+         * Identifier reference.
+         *
+         * @returns
+         * Identifier.
+         */
+        #buildIdentifier(reference: string): string {
+            const partialIdentifier = this.leaderType === LeaderTypes.ExtensionDigit ? reference.substring(0, 1) + this.prefix + reference.substring(1) : this.prefix + reference;
+
+            return partialIdentifier + checkDigit(partialIdentifier);
+        }
 
-    /**
-     * Build an identifier from a reference by merging it with the prefix and adding the check digit.
-     *
-     * @param reference
-     * Identifier reference.
-     *
-     * @returns
-     * Identifier.
-     */
-    private buildIdentifier(reference: string): string {
-        const partialIdentifier = this.leaderType === LeaderTypes.ExtensionDigit ? reference.substring(0, 1) + this.prefix + reference.substring(1) : this.prefix + reference;
+        /**
+         * @inheritDoc
+         */
+        create<TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse = false): TransformerOutput<TTransformerInput, string> {
+            return NUMERIC_CREATOR.create(this.referenceLength, valueOrValues, Exclusions.None, sparse ? this.tweak : undefined, reference => this.#buildIdentifier(reference));
+        }
 
-        return partialIdentifier + checkDigit(partialIdentifier);
-    }
+        /**
+         * Create all identifiers from a partial identifier. Call is recursive until remaining reference
+         * length is 0.
+         *
+         * @param partialIdentifier
+         * Partial identifier. Initial value is `this.prefix`.
+         *
+         * @param remainingReferenceLength
+         * Remaining reference length. Initial value is `this.referenceLength`.
+         *
+         * @param extensionWeight
+         * If this value is not zero, the identifier has an extension digit, this call is setting it, and this value is
+         * applied to the calculation of the check digit.
+         *
+         * @param weight
+         * If the extension weight is zero, this value is applied to the calculation of the check digit.
+         *
+         * @param partialCheckDigitSum
+         * Partial check digit sum for the partial identifier.
+         *
+         * @yields
+         * Identifier.
+         */
+        static * createAllPartial(partialIdentifier: string, remainingReferenceLength: number, extensionWeight: number, weight: number, partialCheckDigitSum: number): Generator<string> {
+            if (remainingReferenceLength === 0) {
+                // Finalize check digit calculation and append.
+                yield partialIdentifier + NUMERIC_CREATOR.character(9 - (partialCheckDigitSum + 9) % 10);
+            } else {
+                const nextRemainingReferenceLength = remainingReferenceLength - 1;
 
-    /**
-     * @inheritDoc
-     */
-    create<TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse = false): TransformerOutput<TTransformerInput, string> {
-        return NUMERIC_CREATOR.create(this.referenceLength, valueOrValues, Exclusions.None, sparse ? this.tweak : undefined, reference => this.buildIdentifier(reference));
-    }
+                let nextPartialCheckDigitSum = partialCheckDigitSum;
 
-    /**
-     * Create all identifiers from a partial identifier. Call is recursive until remaining reference
-     * length is 0.
-     *
-     * @param partialIdentifier
-     * Partial identifier. Initial value is `this.prefix`.
-     *
-     * @param remainingReferenceLength
-     * Remaining reference length. Initial value is `this.referenceLength`.
-     *
-     * @param extensionWeight
-     * If this value is not zero, the identifier has an extension digit, this call is setting it, and this value is
-     * applied to the calculation of the check digit.
-     *
-     * @param weight
-     * If the extension weight is zero, this value is applied to the calculation of the check digit.
-     *
-     * @param partialCheckDigitSum
-     * Partial check digit sum for the partial identifier.
-     *
-     * @yields
-     * Identifier.
-     */
-    private static * createAllPartial(partialIdentifier: string, remainingReferenceLength: number, extensionWeight: number, weight: number, partialCheckDigitSum: number): Generator<string> {
-        if (remainingReferenceLength === 0) {
-            // Finalize check digit calculation and append.
-            yield partialIdentifier + NUMERIC_CREATOR.character(9 - (partialCheckDigitSum + 9) % 10);
-        } else {
-            const nextRemainingReferenceLength = remainingReferenceLength - 1;
+                if (extensionWeight !== 0) {
+                    // Apply every digit to the extension digit.
+                    for (const c of NUMERIC_CREATOR.characterSet) {
+                        yield * AbstractNumericIdentifierCreator.createAllPartial(c + partialIdentifier, nextRemainingReferenceLength, 0, weight, nextPartialCheckDigitSum);
 
-            let nextPartialCheckDigitSum = partialCheckDigitSum;
+                        nextPartialCheckDigitSum += extensionWeight;
+                    }
+                } else {
+                    const nextWeight = 4 - weight;
 
-            if (extensionWeight !== 0) {
-                // Apply every digit to the extension digit.
-                for (const c of NUMERIC_CREATOR.characterSet) {
-                    yield * AbstractNumericIdentifierCreator.createAllPartial(c + partialIdentifier, nextRemainingReferenceLength, 0, weight, nextPartialCheckDigitSum);
+                    // Apply every digit to the current character in the identifier.
+                    for (const c of NUMERIC_CREATOR.characterSet) {
+                        yield * AbstractNumericIdentifierCreator.createAllPartial(partialIdentifier + c, nextRemainingReferenceLength, 0, nextWeight, nextPartialCheckDigitSum);
 
-                    nextPartialCheckDigitSum += extensionWeight;
+                        nextPartialCheckDigitSum += weight;
+                    }
                 }
-            } else {
-                const nextWeight = 4 - weight;
-
-                // Apply every digit to the current character in the identifier.
-                for (const c of NUMERIC_CREATOR.characterSet) {
-                    yield * AbstractNumericIdentifierCreator.createAllPartial(partialIdentifier + c, nextRemainingReferenceLength, 0, nextWeight, nextPartialCheckDigitSum);
+            }
+        }
 
-                    nextPartialCheckDigitSum += weight;
+        /**
+         * @inheritDoc
+         */
+        createAll(): Iterable<string> {
+            const hasExtensionDigit = this.leaderType === LeaderTypes.ExtensionDigit;
+            const prefix = this.prefix;
+            const length = this.length;
+            const referenceLength = this.referenceLength;
+
+            // Start weight is for reference excluding extension digit, which has its weight calculated separately.
+            const startWeight = 3 - 2 * ((referenceLength + 1 - Number(hasExtensionDigit)) % 2);
+
+            // Returning separate Iterable object makes iteration repeatable.
+            return {
+                [Symbol.iterator]() {
+                    return AbstractNumericIdentifierCreator.createAllPartial(prefix, referenceLength, hasExtensionDigit ? 3 - 2 * length % 2 : 0, startWeight, checkDigitSum(startWeight === 3, prefix));
                 }
-            }
+            };
         }
     }
 
-    /**
-     * @inheritDoc
-     */
-    createAll(): Iterable<string> {
-        const hasExtensionDigit = this.leaderType === LeaderTypes.ExtensionDigit;
-        const prefix = this.prefix;
-        const length = this.length;
-        const referenceLength = this.referenceLength;
-
-        // Start weight is for reference excluding extension digit, which has its weight calculated separately.
-        const startWeight = 3 - 2 * ((referenceLength + 1 - Number(hasExtensionDigit)) % 2);
-
-        // Returning separate Iterable object makes iteration repeatable.
-        return {
-            [Symbol.iterator]() {
-                return AbstractNumericIdentifierCreator.createAllPartial(prefix, referenceLength, hasExtensionDigit ? 3 - 2 * length % 2 : 0, startWeight, checkDigitSum(startWeight === 3, prefix));
-            }
-        };
-    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Base class was upcast to type with statically known members for mixin, downcast result.
+    return AbstractNumericIdentifierCreator as AbstractConstructor<
+        ConstructorParameters<typeof AbstractNumericIdentifierCreator>,
+        unknown
+    > as AbstractConstructor<
+        ConstructorParameters<typeof AbstractNumericIdentifierCreator>,
+        IdentifierTypeValidator<TNumericIdentifierType> & AbstractNumericIdentifierCreator
+    >;
 }

package/src/content-character-set-creators.ts

@@ -0,0 +1,9 @@
+import { type CharacterSetCreator, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
+import { AI39_CREATOR, AI82_CREATOR } from "./character-set.js";
+import { type ContentCharacterSet, ContentCharacterSets } from "./content-character-set.js";
+
+export const CONTENT_CHARACTER_SET_CREATORS: Record<ContentCharacterSet, CharacterSetCreator> = {
+    [ContentCharacterSets.Numeric]: NUMERIC_CREATOR,
+    [ContentCharacterSets.AI82]: AI82_CREATOR,
+    [ContentCharacterSets.AI39]: AI39_CREATOR
+};

package/src/gtin-creator.ts

@@ -5,41 +5,40 @@ import {
     type TransformerInput,
     type TransformerOutput
 } from "@aidc-toolkit/utility";
-import { Mixin } from "ts-mixer";
-import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
+import { MixinAbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
 import { checkDigit, priceOrWeightCheckDigit } from "./check.js";
-import { type GTINBaseType, GTINTypes } from "./gtin-type.js";
+import { type GTINBaseLength, GTINLengths } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
 import { GTINValidator } from "./gtin-validator.js";
 import { i18nextGS1 } from "./locale/i18n.js";
 import type { PrefixProvider } from "./prefix-provider.js";
 
 /**
- * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; no applicable to GTIN-14 type.
+ * GTIN creator. Applicable to GTIN-13, GTIN-12, and GTIN-8 types; not applicable to GTIN-14 type.
  */
-export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentifierCreator) {
+export class GTINCreator extends MixinAbstractNumericIdentifierCreator<
+    GTINType
+>(GTINValidator) {
     /**
      * Validation parameters for required indicator digit.
      */
-    private static readonly REQUIRED_INDICATOR_DIGIT_VALIDATION: CharacterSetValidation = {
+    static readonly #REQUIRED_INDICATOR_DIGIT_VALIDATION: CharacterSetValidation = {
         minimumLength: 1,
         maximumLength: 1,
         component: () => i18nextGS1.t("Identifier.indicatorDigit")
     };
 
     /**
-     * Constructor. Typically called internally by a prefix manager but may be called by other code with another prefix
-     * provider type.
+     * Constructor.
      *
      * @param prefixProvider
      * Prefix provider.
      *
-     * @param gtinBaseType
-     * GTIN base type (all except GTIN-14).
+     * @param gtinBaseLength
+     * GTIN base length (all except GTIN-14).
      */
-    constructor(prefixProvider: PrefixProvider, gtinBaseType: GTINBaseType) {
-        super(gtinBaseType);
-
-        this.init(prefixProvider, prefixProvider.prefix);
+    constructor(prefixProvider: PrefixProvider, gtinBaseLength: GTINBaseLength) {
+        super(prefixProvider, prefixProvider.prefix, gtinBaseLength);
     }
 
     /**
@@ -69,9 +68,9 @@ export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentifierC
      * GTIN-14(s).
      */
     createGTIN14<TTransformerInput extends TransformerInput<number | bigint>>(indicatorDigit: string, valueOrValues: TTransformerInput, sparse = false): TransformerOutput<TTransformerInput, string> {
-        NUMERIC_CREATOR.validate(indicatorDigit, GTINCreator.REQUIRED_INDICATOR_DIGIT_VALIDATION);
+        NUMERIC_CREATOR.validate(indicatorDigit, GTINCreator.#REQUIRED_INDICATOR_DIGIT_VALIDATION);
 
-        return NUMERIC_CREATOR.create(GTINTypes.GTIN13 - this.prefixProvider.gs1CompanyPrefix.length - 1, valueOrValues, Exclusions.None, sparse ? this.tweak : undefined, (reference) => {
+        return NUMERIC_CREATOR.create(GTINLengths.GTIN13 - this.prefixProvider.gs1CompanyPrefix.length - 1, valueOrValues, Exclusions.None, sparse ? this.tweak : undefined, (reference) => {
             const partialIdentifier = indicatorDigit + this.prefixProvider.gs1CompanyPrefix + reference;
 
             return partialIdentifier + checkDigit(partialIdentifier);

package/src/gtin-descriptor.ts

@@ -1,6 +1,7 @@
-import type { IdentifierTypes } from "./identifier-type.js";
+import type { GTINBaseLength } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
+import type { LeaderTypes } from "./leader-type.js";
 import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
-import type { LeaderTypes } from "./numeric-identifier-type.js";
 
 /**
  * GTIN descriptor.
@@ -9,7 +10,12 @@ export interface GTINDescriptor extends NumericIdentifierDescriptor {
     /**
      * @inheritDoc
      */
-    readonly identifierType: typeof IdentifierTypes.GTIN;
+    readonly identifierType: GTINType;
+
+    /**
+     * @inheritDoc
+     */
+    readonly length: GTINBaseLength;
 
     /**
      * @inheritDoc

package/src/gtin-length.ts

@@ -0,0 +1,61 @@
+import { omit } from "@aidc-toolkit/core";
+import { type PrefixType, PrefixTypes } from "./prefix-type.js";
+
+/**
+ * GTIN lengths. The numeric values are equal to the lengths of the GTINs.
+ */
+export const GTINLengths = {
+    /**
+     * GTIN-13.
+     */
+    GTIN13: 13,
+
+    /**
+     * GTIN-12.
+     */
+    GTIN12: 12,
+
+    /**
+     * GTIN-8.
+     */
+    GTIN8: 8,
+
+    /**
+     * GTIN-14.
+     */
+    GTIN14: 14
+} as const;
+
+/**
+ * GTIN length key.
+ */
+export type GTINLengthKey = keyof typeof GTINLengths;
+
+/**
+ * GTIN length.
+ */
+export type GTINLength = typeof GTINLengths[GTINLengthKey];
+
+/**
+ * GTIN base lengths (all except GTIN-14).
+ */
+export const GTINBaseLengths = omit(GTINLengths, "GTIN14");
+
+/**
+ * GTIN base length key.
+ */
+export type GTINBaseLengthKey = keyof typeof GTINBaseLengths;
+
+/**
+ * GTIN length.
+ */
+export type GTINBaseLength = typeof GTINBaseLengths[GTINBaseLengthKey];
+
+/**
+ * GTIN base lengths by prefix type. Used to determine the GTIN length supported by a prefix type.
+ */
+export const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseLength>> = {
+    [PrefixTypes.GS1CompanyPrefix]: GTINLengths.GTIN13,
+    [PrefixTypes.UPCCompanyPrefix]: GTINLengths.GTIN12,
+    [PrefixTypes.GS18Prefix]: GTINLengths.GTIN8
+};

package/src/gtin-type.ts

@@ -1,29 +1,12 @@
-import { type PrefixType, PrefixTypes } from "./prefix-type.js";
+import { pick } from "@aidc-toolkit/core";
+import { NumericIdentifierTypes } from "./numeric-identifier-type.js";
 
 /**
- * GTIN types. The numeric values are equal to the lengths of the GTIN types.
+ * GTIN types.
  */
-export const GTINTypes = {
-    /**
-     * GTIN-13.
-     */
-    GTIN13: 13,
-
-    /**
-     * GTIN-12.
-     */
-    GTIN12: 12,
-
-    /**
-     * GTIN-8.
-     */
-    GTIN8: 8,
-
-    /**
-     * GTIN-14.
-     */
-    GTIN14: 14
-} as const;
+export const GTINTypes = pick(NumericIdentifierTypes,
+    NumericIdentifierTypes.GTIN
+);
 
 /**
  * GTIN type key.
@@ -34,17 +17,3 @@ export type GTINTypeKey = keyof typeof GTINTypes;
  * GTIN type.
  */
 export type GTINType = typeof GTINTypes[GTINTypeKey];
-
-/**
- * GTIN base type (all except GTIN-14).
- */
-export type GTINBaseType = Exclude<GTINType, typeof GTINTypes.GTIN14>;
-
-/**
- * GTIN base types by prefix type. Used to determine the GTIN type supported by a prefix type.
- */
-export const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseType>> = {
-    [PrefixTypes.GS1CompanyPrefix]: GTINTypes.GTIN13,
-    [PrefixTypes.UPCCompanyPrefix]: GTINTypes.GTIN12,
-    [PrefixTypes.GS18Prefix]: GTINTypes.GTIN8
-};