@aidc-toolkit/gs1 1.0.24-beta → 1.0.25-beta

package/src/non-numeric-identifier-validator.ts

@@ -1,28 +1,18 @@
 import { Exclusions, RegExpValidator } from "@aidc-toolkit/utility";
+import { AbstractIdentifierValidator } from "./abstract-identifier-validator";
 import { hasValidCheckCharacterPair } from "./check";
-import { type IdentifierType, IdentifierTypes } from "./identifier-type";
-import {
-    AbstractIdentifierValidator,
-    type ContentCharacterSet,
-    ContentCharacterSets,
-    type IdentifierValidation
-} from "./identifier-validator";
+import { IdentifierDescriptors } from "./descriptors";
+import type { IdentifierValidation } from "./identifier-validator";
 import { i18nextGS1 } from "./locale/i18n";
-import type { NumericIdentifierType } from "./numeric-identifier-validator";
-import { PrefixTypes } from "./prefix-type";
-
-/**
- * Non-numeric identifier type.
- */
-export type NonNumericIdentifierType = Exclude<IdentifierType, NumericIdentifierType>;
+import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type";
 
 /**
  * Non-numeric identifier validation parameters.
  */
 export interface NonNumericIdentifierValidation extends IdentifierValidation {
     /**
-     * Exclusion support for reference. Prevents non-numeric identifier from being mistaken for numeric
-     * identifier.
+     * Exclusion support for reference. Prevents non-numeric identifier from being mistaken for numeric identifier.
      */
     exclusion?: typeof Exclusions.None | typeof Exclusions.AllNumeric | undefined;
 }
