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

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

@@ -1,3 +1,4 @@
+import type { AbstractConstructor } from "@aidc-toolkit/core";
 import {
     CharacterSetCreator,
     Exclusions,
@@ -5,14 +6,9 @@ import {
     type TransformerInput,
     type TransformerOutput
 } from "@aidc-toolkit/utility";
-import {
-    type IdentifierCreatorConstructor,
-    type IdentifierExtensionConstructor,
-    type IdentifierValidatorConstructor,
-    MixinAbstractIdentifierCreator
-} from "./abstract-identifier-creator.js";
+import { type IdentifierCreatorConstructor, MixinAbstractIdentifierCreator } from "./abstract-identifier-creator.js";
 import { checkDigit, checkDigitSum } from "./check.js";
-import type { IdentifierTypeValidator } from "./identifier-validators.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 { NumericIdentifierType } from "./numeric-identifier-type.js";
@@ -22,9 +18,6 @@ import type { PrefixProvider } from "./prefix-provider.js";
 /**
  * Numeric identifier creator constructor type, which delegates to a numeric identifier validator constructor.
  *
- * @template TConstructorArguments
- * Constructor arguments types.
- *
  * @template TNumericIdentifierType
  * Numeric identifier type type.
  *
@@ -32,42 +25,31 @@ import type { PrefixProvider } from "./prefix-provider.js";
  * Numeric identifier validator type.
  */
 export type NumericIdentifierCreatorConstructor<
-    TConstructorArguments extends unknown[],
     TNumericIdentifierType extends NumericIdentifierType,
     TNumericIdentifierValidator extends NumericIdentifierValidator<TNumericIdentifierType>
-> = IdentifierExtensionConstructor<
-    [prefixProvider: PrefixProvider, prefix: string, ...args: TConstructorArguments],
+> = 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 TConstructorArguments
- * Constructor arguments types.
- *
  * @template TNumericIdentifierType
  * Numeric identifier type type.
  *
- * @template TNumericIdentifierValidatorConstructor
- * Numeric identifier validator constructor type.
- *
- * @param NumericIdentifierValidatorBase
+ * @param NumericIdentifierValidatorConstructor
  * Numeric identifier validator base.
  *
  * @returns
  * Numeric identifier creator class.
  */
 export function MixinAbstractNumericIdentifierCreator<
-    TConstructorArguments extends unknown[],
-    TNumericIdentifierType extends NumericIdentifierType,
-    TNumericIdentifierValidatorConstructor extends IdentifierValidatorConstructor<
-        TConstructorArguments,
-        TNumericIdentifierType,
-        NumericIdentifierValidation
-    >
->(NumericIdentifierValidatorBase: TNumericIdentifierValidatorConstructor): NumericIdentifierCreatorConstructor<
-    TConstructorArguments,
+    TNumericIdentifierType extends NumericIdentifierType
+>(NumericIdentifierValidatorConstructor: AbstractConstructor<
+    ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>,
+    IdentifierTypeValidator<TNumericIdentifierType>
+>): NumericIdentifierCreatorConstructor<
     TNumericIdentifierType,
     IdentifierTypeValidator<TNumericIdentifierType>
 > {
@@ -75,12 +57,13 @@ export function MixinAbstractNumericIdentifierCreator<
      * Abstract numeric identifier creator. Implements common functionality for a numeric identifier creator, mixed in
      * with a matching numeric identifier validator.
      */
-    abstract class AbstractNumericIdentifierCreator extends (MixinAbstractIdentifierCreator(NumericIdentifierValidatorBase) as IdentifierCreatorConstructor<
-        TConstructorArguments,
-        TNumericIdentifierType,
-        NumericIdentifierValidation,
-        NumericIdentifierValidator<TNumericIdentifierType>
-    >) implements NumericIdentifierCreator<TNumericIdentifierType> {
+    abstract class AbstractNumericIdentifierCreator extends (
+        MixinAbstractIdentifierCreator(NumericIdentifierValidatorConstructor) as IdentifierCreatorConstructor<
+            TNumericIdentifierType,
+            NumericIdentifierValidation,
+            NumericIdentifierValidator<TNumericIdentifierType>
+        >
+    ) implements NumericIdentifierCreator<TNumericIdentifierType> {
         /**
          * Capacity.
          */
@@ -103,7 +86,7 @@ export function MixinAbstractNumericIdentifierCreator<
          * @param args
          * Originating constructor arguments.
          */
-        constructor(prefixProvider: PrefixProvider, prefix: string, ...args: TConstructorArguments) {
+        constructor(prefixProvider: PrefixProvider, prefix: string, ...args: ConstructorParameters<IdentifierValidatorConstructorsEntry<TNumericIdentifierType>>) {
             super(prefixProvider, prefix, 1, ...args);
 
             // Capacity is always in number range.
@@ -227,10 +210,10 @@ export function MixinAbstractNumericIdentifierCreator<
     }
 
     // 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 IdentifierExtensionConstructor<
+    return AbstractNumericIdentifierCreator as AbstractConstructor<
         ConstructorParameters<typeof AbstractNumericIdentifierCreator>,
         unknown
-    > as IdentifierExtensionConstructor<
+    > as AbstractConstructor<
         ConstructorParameters<typeof AbstractNumericIdentifierCreator>,
         IdentifierTypeValidator<TNumericIdentifierType> & AbstractNumericIdentifierCreator
     >;

package/src/gtin-creator.ts

@@ -14,12 +14,10 @@ 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 MixinAbstractNumericIdentifierCreator<
-    [GTINBaseLength],
-    GTINType,
-    typeof GTINValidator
+    GTINType
 >(GTINValidator) {
     /**
      * Validation parameters for required indicator digit.

package/src/identifier-creators.ts

@@ -1,4 +1,6 @@
-import type { GTINCreator } from "./gtin-creator.js";
+import { GTINCreator } from "./gtin-creator.js";
+import type { GTINBaseLength } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
 import type { IdentifierCreator } from "./identifier-creator.js";
 import {
     type IdentifierTypeExtension,
@@ -11,10 +13,11 @@ import {
 } from "./identifier-extension.js";
 import type { IdentifierType } from "./identifier-type.js";
 import type { NonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator.js";
-import type { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
-import type { NonSerializableNumericIdentifierCreator } from "./non-serializable-numeric-identifier-creator.js";
+import { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
+import { NonSerializableNumericIdentifierCreator } from "./non-serializable-numeric-identifier-creator.js";
 import type { NumericIdentifierCreator } from "./numeric-identifier-creator.js";
-import type { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
+import type { PrefixProvider } from "./prefix-provider.js";
+import { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
 
 /**
  * Identifier creator type based on identifier type type.
@@ -48,6 +51,53 @@ export type IdentifierCreatorsRecord = {
     [TIdentifierType in IdentifierType]: IdentifierCreatorsEntry<TIdentifierType>;
 };
 
+/**
+ * GTIN creator constructor type.
+ */
+export type GTINCreatorConstructor =
+    new (prefixProvider: PrefixProvider, gtinBaseLength: GTINBaseLength) => GTINCreator;
+
+/**
+ * Non-GTIN creator constructor type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type NonGTINCreatorConstructor<TIdentifierType extends Exclude<IdentifierType, GTINType>> =
+    new (prefixProvider: PrefixProvider, identifierType: TIdentifierType) => IdentifierCreatorsRecord[TIdentifierType];
+
+/**
+ * Identifier creator constructors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierCreatorConstructorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ?
+    GTINCreatorConstructor :
+    NonGTINCreatorConstructor<Exclude<TIdentifierType, GTINType>>;
+
+/**
+ * Identifier creator constructors record type.
+ */
+export type IdentifierCreatorConstructorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierCreatorConstructorsEntry<TIdentifierType>;
+};
+
+export const IdentifierCreatorConstructors: IdentifierCreatorConstructorsRecord = {
+    GTIN: GTINCreator,
+    GLN: NonSerializableNumericIdentifierCreator,
+    SSCC: NonSerializableNumericIdentifierCreator,
+    GRAI: SerializableNumericIdentifierCreator,
+    GIAI: NonNumericIdentifierCreator,
+    GSRN: NonSerializableNumericIdentifierCreator,
+    GDTI: SerializableNumericIdentifierCreator,
+    GINC: NonNumericIdentifierCreator,
+    GSIN: NonSerializableNumericIdentifierCreator,
+    GCN: SerializableNumericIdentifierCreator,
+    CPID: NonNumericIdentifierCreator,
+    GMN: NonNumericIdentifierCreator
+};
+
 /**
  * Determine if identifier creator is a numeric identifier creator.
  *

package/src/identifier-validators.ts

@@ -1,6 +1,6 @@
 import type { GTINBaseLength } from "./gtin-length.js";
 import type { GTINType } from "./gtin-type.js";
-import { GTIN_VALIDATORS, type GTINValidator } from "./gtin-validator.js";
+import { GTIN_VALIDATORS, GTINValidator } from "./gtin-validator.js";
 import { isGTINDescriptors } from "./identifier-descriptors.js";
 import {
     type IdentifierTypeExtension,
@@ -105,13 +105,13 @@ export type IdentifierValidatorsEntry<TIdentifierType extends IdentifierType> =
  * Identifier validators record type.
  */
 export type IdentifierValidatorsRecord = {
-    readonly [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
+    [TIdentifierType in IdentifierType]: IdentifierValidatorsEntry<TIdentifierType>;
 };
 
 /**
  * Identifier validators for all identifier types.
  */
-export const IdentifierValidators: IdentifierValidatorsRecord = {
+export const IdentifierValidators: Readonly<IdentifierValidatorsRecord> = {
     [IdentifierTypes.GTIN]: GTIN_VALIDATORS,
     [IdentifierTypes.GLN]: GLN_VALIDATOR,
     [IdentifierTypes.SSCC]: SSCC_VALIDATOR,
@@ -126,6 +126,53 @@ export const IdentifierValidators: IdentifierValidatorsRecord = {
     [IdentifierTypes.GMN]: GMN_VALIDATOR
 };
 
+/**
+ * GTIN validator constructor type.
+ */
+export type GTINValidatorConstructor =
+    new (gtinBaseLength: GTINBaseLength) => GTINValidator;
+
+/**
+ * Non-GTIN validator constructor type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type NonGTINValidatorConstructor<TIdentifierType extends Exclude<IdentifierType, GTINType>> =
+    new (identifierType: TIdentifierType) => IdentifierValidatorsRecord[TIdentifierType];
+
+/**
+ * Identifier validator constructors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierValidatorConstructorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends GTINType ?
+    GTINValidatorConstructor :
+    NonGTINValidatorConstructor<Exclude<TIdentifierType, GTINType>>;
+
+/**
+ * Identifier validator constructors record type.
+ */
+export type IdentifierValidatorConstructorsRecord = {
+    readonly [TIdentifierType in IdentifierType]: IdentifierValidatorConstructorsEntry<TIdentifierType>;
+};
+
+export const IdentifierValidatorConstructors: IdentifierValidatorConstructorsRecord = {
+    GTIN: GTINValidator,
+    GLN: NonSerializableNumericIdentifierValidator,
+    SSCC: NonSerializableNumericIdentifierValidator,
+    GRAI: SerializableNumericIdentifierValidator,
+    GIAI: NonNumericIdentifierValidator,
+    GSRN: NonSerializableNumericIdentifierValidator,
+    GDTI: SerializableNumericIdentifierValidator,
+    GINC: NonNumericIdentifierValidator,
+    GSIN: NonSerializableNumericIdentifierValidator,
+    GCN: SerializableNumericIdentifierValidator,
+    CPID: NonNumericIdentifierValidator,
+    GMN: NonNumericIdentifierValidator
+};
+
 /**
  * Determine if identifier validators or validator is GTIN validators.
  *

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

@@ -19,10 +19,8 @@ import type { PrefixProvider } from "./prefix-provider.js";
  * Non-numeric identifier creator.
  */
 export class NonNumericIdentifierCreator extends MixinAbstractIdentifierCreator<
-    [NonNumericIdentifierType],
     NonNumericIdentifierType,
-    NonNumericIdentifierValidation,
-    typeof NonNumericIdentifierValidator
+    NonNumericIdentifierValidation
 >(NonNumericIdentifierValidator) {
     /**
      * Reference validation parameters.

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

@@ -6,7 +6,6 @@ import { NonSerializableNumericIdentifierValidator } from "./non-serializable-nu
  * Non-serializable numeric identifier creator.
  */
 export class NonSerializableNumericIdentifierCreator extends MixinAbstractNonGTINNumericIdentifierCreator<
-    NonSerializableNumericIdentifierType,
-    typeof NonSerializableNumericIdentifierValidator
+    NonSerializableNumericIdentifierType
 >(NonSerializableNumericIdentifierValidator) {
 }

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

@@ -1,7 +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/prefix-manager.ts

@@ -1,19 +1,22 @@
-import { GTINCreator } from "./gtin-creator.js";
+import type { GTINCreator } from "./gtin-creator.js";
 import { GTIN_BASE_TYPES } from "./gtin-length.js";
+import type { GTINType } from "./gtin-type.js";
 import type { IdentifierCreator } from "./identifier-creator.js";
-import { type IdentifierCreatorsRecord, isNumericIdentifierCreator } from "./identifier-creators.js";
+import {
+    IdentifierCreatorConstructors,
+    type IdentifierCreatorsRecord,
+    isNumericIdentifierCreator,
+    type NonGTINCreatorConstructor
+} from "./identifier-creators.js";
 import { type IdentifierType, IdentifierTypes } from "./identifier-type.js";
 import { i18nextGS1 } from "./locale/i18n.js";
-import { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
-import type { NonNumericIdentifierType } from "./non-numeric-identifier-type.js";
-import { NonSerializableNumericIdentifierCreator } from "./non-serializable-numeric-identifier-creator.js";
-import type { NonSerializableNumericIdentifierType } from "./non-serializable-numeric-identifier-type.js";
+import type { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator.js";
+import type { NonSerializableNumericIdentifierCreator } from "./non-serializable-numeric-identifier-creator.js";
 import type { NumericIdentifierType } from "./numeric-identifier-type.js";
 import type { PrefixProvider } from "./prefix-provider.js";
 import { type PrefixType, PrefixTypes } from "./prefix-type.js";
 import { PrefixValidator } from "./prefix-validator.js";
-import { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
-import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
+import type { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator.js";
 
 /**
  * Prefix manager. This is the core class for identifier creation.
@@ -232,33 +235,30 @@ export class PrefixManager implements PrefixProvider {
      * @template TIdentifierType
      * Identifier type type.
      *
-     * @template TConstructorArgument
-     * Second constructor argument type.
-     *
      * @param identifierType
-     * Identifier type used to construct identifier creator.
-     *
-     * @param constructorArgument
-     * Second constructor argument passed to constructor callback alongside this.
-     *
-     * @param ConstructorCallback
-     * Constructor callback.
+     * Identifier type for which to retrieve or construct identifier creator.
      *
      * @returns
      * Identifier creator.
      */
-    #getIdentifierCreator<TIdentifierType extends IdentifierType, TConstructorArgument>(identifierType: TIdentifierType, constructorArgument: TConstructorArgument, ConstructorCallback: new (prefixProvider: PrefixProvider, constructorParameter: TConstructorArgument) => IdentifierCreatorsRecord[TIdentifierType]): IdentifierCreatorsRecord[TIdentifierType] {
+    getIdentifierCreator<TIdentifierType extends IdentifierType>(identifierType: TIdentifierType): IdentifierCreatorsRecord[TIdentifierType] {
         let creator: IdentifierCreatorsRecord[TIdentifierType] | undefined = this.#identifierCreators[identifierType];
 
         if (creator === undefined) {
-            if (this.prefixType === PrefixTypes.GS18Prefix && identifierType !== IdentifierTypes.GTIN) {
-                throw new RangeError(i18nextGS1.t("Prefix.identifierTypeNotSupportedByGS18Prefix", {
-                    identifierType
-                }));
+            if (identifierType === IdentifierTypes.GTIN) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Types are known to match.
+                creator = new IdentifierCreatorConstructors.GTIN(this, GTIN_BASE_TYPES[this.prefixType]) as IdentifierCreatorsRecord[TIdentifierType];
+            } else {
+                if (this.prefixType === PrefixTypes.GS18Prefix) {
+                    throw new RangeError(i18nextGS1.t("Prefix.identifierTypeNotSupportedByGS18Prefix", {
+                        identifierType
+                    }));
+                }
+
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Types are known to match.
+                creator = new (IdentifierCreatorConstructors[identifierType] as unknown as NonGTINCreatorConstructor<Exclude<TIdentifierType, GTINType>>)(this, identifierType as Exclude<TIdentifierType, GTINType>);
             }
 
-            creator = new ConstructorCallback(this, constructorArgument);
-
             this.#setCreatorTweak(creator);
 
             this.#identifierCreators[identifierType] = creator;
@@ -267,126 +267,87 @@ export class PrefixManager implements PrefixProvider {
         return creator;
     }
 
-    /**
-     * Get non-GTIN numeric identifier creator.
-     *
-     * @param identifierType
-     * Identifier type used to construct identifier creator.
-     *
-     * @returns
-     * Identifier creator.
-     */
-    #getNonGTINNumericIdentifierCreator(identifierType: NonSerializableNumericIdentifierType): NonSerializableNumericIdentifierCreator {
-        return this.#getIdentifierCreator(identifierType, identifierType, NonSerializableNumericIdentifierCreator);
-    }
-
-    /**
-     * Get serialized numeric identifier creator.
-     *
-     * @param identifierType
-     * Identifier type used to construct identifier creator.
-     *
-     * @returns
-     * Identifier creator.
-     */
-    #getSerializableNumericIdentifierCreator(identifierType: SerializableNumericIdentifierType): SerializableNumericIdentifierCreator {
-        return this.#getIdentifierCreator(identifierType, identifierType, SerializableNumericIdentifierCreator);
-    }
-
-    /**
-     * Get non-numeric identifier creator.
-     *
-     * @param identifierType
-     * Identifier type used to construct identifier creator.
-     *
-     * @returns
-     * Identifier creator.
-     */
-    #getNonNumericIdentifierCreator(identifierType: NonNumericIdentifierType): NonNumericIdentifierCreator {
-        return this.#getIdentifierCreator(identifierType, identifierType, NonNumericIdentifierCreator);
-    }
-
     /**
      * Get GTIN creator.
      */
     get gtinCreator(): GTINCreator {
-        return this.#getIdentifierCreator(IdentifierTypes.GTIN, GTIN_BASE_TYPES[this.prefixType], GTINCreator);
+        return this.getIdentifierCreator(IdentifierTypes.GTIN);
     }
 
     /**
      * Get GLN creator.
      */
     get glnCreator(): NonSerializableNumericIdentifierCreator {
-        return this.#getNonGTINNumericIdentifierCreator(IdentifierTypes.GLN);
+        return this.getIdentifierCreator(IdentifierTypes.GLN);
     }
 
     /**
      * Get SSCC creator.
      */
     get ssccCreator(): NonSerializableNumericIdentifierCreator {
-        return this.#getNonGTINNumericIdentifierCreator(IdentifierTypes.SSCC);
+        return this.getIdentifierCreator(IdentifierTypes.SSCC);
     }
 
     /**
      * Get GRAI creator.
      */
     get graiCreator(): SerializableNumericIdentifierCreator {
-        return this.#getSerializableNumericIdentifierCreator(IdentifierTypes.GRAI);
+        return this.getIdentifierCreator(IdentifierTypes.GRAI);
     }
 
     /**
      * Get GIAI creator.
      */
     get giaiCreator(): NonNumericIdentifierCreator {
-        return this.#getNonNumericIdentifierCreator(IdentifierTypes.GIAI);
+        return this.getIdentifierCreator(IdentifierTypes.GIAI);
     }
 
     /**
      * Get GSRN creator.
      */
     get gsrnCreator(): NonSerializableNumericIdentifierCreator {
-        return this.#getNonGTINNumericIdentifierCreator(IdentifierTypes.GSRN);
+        return this.getIdentifierCreator(IdentifierTypes.GSRN);
     }
 
     /**
      * Get GDTI creator.
      */
     get gdtiCreator(): SerializableNumericIdentifierCreator {
-        return this.#getSerializableNumericIdentifierCreator(IdentifierTypes.GDTI);
+        return this.getIdentifierCreator(IdentifierTypes.GDTI);
     }
 
     /**
      * Get GINC creator.
      */
     get gincCreator(): NonNumericIdentifierCreator {
-        return this.#getNonNumericIdentifierCreator(IdentifierTypes.GINC);
+        return this.getIdentifierCreator(IdentifierTypes.GINC);
     }
 
     /**
      * Get GSIN creator.
      */
     get gsinCreator(): NonSerializableNumericIdentifierCreator {
-        return this.#getNonGTINNumericIdentifierCreator(IdentifierTypes.GSIN);
+        return this.getIdentifierCreator(IdentifierTypes.GSIN);
     }
 
     /**
      * Get GCN creator.
      */
     get gcnCreator(): SerializableNumericIdentifierCreator {
-        return this.#getSerializableNumericIdentifierCreator(IdentifierTypes.GCN);
+        return this.getIdentifierCreator(IdentifierTypes.GCN);
     }
 
     /**
      * Get CPID creator.
      */
     get cpidCreator(): NonNumericIdentifierCreator {
-        return this.#getNonNumericIdentifierCreator(IdentifierTypes.CPID);
+        return this.getIdentifierCreator(IdentifierTypes.CPID);
     }
 
     /**
      * Get GMN creator.
      */
     get gmnCreator(): NonNumericIdentifierCreator {
-        return this.#getNonNumericIdentifierCreator(IdentifierTypes.GMN);
+        return this.getIdentifierCreator(IdentifierTypes.GMN);
     }
 }

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

@@ -8,8 +8,7 @@ import { SerializableNumericIdentifierValidator } from "./serializable-numeric-i
  * Serializable numeric identifier creator.
  */
 export class SerializableNumericIdentifierCreator extends MixinAbstractNonGTINNumericIdentifierCreator<
-    SerializableNumericIdentifierType,
-    typeof SerializableNumericIdentifierValidator
+    SerializableNumericIdentifierType
 >(SerializableNumericIdentifierValidator) {
     /**
      * Concatenate a validated base identifier with serial component(s).

package/test/mixin.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+import {
+    GTINBaseLengths,
+    type IdentifierCreator,
+    IdentifierTypes,
+    IdentifierValidators,
+    PrefixManager,
+    PrefixTypes
+} from "../src/index.js";
+
+describe("Mixins", () => {
+    function validate<TValidator extends object, TCreator extends TValidator & IdentifierCreator>(validator: TValidator, creator: TCreator): void {
+        for (const key of Object.keys(validator)) {
+            expect(key in creator, key).toBe(true);
+        }
+    }
+
+    const prefixManager = PrefixManager.get(PrefixTypes.GS1CompanyPrefix, "9521234");
+
+    test(IdentifierTypes.GTIN, () => {
+        validate(IdentifierValidators.GTIN[GTINBaseLengths.GTIN13], prefixManager.gtinCreator);
+    });
+
+    test("Non-serialized numeric", () => {
+        validate(IdentifierValidators.GLN, prefixManager.glnCreator);
+    });
+
+    test("Serialized numeric", () => {
+        validate(IdentifierValidators.GRAI, prefixManager.graiCreator);
+    });
+
+    test("Non-numeric", () => {
+        validate(IdentifierValidators.GIAI, prefixManager.giaiCreator);
+    });
+});

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

@@ -7,12 +7,12 @@ import {
     PrefixTypes
 } from "../src/index.js";
 import { validateIdentifierValidator } from "./identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { characterSetCreatorFor } from "./utility.js";
 
 export function validateNonNumericIdentifierValidator(validator: NonNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, referenceCharacterSet: ContentCharacterSet, requiresCheckCharacterPair: boolean): void {
     validateIdentifierValidator(validator, identifierType, PrefixTypes.GS1CompanyPrefix, length);
 
-    const referenceCreator = creatorFor(referenceCharacterSet);
+    const referenceCreator = characterSetCreatorFor(referenceCharacterSet);
 
     expect(validator.referenceCharacterSet).toBe(referenceCharacterSet);
     expect(validator.referenceCreator).toBe(referenceCreator);

package/test/serializable-numeric-identifier-validator.ts

@@ -7,12 +7,12 @@ import type {
     SerializableNumericIdentifierValidator
 } from "../src/index.js";
 import { validateNonGTINNumericIdentifierValidator } from "./non-gtin-numeric-identifier-validator.js";
-import { creatorFor } from "./utility.js";
+import { characterSetCreatorFor } from "./utility.js";
 
 export function validateSerializableNumericIdentifierValidator(validator: SerializableNumericIdentifierValidator, isCreator: boolean, identifierType: IdentifierType, length: number, leaderType: LeaderType, serialLength: number, serialCharacterSet: ContentCharacterSet): void {
     validateNonGTINNumericIdentifierValidator(validator, isCreator, identifierType, length, leaderType);
 
-    const serialCreator = creatorFor(serialCharacterSet);
+    const serialCreator = characterSetCreatorFor(serialCharacterSet);
 
     expect(validator.serialComponentLength).toBe(serialLength);
     expect(validator.serialComponentCharacterSet).toBe(serialCharacterSet);

package/test/utility.ts

@@ -1,22 +1,22 @@
 import { type CharacterSetCreator, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { AI39_CREATOR, AI82_CREATOR, type ContentCharacterSet, ContentCharacterSets } from "../src/index.js";
 
-export function creatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
-    let creator: CharacterSetCreator;
+export function characterSetCreatorFor(characterSet: ContentCharacterSet): CharacterSetCreator {
+    let characterSetCreator: CharacterSetCreator;
 
     switch (characterSet) {
         case ContentCharacterSets.Numeric:
-            creator = NUMERIC_CREATOR;
+            characterSetCreator = NUMERIC_CREATOR;
             break;
 
         case ContentCharacterSets.AI82:
-            creator = AI82_CREATOR;
+            characterSetCreator = AI82_CREATOR;
             break;
 
         case ContentCharacterSets.AI39:
-            creator = AI39_CREATOR;
+            characterSetCreator = AI39_CREATOR;
             break;
     }
 
-    return creator;
+    return characterSetCreator;
 }

package/tsconfig.json

@@ -1,4 +1,5 @@
 {
+  "extends": "@aidc-toolkit/dev/tsconfig-template.json",
   "include": [],
   "references": [
     {