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

package/src/non-gtin-numeric-identifier-type.ts

@@ -1,7 +1,18 @@
-import type { IdentifierTypes } from "./identifier-type.js";
-import type { NumericIdentifierType } from "./numeric-identifier-type.js";
+import { exclude } from "@aidc-toolkit/core";
+import { GTINTypes } from "./gtin-type.js";
+import { NumericIdentifierTypes } from "./numeric-identifier-type.js";
+
+/**
+ * Non-GTIN numeric identifier types.
+ */
+export const NonGTINNumericIdentifierTypes = exclude(NumericIdentifierTypes, GTINTypes);
+
+/**
+ * Non-GTIN numeric identifier type key.
+ */
+export type NonGTINNumericIdentifierTypeKey = keyof typeof NonGTINNumericIdentifierTypes;
 
 /**
  * Non-GTIN numeric identifier type.
  */
-export type NonGTINNumericIdentifierType = Exclude<NumericIdentifierType, typeof IdentifierTypes.GTIN>;
+export type NonGTINNumericIdentifierType = typeof NonGTINNumericIdentifierTypes[NonGTINNumericIdentifierTypeKey];

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

@@ -1,20 +1,12 @@
-import { AbstractNumericIdentifierValidator } from "./abstract-numeric-identifier-validator.js";
-import { IdentifierDescriptors } from "./descriptors.js";
 import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
 import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type.js";