@@ -30,7 +20,7 @@ export interface NonNumericIdentifierValidation extends IdentifierValidation {
 /**
  * Non-numeric identifier validator.
  */
-export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierValidation> {
+export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierDescriptor, NonNumericIdentifierValidation> {
     /**
      * Validator to ensure that an identifier (minus check character pair) is not all numeric.
      */
@@ -53,20 +43,13 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
      *
      * @param identifierType
      * Identifier type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param referenceCharacterSet
-     * Reference character set.
-     *
-     * @param requiresCheckCharacterPair
-     * True if the identifier requires a check character pair.
      */
-    constructor(identifierType: IdentifierType, length: number, referenceCharacterSet: ContentCharacterSet, requiresCheckCharacterPair = false) {
-        super(identifierType, PrefixTypes.GS1CompanyPrefix, length, referenceCharacterSet);
+    constructor(identifierType: NonNumericIdentifierType) {
+        const identifierDescriptor = IdentifierDescriptors[identifierType];
+
+        super(identifierDescriptor);
 
-        this._requiresCheckCharacterPair = requiresCheckCharacterPair;
+        this._requiresCheckCharacterPair = identifierDescriptor.requiresCheckCharacterPair;
     }
 
     /**
@@ -88,15 +71,14 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
     validate(identifier: string, validation?: NonNumericIdentifierValidation): void {
         const partialIdentifier = this.requiresCheckCharacterPair ? identifier.substring(0, identifier.length - 2) : identifier;
 
-        super.validatePrefix(partialIdentifier, validation?.positionOffset);
+        super.validatePrefix(partialIdentifier);
 
         if (!this.requiresCheckCharacterPair) {
             this.referenceCreator.validate(identifier, {
-                maximumLength: this.length,
-                positionOffset: validation?.positionOffset
+                maximumLength: this.length
             });
             // Validating the check character pair will also validate the characters.
-        } else if (!hasValidCheckCharacterPair(this.padIdentifier(identifier, validation))) {
+        } else if (!hasValidCheckCharacterPair(this.padIdentifier(identifier))) {
             throw new RangeError(i18nextGS1.t("Identifier.invalidCheckCharacterPair"));
         }
 
@@ -106,23 +88,3 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
         }
     }
 }
-
-/**
- * GIAI validator.
- */
-export const GIAI_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GIAI, 30, ContentCharacterSets.AI82);
-
-/**
- * GINC validator.
- */
-export const GINC_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GINC, 30, ContentCharacterSets.AI82);
-
-/**
- * CPID validator.
- */
-export const CPID_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.CPID, 30, ContentCharacterSets.AI39);
-
-/**
- * GMN validator.
- */
-export const GMN_VALIDATOR = new NonNumericIdentifierValidator(IdentifierTypes.GMN, 25, ContentCharacterSets.AI82, true);

package/src/numeric-identifier-creator.ts

@@ -1,27 +1,33 @@
-import {
-    CharacterSetCreator,
-    Exclusions,
-    NUMERIC_CREATOR,
-    type TransformerInput,
-    type TransformerOutput
-} from "@aidc-toolkit/utility";
-import { checkDigit, checkDigitSum } from "./check";
-import { AbstractIdentifierCreator, type IdentifierCreator } from "./identifier-creator";
-import { type LeaderType, LeaderTypes, type NumericIdentifierValidator } from "./numeric-identifier-validator";
-import type { PrefixProvider } from "./prefix-provider";
+import type { TransformerInput, TransformerOutput } from "@aidc-toolkit/utility";
+import type { IdentifierCreator } from "./identifier-creator";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
+import type { NumericIdentifierValidation, NumericIdentifierValidator } from "./numeric-identifier-validator";
 
 /**
  * Numeric identifier creator. Creates one or many numeric identifiers.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
  */
-export interface NumericIdentifierCreator extends NumericIdentifierValidator, IdentifierCreator {
+export interface NumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends NumericIdentifierValidator<TNumericIdentifierDescriptor>, IdentifierCreator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
     /**
      * Get the capacity (`10**referenceLength`).
      */
     get capacity(): number;
 
     /**
-     * Create identifier(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}.
+     * Get the tweak for sparse creation.
+     */
+    get tweak(): bigint;
+
+    /**
+     * Set the tweak for sparse creation.
+     */
+    set tweak(value: bigint);
+
+    /**
+     * Create identifier(s) with reference(s) based on numeric value(s). The value(s) is/are converted to references of
+     * the appropriate length using the numeric creator.
      *
      * @template TTransformerInput
      * Transformer input type.
@@ -49,152 +55,3 @@ export interface NumericIdentifierCreator extends NumericIdentifierValidator, Id
      */
     createAll: () => Iterable<string>;
 }
-
-/**
- * Abstract numeric identifier creator. Implements common functionality for a numeric identifier
- * creator.
- */
-export abstract class AbstractNumericIdentifierCreator extends AbstractIdentifierCreator implements NumericIdentifierCreator {
-    /**
-     * Capacity.
-     */
-    private _capacity!: number;
-
-    /**
-     * Tweak for sparse creation.
-     */
-    private _tweak = 0n;
-
-    /**
-     * 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.
-     */
-    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 get leaderType(): LeaderType;
-
-    /**
-     * @inheritDoc
-     */
-    get capacity(): number {
-        return this._capacity;
-    }
-
-    /**
-     * Get the tweak for sparse creation.
-     */
-    get tweak(): bigint {
-        return this._tweak;
-    }
-
-    /**
-     * Set the tweak for sparse creation.
-     */
-    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.
-     */
-    private 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);
-    }
-
-    /**
-     * @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));
-    }
-
-    /**
-     * 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;
-
-            let nextPartialCheckDigitSum = partialCheckDigitSum;
-
-            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);
-
-                    nextPartialCheckDigitSum += extensionWeight;
-                }
-            } 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));
-            }
-        };
-    }
-}

package/src/numeric-identifier-descriptor.ts

@@ -0,0 +1,23 @@
+import type { ContentCharacterSets } from "./content-character-set";
+import type { IdentifierDescriptor } from "./identifier-descriptor";
+import type { LeaderType, NumericIdentifierType } from "./numeric-identifier-type";
+
+/**
+ * Numeric identifier descriptor.
+ */
+export interface NumericIdentifierDescriptor extends IdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: NumericIdentifierType;
+
+    /**
+     * @inheritDoc
+     */
+    readonly referenceCharacterSet: typeof ContentCharacterSets.Numeric;
+
+    /**
+     * Leader type.
+     */
+    readonly leaderType: LeaderType;
+}

package/src/numeric-identifier-type.ts

@@ -0,0 +1,44 @@
+import type { IdentifierTypes } from "./identifier-type";
+
+/**
+ * Numeric identifier type.
+ */
+export type NumericIdentifierType =
+    typeof IdentifierTypes.GTIN |
+    typeof IdentifierTypes.GLN |
+    typeof IdentifierTypes.SSCC |
+    typeof IdentifierTypes.GRAI |
+    typeof IdentifierTypes.GSRN |
+    typeof IdentifierTypes.GDTI |
+    typeof IdentifierTypes.GSIN |
+    typeof IdentifierTypes.GCN;
+
+/**
+ * Leader type.
+ */
+export const LeaderTypes = {
+    /**
+     * No leader.
+     */
+    None: "None",
+
+    /**
+     * Indicator digit (GTIN only).
+     */
+    IndicatorDigit: "Indicator digit",
+
+    /**
+     * Extension digit (SSCC only).
+     */
+    ExtensionDigit: "Extension digit"
+} as const;
+
+/**
+ * Leader type key.
+ */
+export type LeaderTypeKey = keyof typeof LeaderTypes;
+
+/**
+ * Leader type.
+ */
+export type LeaderType = typeof LeaderTypes[LeaderTypeKey];

