@aidc-toolkit/gs1 1.0.46-beta → 1.0.47-beta

package/src/gtin-creator.ts

@@ -1,10 +1,4 @@
-import {
-    type CharacterSetValidation,
-    Exclusions,
-    NUMERIC_CREATOR,
-    type TransformerInput,
-    type TransformerOutput
-} from "@aidc-toolkit/utility";
+import { type CharacterSetValidation, Exclusions, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { MixinAbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator.js";
 import { checkDigit } from "./check.js";
 import { type GTINBaseLength, GTINLengths } from "./gtin-length.js";
@@ -49,28 +43,46 @@ export class GTINCreator extends MixinAbstractNumericIdentifierCreator<
     }
 
     /**
-     * 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}.
+     * Create GTIN-14 with an indicator digit and reference based on a numeric value. The value is converted to a
+     * reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
-     * @template TTransformerInput
-     * Transformer input type.
+     * @param indicatorDigit
+     * Indicator digit.
+     *
+     * @param value
+     * Numeric value.
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery.
+     *
+     * @returns
+     * GTIN-14.
+     */
+    createGTIN14(indicatorDigit: string, value: number | bigint, sparse?: boolean): string;
+
+    /**
+     * Create GTIN-14s with an indicator digit and references based on numeric values. The values are converted to
+     * references of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
      * @param indicatorDigit
      * Indicator digit.
      *
-     * @param valueOrValues
-     * Numeric value(s).
+     * @param values
+     * Numeric values.
      *
      * @param sparse
-     * If true, the value(s) is/are mapped to a sparse sequence resistant to discovery. Default is false.
+     * If true, the values are mapped to a sparse sequence resistant to discovery.
      *
      * @returns
-     * GTIN-14(s).
+     * GTIN-14s.
      */
-    createGTIN14<TTransformerInput extends TransformerInput<number | bigint>>(indicatorDigit: string, valueOrValues: TTransformerInput, sparse = false): TransformerOutput<TTransformerInput, string> {
+    createGTIN14(indicatorDigit: string, values: Iterable<number | bigint>, sparse?: boolean): Iterable<string>;
+
+    // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+    createGTIN14(indicatorDigit: string, valueOrValues: number | bigint | Iterable<number | bigint>, sparse?: boolean): string | Iterable<string> {
         NUMERIC_CREATOR.validate(indicatorDigit, GTINCreator.#REQUIRED_INDICATOR_DIGIT_VALIDATION);
 
-        return NUMERIC_CREATOR.create(GTINLengths.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 === true ? this.tweak : undefined, (reference) => {
             const partialIdentifier = indicatorDigit + this.prefixProvider.gs1CompanyPrefix + reference;
 
             return partialIdentifier + checkDigit(partialIdentifier);

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

@@ -1,9 +1,4 @@
-import {
-    type CharacterSetValidation,
-    mapIterable,
-    type TransformerInput,
-    type TransformerOutput
-} from "@aidc-toolkit/utility";
+import { type CharacterSetValidation, mapIterable } from "@aidc-toolkit/utility";
 import { MixinAbstractIdentifierCreator } from "./abstract-identifier-creator.js";
 import { checkCharacterPair } from "./check.js";
 import { IdentifierDescriptors } from "./identifier-descriptors.js";
@@ -55,21 +50,29 @@ export class NonNumericIdentifierCreator extends MixinAbstractIdentifierCreator<
     }
 
     /**
-     * Create identifier(s) with reference(s).
+     * Create an identifier with a reference.
+     *
+     * @param reference
+     * Reference.
      *
-     * @template TTransformerInput
-     * Transformer input type.
+     * @returns
+     * Identifier.
+     */
+    create(reference: string): string;
+
+    /**
+     * Create identifiers with references.
      *
-     * @param referenceOrReferences
-     * Reference(s).
+     * @param references
+     * References.
      *
      * @returns
-     * Identifier(s).
+     * Identifiers.
      */
-    create<TTransformerInput extends TransformerInput<string>>(referenceOrReferences: TTransformerInput): TransformerOutput<TTransformerInput, string> {
-        // TODO Refactor type when https://github.com/microsoft/TypeScript/pull/56941 released.
-        let result: string | Iterable<string>;
+    create(references: Iterable<string>): Iterable<string>;
 
+    // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+    create(referenceOrReferences: string | Iterable<string>): string | Iterable<string> {
         const referenceCreator = this.referenceCreator;
         const referenceValidation = this.referenceValidation;
         const prefix = this.prefix;
@@ -92,13 +95,8 @@ export class NonNumericIdentifierCreator extends MixinAbstractIdentifierCreator<
             return requiresCheckCharacterPair ? partialIdentifier + checkCharacterPair(partialIdentifier) : partialIdentifier;
         }
 
-        if (typeof referenceOrReferences !== "object") {
-            result = validateAndCreate(referenceOrReferences);
-        } else {
-            result = mapIterable(referenceOrReferences, validateAndCreate);
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled above.
-        return result as TransformerOutput<TTransformerInput, string>;
+        return typeof referenceOrReferences !== "object" ?
+            validateAndCreate(referenceOrReferences) :
+            mapIterable(referenceOrReferences, validateAndCreate);
     }
 }

package/src/numeric-identifier-creator.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Used in JSDoc.
-import { NUMERIC_CREATOR, type TransformerInput, type TransformerOutput } from "@aidc-toolkit/utility";
+import { NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import type { IdentifierCreator } from "./identifier-creator.js";
 import type { NumericIdentifierType } from "./numeric-identifier-type.js";
 import type { NumericIdentifierValidation, NumericIdentifierValidator } from "./numeric-identifier-validator.js";
@@ -26,23 +26,37 @@ export interface NumericIdentifierCreator<TNumericIdentifierType extends Numeric
      */
     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 {@linkcode NUMERIC_CREATOR}.
-     *
-     * @template TTransformerInput
-     * Transformer input type.
-     *
-     * @param valueOrValues
-     * Numeric value(s).
-     *
-     * @param sparse
-     * If true, the value(s) are mapped to a sparse sequence resistant to discovery. Default is false.
-     *
-     * @returns
-     * Identifier(s).
-     */
-    create: <TTransformerInput extends TransformerInput<number | bigint>>(valueOrValues: TTransformerInput, sparse?: boolean) => TransformerOutput<TTransformerInput, string>;
+    create: {
+        /**
+         * Create an identifier with a reference based on a numeric value. The value is converted to a reference of the
+         * appropriate length using {@linkcode NUMERIC_CREATOR}.
+         *
+         * @param value
+         * Numeric value.
+         *
+         * @param sparse
+         * If true, the value is mapped to a sparse sequence resistant to discovery.
+         *
+         * @returns
+         * Identifier.
+         */
+        (value: number | bigint, sparse?: boolean): string;
+
+        /**
+         * Create identifiers with references based on numeric values. The values are converted to references of the
+         * appropriate length using {@linkcode NUMERIC_CREATOR}.
+         *
+         * @param values
+         * Numeric values.
+         *
+         * @param sparse
+         * If true, the values are mapped to a sparse sequence resistant to discovery.
+         *
+         * @returns
+         * Identifiers.
+         */
+        (values: Iterable<number | bigint>, sparse?: boolean): Iterable<string>;
+    };
 
     /**
      * Create all identifiers for the prefix from `0` to `capacity - 1`.

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

@@ -1,5 +1,5 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Used in JSDoc.
-import { mapIterable, NUMERIC_CREATOR, type TransformerInput, type TransformerOutput } from "@aidc-toolkit/utility";
+import { mapIterable, NUMERIC_CREATOR } from "@aidc-toolkit/utility";
 import { MixinAbstractNonGTINNumericIdentifierCreator } from "./abstract-non-gtin-numeric-identifier-creator.js";
 import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type.js";
 import { SerializableNumericIdentifierValidator } from "./serializable-numeric-identifier-validator.js";
@@ -11,24 +11,35 @@ export class SerializableNumericIdentifierCreator extends MixinAbstractNonGTINNu
     SerializableNumericIdentifierType
 >(SerializableNumericIdentifierValidator) {
     /**
-     * Concatenate a validated base identifier with serial component(s).
+     * Concatenate a validated base identifier with a serial component.
      *
-     * @template TTransformerInput
-     * Transformer input type.
+     * @param baseIdentifier
+     * Base identifier.
+     *
+     * @param serialComponent
+     * Serial component.
+     *
+     * @returns
+     * Serialized identifier.
+     */
+    #concatenateValidated(baseIdentifier: string, serialComponent: string): string;
+
+    /**
+     * Concatenate a validated base identifier with serial components.
      *
      * @param baseIdentifier
      * Base identifier.
      *
-     * @param serialComponentOrComponents
-     * Serial component(s).
+     * @param serialComponents
+     * Serial components.
      *
      * @returns
-     * Serialized identifier(s).
+     * Serialized identifiers.
      */
-    #concatenateValidated<TTransformerInput extends TransformerInput<string>>(baseIdentifier: string, serialComponentOrComponents: TTransformerInput): TransformerOutput<TTransformerInput, string> {
-        // TODO Refactor type when https://github.com/microsoft/TypeScript/pull/56941 released.
-        let result: string | Iterable<string>;
+    #concatenateValidated(baseIdentifier: string, serialComponents: Iterable<string>): Iterable<string>;
 
+    // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+    #concatenateValidated(baseIdentifier: string, serialComponentOrComponents: string | Iterable<string>): string | Iterable<string> {
         const serialComponentCreator = this.serialComponentCreator;
         const serialComponentValidation = this.serialComponentValidation;
 
@@ -47,55 +58,82 @@ export class SerializableNumericIdentifierCreator extends MixinAbstractNonGTINNu
             return baseIdentifier + serialComponent;
         }
 
-        if (typeof serialComponentOrComponents !== "object") {
-            result = validateAndConcatenate(serialComponentOrComponents);
-        } else {
-            result = mapIterable(serialComponentOrComponents, validateAndConcatenate);
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled above.
-        return result as TransformerOutput<TTransformerInput, string>;
+        return typeof serialComponentOrComponents !== "object" ?
+            validateAndConcatenate(serialComponentOrComponents) :
+            mapIterable(serialComponentOrComponents, validateAndConcatenate);
     }
 
     /**
-     * Create serialized identifier(s) with a reference based on a numeric value concatenated with serial component(s).
+     * Create a serialized identifier with a reference based on a numeric value concatenated with a serial component.
      * 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.
+     *
+     * @param serialComponent
+     * Serial component.
+     *
+     * @param sparse
+     * If true, the value is mapped to a sparse sequence resistant to discovery.
+     *
+     * @returns
+     * Serialized identifier.
+     */
+    createSerialized(value: number | bigint, serialComponent: string, sparse?: boolean): string;
+
+    /**
+     * Create serialized identifiers with a reference based on a numeric value concatenated with serial components. The
+     * value is converted to a reference of the appropriate length using {@linkcode NUMERIC_CREATOR}.
      *
      * @param value
      * Numeric value of the reference.
      *
-     * @param serialComponentOrComponents
-     * Serial component(s).
+     * @param serialComponents
+     * Serial components.
      *
      * @param sparse
-     * If true, the value is mapped to a sparse sequence resistant to discovery. Default is false.
+     * If true, the value is mapped to a sparse sequence resistant to discovery.
      *
      * @returns
      * Serialized identifiers.
      */
-    createSerialized<TTransformerInput extends TransformerInput<string>>(value: number, serialComponentOrComponents: TTransformerInput, sparse?: boolean): TransformerOutput<TTransformerInput, string> {
+    createSerialized(value: number | bigint, serialComponents: Iterable<string>, sparse?: boolean): Iterable<string>;
+
+    // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+    createSerialized(value: number | bigint, serialComponentOrComponents: string | Iterable<string>, sparse?: boolean): string | Iterable<string> {
         return this.#concatenateValidated(this.create(value, sparse), serialComponentOrComponents);
     }
 
     /**
-     * Concatenate a base identifier with serial component(s).
+     * Concatenate a base identifier with a serial component.
+     *
+     * @param baseIdentifier
+     * Base identifier.
+     *
+     * @param serialComponent
+     * Serial component.
      *
-     * @template TTransformerInput
-     * Transformer input type.
+     * @returns
+     * Serialized identifier.
+     */
+    concatenate(baseIdentifier: string, serialComponent: string): string;
+
+    /**
+     * Concatenate a base identifier with serial components.
      *
      * @param baseIdentifier
      * Base identifier.
      *
-     * @param serialComponentOrComponents
-     * Serial component(s).
+     * @param serialComponents
+     * Serial components.
      *
      * @returns
-     * Serialized identifier(s).
+     * Serialized identifiers.
      */
-    concatenate<TTransformerInput extends TransformerInput<string>>(baseIdentifier: string, serialComponentOrComponents: TTransformerInput): TransformerOutput<TTransformerInput, string> {
+    concatenate(baseIdentifier: string, serialComponents: Iterable<string>): Iterable<string>;
+
+    // eslint-disable-next-line jsdoc/require-jsdoc -- Implementation of overloaded signatures.
+    concatenate(baseIdentifier: string, serialComponentOrComponents: string | Iterable<string>): string | Iterable<string> {
         this.validate(baseIdentifier);
 
         return this.#concatenateValidated(baseIdentifier, serialComponentOrComponents);

package/src/version.ts

@@ -1,4 +1,4 @@
 /**
  * Repository version, updated automatically during publication.
  */
-export const VERSION = "1.0.46-beta";
+export const VERSION = "1.0.47-beta";