-import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import { NumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
 /**
  * Non-GTIN numeric identifier validator.
+ *
+ * @template TNonGTINNumericIdentifierType
+ * Non-GTIN numeric identifier type type.
  */
-export class NonGTINNumericIdentifierValidator extends AbstractNumericIdentifierValidator<NonGTINNumericIdentifierDescriptor> {
-    /**
-     * Constructor.
-     *
-     * @param identifierType
-     * Identifier type.
-     */
-    constructor(identifierType: Exclude<NonGTINNumericIdentifierType, SerializableNumericIdentifierType>) {
-        super(IdentifierDescriptors[identifierType]);
-    }
+export abstract class NonGTINNumericIdentifierValidator<TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NumericIdentifierValidator<TNonGTINNumericIdentifierType> implements NonGTINNumericIdentifierDescriptor {
 }

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

@@ -4,26 +4,31 @@ import {
     type TransformerInput,
     type TransformerOutput
 } from "@aidc-toolkit/utility";
-import { Mixin } from "ts-mixer";
-import { AbstractIdentifierCreator } from "./abstract-identifier-creator.js";
+import { MixinAbstractIdentifierCreator } from "./abstract-identifier-creator.js";
 import { checkCharacterPair } from "./check.js";
+import { IdentifierDescriptors } from "./identifier-descriptors.js";
 import { i18nextGS1 } from "./locale/i18n.js";
 import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
-import { NonNumericIdentifierValidator } from "./non-numeric-identifier-validator.js";
+import {
+    type NonNumericIdentifierValidation,
+    NonNumericIdentifierValidator
+} from "./non-numeric-identifier-validator.js";
 import type { PrefixProvider } from "./prefix-provider.js";
 
 /**
  * Non-numeric identifier creator.
  */
-export class NonNumericIdentifierCreator extends Mixin(NonNumericIdentifierValidator, AbstractIdentifierCreator) {
+export class NonNumericIdentifierCreator extends MixinAbstractIdentifierCreator<
+    NonNumericIdentifierType,
+    NonNumericIdentifierValidation
+>(NonNumericIdentifierValidator) {
     /**
      * Reference validation parameters.
      */
-    private readonly _referenceValidation: CharacterSetValidation;
+    readonly #referenceValidation: CharacterSetValidation;
 
     /**
-     * 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.
@@ -32,11 +37,9 @@ export class NonNumericIdentifierCreator extends Mixin(NonNumericIdentifierValid
      * Identifier type.
      */
     constructor(prefixProvider: PrefixProvider, identifierType: NonNumericIdentifierType) {
-        super(identifierType);
-
-        this.init(prefixProvider, prefixProvider.gs1CompanyPrefix, 2 * Number(this.requiresCheckCharacterPair));
+        super(prefixProvider, prefixProvider.gs1CompanyPrefix, 2 * Number(IdentifierDescriptors[identifierType].requiresCheckCharacterPair), identifierType);
 
-        this._referenceValidation = {
+        this.#referenceValidation = {
             minimumLength: 1,
             // Maximum reference length has to account for prefix and check character pair.
             maximumLength: this.referenceLength,
@@ -48,7 +51,7 @@ export class NonNumericIdentifierCreator extends Mixin(NonNumericIdentifierValid
      * Get the reference validation parameters.
      */
     protected get referenceValidation(): CharacterSetValidation {
-        return this._referenceValidation;
+        return this.#referenceValidation;
     }
 
     /**

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

@@ -1,7 +1,18 @@
-import type { IdentifierType } from "./identifier-type.js";
-import type { NumericIdentifierType } from "./numeric-identifier-type.js";
+import { exclude } from "@aidc-toolkit/core";
+import { IdentifierTypes } from "./identifier-type.js";
+import { NumericIdentifierTypes } from "./numeric-identifier-type.js";
+
+/**
+ * Non-numeric identifier types.
+ */
+export const NonNumericIdentifierTypes = exclude(IdentifierTypes, NumericIdentifierTypes);
+
+/**
+ * Non-numeric identifier type key.
+ */
+export type NonNumericIdentifierTypeKey = keyof typeof NonNumericIdentifierTypes;
 
 /**
  * Non-numeric identifier type.
  */
-export type NonNumericIdentifierType = Exclude<IdentifierType, NumericIdentifierType>;
+export type NonNumericIdentifierType = typeof NonNumericIdentifierTypes[NonNumericIdentifierTypeKey];

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

@@ -1,8 +1,7 @@
 import { Exclusions, RegExpValidator } from "@aidc-toolkit/utility";
-import { AbstractIdentifierValidator } from "./abstract-identifier-validator.js";
 import { hasValidCheckCharacterPair } from "./check.js";
-import { IdentifierDescriptors } from "./descriptors.js";
-import type { IdentifierValidation } from "./identifier-validator.js";
+import { IdentifierDescriptors } from "./identifier-descriptors.js";
+import { type IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
 import { i18nextGS1 } from "./locale/i18n.js";
 import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor.js";
 import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
@@ -20,11 +19,11 @@ export interface NonNumericIdentifierValidation extends IdentifierValidation {
 /**
  * Non-numeric identifier validator.
  */
-export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<NonNumericIdentifierDescriptor, NonNumericIdentifierValidation> {
+export class NonNumericIdentifierValidator extends IdentifierValidator<NonNumericIdentifierType, NonNumericIdentifierValidation> implements NonNumericIdentifierDescriptor {
     /**
      * Validator to ensure that an identifier (minus check character pair) is not all numeric.
      */
-    private static readonly NOT_ALL_NUMERIC_VALIDATOR = new class extends RegExpValidator {
+    static readonly #NOT_ALL_NUMERIC_VALIDATOR = new class extends RegExpValidator {
         /**
          * @inheritDoc
          */
@@ -36,7 +35,7 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
     /**
      * True if the identifier requires a check character pair.
      */
-    private readonly _requiresCheckCharacterPair: boolean;
+    readonly #requiresCheckCharacterPair: boolean;
 
     /**
      * Constructor.
@@ -49,14 +48,14 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
 
         super(identifierDescriptor);
 
-        this._requiresCheckCharacterPair = identifierDescriptor.requiresCheckCharacterPair;
+        this.#requiresCheckCharacterPair = identifierDescriptor.requiresCheckCharacterPair;
     }
 
     /**
      * Determine if the identifier requires a check character pair.
      */
     get requiresCheckCharacterPair(): boolean {
-        return this._requiresCheckCharacterPair;
+        return this.#requiresCheckCharacterPair;
     }
 
     /**
@@ -84,7 +83,7 @@ export class NonNumericIdentifierValidator extends AbstractIdentifierValidator<N
 
         // Check for all-numeric identifier (minus check character pair) if excluded.
         if (validation?.exclusion === Exclusions.AllNumeric) {
-            NonNumericIdentifierValidator.NOT_ALL_NUMERIC_VALIDATOR.validate(partialIdentifier);
+            NonNumericIdentifierValidator.#NOT_ALL_NUMERIC_VALIDATOR.validate(partialIdentifier);
         }
     }
 }

package/src/non-serializable-numeric-identifier-creator.ts

@@ -0,0 +1,11 @@
+import { MixinAbstractNonGTINNumericIdentifierCreator } from "./abstract-non-gtin-numeric-identifier-creator.js";
+import type { NonSerializableNumericIdentifierType } from "./non-serializable-numeric-identifier-type.js";
+import { NonSerializableNumericIdentifierValidator } from "./non-serializable-numeric-identifier-validator.js";
+
+/**
+ * Non-serializable numeric identifier creator.
+ */
+export class NonSerializableNumericIdentifierCreator extends MixinAbstractNonGTINNumericIdentifierCreator<
+    NonSerializableNumericIdentifierType
+>(NonSerializableNumericIdentifierValidator) {
+}

package/src/non-serializable-numeric-identifier-descriptor.ts

@@ -0,0 +1,12 @@
+import type { LeaderTypes } from "./leader-type.js";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor.js";
+
+/**
+ * Non-serializable numeric identifier descriptor.
+ */
+export interface NonSerializableNumericIdentifierDescriptor extends NonGTINNumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.None | typeof LeaderTypes.ExtensionDigit;
+}

package/src/non-serializable-numeric-identifier-type.ts

@@ -0,0 +1,22 @@
+import { pick } from "@aidc-toolkit/core";
+import { NonGTINNumericIdentifierTypes } from "./non-gtin-numeric-identifier-type.js";
+
+/**
+ * Non-serializable numeric identifier types.
+ */
+export const NonSerializableNumericIdentifierTypes = pick(NonGTINNumericIdentifierTypes,
+    NonGTINNumericIdentifierTypes.GLN,
+    NonGTINNumericIdentifierTypes.SSCC,
+    NonGTINNumericIdentifierTypes.GSRN,
+    NonGTINNumericIdentifierTypes.GSIN
+);
+
+/**
+ * Non-serializable numeric identifier type key.
+ */
+export type NonSerializableNumericIdentifierTypeKey = keyof typeof NonSerializableNumericIdentifierTypes;
+
+/**
+ * Non-serializable numeric identifier type.
+ */
+export type NonSerializableNumericIdentifierType = typeof NonSerializableNumericIdentifierTypes[NonSerializableNumericIdentifierTypeKey];

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

@@ -0,0 +1,19 @@
+import { IdentifierDescriptors } from "./identifier-descriptors.js";
+import { NonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
+import type { NonSerializableNumericIdentifierDescriptor } from "./non-serializable-numeric-identifier-descriptor.js";
+import type { NonSerializableNumericIdentifierType } from "./non-serializable-numeric-identifier-type.js";
+
+/**
+ * Non-serializable numeric identifier validator.
+ */
+export class NonSerializableNumericIdentifierValidator extends NonGTINNumericIdentifierValidator<NonSerializableNumericIdentifierType> implements NonSerializableNumericIdentifierDescriptor {
+    /**
+     * Constructor.
+     *
+     * @param identifierType
+     * Identifier type.
+     */
+    constructor(identifierType: NonSerializableNumericIdentifierType) {
+        super(IdentifierDescriptors[identifierType]);
+    }
+}

package/src/numeric-identifier-creator.ts

@@ -1,15 +1,16 @@
-import type { TransformerInput, TransformerOutput } from "@aidc-toolkit/utility";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Used in JSDoc.
+import { NUMERIC_CREATOR, type TransformerInput, type TransformerOutput } from "@aidc-toolkit/utility";
 import type { IdentifierCreator } from "./identifier-creator.js";
-import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
+import type { NumericIdentifierType } from "./numeric-identifier-type.js";
 import type { NumericIdentifierValidation, NumericIdentifierValidator } from "./numeric-identifier-validator.js";
 
 /**
  * Numeric identifier creator. Creates one or many numeric identifiers.
  *
- * @template TNumericIdentifierDescriptor
- * Numeric identifier descriptor type.
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
  */
-export interface NumericIdentifierCreator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends NumericIdentifierValidator<TNumericIdentifierDescriptor>, IdentifierCreator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
+export interface NumericIdentifierCreator<TNumericIdentifierType extends NumericIdentifierType = NumericIdentifierType> extends NumericIdentifierValidator<TNumericIdentifierType>, IdentifierCreator<TNumericIdentifierType, NumericIdentifierValidation> {
     /**
      * Get the capacity (`10**referenceLength`).
      */
@@ -27,7 +28,7 @@ export interface NumericIdentifierCreator<TNumericIdentifierDescriptor extends N
 
     /**
      * 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.
+     * the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
      * @template TTransformerInput
      * Transformer input type.

package/src/numeric-identifier-descriptor.ts

@@ -1,6 +1,7 @@
 import type { ContentCharacterSets } from "./content-character-set.js";
 import type { IdentifierDescriptor } from "./identifier-descriptor.js";
-import type { LeaderType, NumericIdentifierType } from "./numeric-identifier-type.js";
+import type { LeaderType } from "./leader-type.js";
+import type { NumericIdentifierType } from "./numeric-identifier-type.js";
 
 /**
  * Numeric identifier descriptor.

package/src/numeric-identifier-type.ts

@@ -1,44 +1,26 @@
-import type { IdentifierTypes } from "./identifier-type.js";
+import { pick } from "@aidc-toolkit/core";
+import { IdentifierTypes } from "./identifier-type.js";
 
 /**
- * Numeric identifier type.
+ * Numeric identifier types.
  */
-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;
+export const NumericIdentifierTypes = pick(IdentifierTypes,
+    IdentifierTypes.GTIN,
+    IdentifierTypes.GLN,
+    IdentifierTypes.SSCC,
+    IdentifierTypes.GRAI,
+    IdentifierTypes.GSRN,
+    IdentifierTypes.GDTI,
+    IdentifierTypes.GSIN,
+    IdentifierTypes.GCN
+);
 
 /**
- * Leader type.
+ * Numeric identifier type key.
  */
-export const LeaderTypes = {
-    /**
-     * No leader.
-     */
-    None: "None",
-
-    /**
-     * Indicator digit (GTIN only).
-     */
-    IndicatorDigit: "Indicator digit",
-
-    /**
-     * Extension digit (SSCC only).
-     */
-    ExtensionDigit: "Extension digit"
-} as const;
+export type NumericIdentifierTypeKey = keyof typeof NumericIdentifierTypes;
 
 /**
- * Leader type key.
- */
-export type LeaderTypeKey = keyof typeof LeaderTypes;
-
-/**
- * Leader type.
+ * Numeric identifier type.
  */
-export type LeaderType = typeof LeaderTypes[LeaderTypeKey];
+export type NumericIdentifierType = typeof NumericIdentifierTypes[NumericIdentifierTypeKey];

package/src/numeric-identifier-validator.ts

@@ -1,5 +1,10 @@
-import type { IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
+import { hasValidCheckDigit } from "./check.js";
+import type { IdentifierTypeDescriptor } from "./identifier-descriptors.js";
+import { type IdentifierValidation, IdentifierValidator } from "./identifier-validator.js";
+import { LeaderTypes } from "./leader-type.js";
+import { i18nextGS1 } from "./locale/i18n.js";
 import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor.js";
+import type { NumericIdentifierType } from "./numeric-identifier-type.js";
 
 /**
  * Numeric identifier validation parameters.
@@ -14,12 +19,62 @@ export interface NumericIdentifierValidation extends IdentifierValidation {
 /**
  * Numeric identifier validator.
  *
- * @template TNumericIdentifierDescriptor
- * Numeric identifier descriptor type.
+ * @template TNumericIdentifierType
+ * Numeric identifier type type.
  */
-export interface NumericIdentifierValidator<TNumericIdentifierDescriptor extends NumericIdentifierDescriptor = NumericIdentifierDescriptor> extends IdentifierValidator<TNumericIdentifierDescriptor, NumericIdentifierValidation> {
+export abstract class NumericIdentifierValidator<TNumericIdentifierType extends NumericIdentifierType = NumericIdentifierType> extends IdentifierValidator<TNumericIdentifierType, NumericIdentifierValidation> implements NumericIdentifierDescriptor {
     /**
-     * Get the leader type.
+     * Leader type.
      */
-    get leaderType(): TNumericIdentifierDescriptor["leaderType"];
+    readonly #leaderType: IdentifierTypeDescriptor<TNumericIdentifierType>["leaderType"];
+
+    /**
+     * Prefix position, determined by the leader type.
+     */
+    readonly #prefixPosition: number;
+
+    /**
+     * Constructor.
+     *
+     * @param identifierDescriptor
+     * Identifier descriptor.
+     */
+    constructor(identifierDescriptor: IdentifierTypeDescriptor<TNumericIdentifierType>) {
+        super(identifierDescriptor);
+
+        this.#leaderType = identifierDescriptor.leaderType;
+        this.#prefixPosition = Number(this.leaderType === LeaderTypes.ExtensionDigit);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    get leaderType(): IdentifierTypeDescriptor<TNumericIdentifierType>["leaderType"] {
+        return this.#leaderType;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    validate(identifier: string, validation?: NumericIdentifierValidation): 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?.positionOffset))) {
+            throw new RangeError(i18nextGS1.t("Identifier.invalidCheckDigit"));
+        }
+    }
 }