package/src/numeric-identifier-validator.ts

@@ -1,128 +1,25 @@
-import { hasValidCheckDigit } from "./check";
-import type { IdentifierType, IdentifierTypes } from "./identifier-type";
-import {
-    AbstractIdentifierValidator,
-    ContentCharacterSets,
-    type IdentifierValidation,
-    type IdentifierValidator
-} from "./identifier-validator";
-import { i18nextGS1 } from "./locale/i18n";
-import type { PrefixType } from "./prefix-type";
+import type { IdentifierValidation, IdentifierValidator } from "./identifier-validator";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
 
 /**
- * Numeric identifier type.
+ * Numeric identifier validation parameters.
  */
-export type NumericIdentifierType =
-    typeof IdentifierTypes.GTIN |
-    typeof IdentifierTypes.GLN |
-    typeof IdentifierTypes.SSCC |
-    typeof IdentifierTypes.GRAI |
-    typeof IdentifierTypes.GSRN |
-    typeof IdentifierTypes.GDTI |
-    typeof IdentifierTypes.GSIN |
-    typeof IdentifierTypes.GCN;
-
-/**
- * Leader type.
- */
-export const LeaderTypes = {
-    /**
-     * No leader.
-     */
-    None: "None",
-
-    /**
-     * Indicator digit (GTIN only).
-     */
-    IndicatorDigit: "Indicator digit",
-
-    /**
-     * Extension digit (SSCC only).
-     */
-    ExtensionDigit: "Extension digit"
-};
-
-/**
- * Leader type.
- */
-export type LeaderType = typeof LeaderTypes[keyof typeof LeaderTypes];
-
-/**
- * Numeric identifier validator. Validates a numeric identifier.
- */
-export interface NumericIdentifierValidator extends IdentifierValidator {
+export interface NumericIdentifierValidation extends IdentifierValidation {
     /**
-     * Get the leader type.
+     * Position offset within a larger string. Some numeric identifier types have the prefix offset by one.
      */
-    get leaderType(): LeaderType;
+    positionOffset?: number | undefined;
 }
 
 /**
- * Abstract numeric identifier validator. Implements common functionality for a numeric identifier
- * validator.
+ * Numeric identifier validator.
+ *
+ * @template TNumericIdentifierDescriptor
+ * Numeric identifier descriptor type.
  */
-export abstract class AbstractNumericIdentifierValidator extends AbstractIdentifierValidator implements NumericIdentifierValidator {
+export interface NumericIdentifierValidator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends IdentifierValidator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
     /**
-     * Leader type.
-     */
-    private readonly _leaderType: LeaderType;
-
-    /**
-     * Prefix position, determined by the leader type.
-     */
-    private readonly _prefixPosition: number;
-
-    /**
-     * Constructor.
-     *
-     * @param identifierType
-     * Identifier type.
-     *
-     * @param prefixType
-     * Prefix type.
-     *
-     * @param length
-     * Length.
-     *
-     * @param leaderType
-     * Leader type.
-     */
-    protected constructor(identifierType: IdentifierType, prefixType: PrefixType, length: number, leaderType: LeaderType) {
-        super(identifierType, prefixType, length, ContentCharacterSets.Numeric);
-
-        this._leaderType = leaderType;
-        this._prefixPosition = Number(this.leaderType === LeaderTypes.ExtensionDigit);
-    }
-
-    /**
-     * @inheritDoc
-     */
-    get leaderType(): LeaderType {
-        return this._leaderType;
-    }
-
-    /**
-     * @inheritDoc
+     * Get the leader type.
      */
-    validate(identifier: string, validation?: IdentifierValidation): void {
-        // Validate the prefix, with care taken for its position within the identifier.
-        if (this._prefixPosition === 0) {
-            super.validatePrefix(identifier, validation?.positionOffset);
-        } else {
-            super.validatePrefix(identifier.substring(this._prefixPosition), validation?.positionOffset === undefined ? this._prefixPosition : validation.positionOffset + this._prefixPosition);
-        }
-
-        // Validate the length.
-        if (identifier.length !== this.length) {
-            throw new RangeError(i18nextGS1.t("Identifier.identifierTypeLength", {
-                identifierType: this.identifierType,
-                length: this.length
-            }));
-        }
-
-        // Validating the check digit will also validate the characters.
-        if (!hasValidCheckDigit(this.padIdentifier(identifier, validation))) {
-            throw new RangeError(i18nextGS1.t("Identifier.invalidCheckDigit"));
-        }
-    }
+    get leaderType(): TNumericIdentifierDescriptor["leaderType"];
 }