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

package/src/creators.ts

@@ -0,0 +1,113 @@
+import {
+    isGTINDescriptor,
+    isNonGTINNumericIdentifierDescriptor,
+    isNonNumericIdentifierDescriptor,
+    isNumericIdentifierDescriptor,
+    isSerializableNumericIdentifierDescriptor
+} from "./descriptors";
+import type { GTINCreator } from "./gtin-creator";
+import type { IdentifierCreator } from "./identifier-creator";
+import type { IdentifierType, IdentifierTypes } from "./identifier-type";
+import type { NonGTINNumericIdentifierCreator } from "./non-gtin-numeric-identifier-creator";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type";
+import type { NonNumericIdentifierCreator } from "./non-numeric-identifier-creator";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type";
+import type { NumericIdentifierCreator } from "./numeric-identifier-creator";
+import type { SerializableNumericIdentifierCreator } from "./serializable-numeric-identifier-creator";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type";
+
+/**
+ * Determine the identifier creator type for an identifier type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeCreator<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
+    NonNumericIdentifierCreator :
+    TIdentifierType extends SerializableNumericIdentifierType ?
+        SerializableNumericIdentifierCreator :
+        TIdentifierType extends NonGTINNumericIdentifierType ?
+            NonGTINNumericIdentifierCreator :
+            TIdentifierType extends typeof IdentifierTypes.GTIN ?
+                GTINCreator :
+                IdentifierCreator;
+
+/**
+ * Identifier creators entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierCreatorsEntry<TIdentifierType extends IdentifierType> = IdentifierTypeCreator<TIdentifierType>;
+
+/**
+ * Identifier creators record type.
+ */
+export type IdentifierCreatorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierCreatorsEntry<TIdentifierType>;
+};
+
+/**
+ * Determine if identifier creator is a numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a numeric identifier creator.
+ */
+export function isNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NumericIdentifierCreator {
+    return isNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a GTIN creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a GTIN creator.
+ */
+export function isGTINCreator(identifierCreator: IdentifierCreator): identifierCreator is GTINCreator {
+    return isGTINDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-GTIN numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-GTIN numeric identifier creator.
+ */
+export function isNonGTINNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonGTINNumericIdentifierCreator {
+    return isNonGTINNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a serializable numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a serializable numeric identifier creator.
+ */
+export function isSerializableNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is SerializableNumericIdentifierCreator {
+    return isSerializableNumericIdentifierDescriptor(identifierCreator);
+}
+
+/**
+ * Determine if identifier creator is a non-numeric identifier creator.
+ *
+ * @param identifierCreator
+ * Identifier creator.
+ *
+ * @returns
+ * True if identifier creator is a non-numeric identifier creator.
+ */
+export function isNonNumericIdentifierCreator(identifierCreator: IdentifierCreator): identifierCreator is NonNumericIdentifierCreator {
+    return isNonNumericIdentifierDescriptor(identifierCreator);
+}

package/src/descriptors.ts

@@ -0,0 +1,332 @@
+import { ContentCharacterSets } from "./content-character-set";
+import type { GTINDescriptor } from "./gtin-descriptor";
+import { type GTINBaseType, GTINTypes } from "./gtin-type";
+import type { IdentifierDescriptor } from "./identifier-descriptor";
+import { type IdentifierType, IdentifierTypes } from "./identifier-type";
+import type { NonGTINNumericIdentifierDescriptor } from "./non-gtin-numeric-identifier-descriptor";
+import type { NonGTINNumericIdentifierType } from "./non-gtin-numeric-identifier-type";
+import type { NonNumericIdentifierDescriptor } from "./non-numeric-identifier-descriptor";
+import type { NonNumericIdentifierType } from "./non-numeric-identifier-type";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
+import { LeaderTypes, type NumericIdentifierType } from "./numeric-identifier-type";
+import { PrefixTypes } from "./prefix-type";
+import type { SerializableNumericIdentifierDescriptor } from "./serializable-numeric-identifier-descriptor";
+import type { SerializableNumericIdentifierType } from "./serializable-numeric-identifier-type";
+
+/**
+ * GTIN-13 descriptor.
+ */
+const GTIN13_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: GTINTypes.GTIN13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN-12 descriptor.
+ */
+const GTIN12_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.UPCCompanyPrefix,
+    length: GTINTypes.GTIN12,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN-8 descriptor.
+ */
+const GTIN8_DESCRIPTOR: GTINDescriptor = {
+    identifierType: IdentifierTypes.GTIN,
+    prefixType: PrefixTypes.GS18Prefix,
+    length: GTINTypes.GTIN8,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.IndicatorDigit
+};
+
+/**
+ * GTIN descriptors indexed by prefix type.
+ */
+const GTIN_DESCRIPTORS: Readonly<Record<GTINBaseType, GTINDescriptor>> = {
+    [GTINTypes.GTIN13]: GTIN13_DESCRIPTOR,
+    [GTINTypes.GTIN12]: GTIN12_DESCRIPTOR,
+    [GTINTypes.GTIN8]: GTIN8_DESCRIPTOR
+};
+
+/**
+ * GLN descriptor.
+ */
+const GLN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GLN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * SSCC descriptor.
+ */
+const SSCC_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.SSCC,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 18,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.ExtensionDigit
+};
+
+/**
+ * GRAI descriptor.
+ */
+const GRAI_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GRAI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 16,
+    serialComponentCharacterSet: ContentCharacterSets.AI82
+};
+
+/**
+ * GIAI descriptor.
+ */
+const GIAI_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GIAI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GSRN descriptor.
+ */
+const GSRN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GSRN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 18,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * GDTI descriptor.
+ */
+const GDTI_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GDTI,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 17,
+    serialComponentCharacterSet: ContentCharacterSets.AI82
+};
+
+/**
+ * GINC descriptor.
+ */
+const GINC_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GINC,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GSIN descriptor.
+ */
+const GSIN_DESCRIPTOR: NonGTINNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GSIN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 17,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None
+};
+
+/**
+ * GCN descriptor.
+ */
+const GCN_DESCRIPTOR: SerializableNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GCN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 13,
+    referenceCharacterSet: ContentCharacterSets.Numeric,
+    leaderType: LeaderTypes.None,
+    serialComponentLength: 12,
+    serialComponentCharacterSet: ContentCharacterSets.Numeric
+};
+
+/**
+ * CPID descriptor.
+ */
+const CPID_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.CPID,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 30,
+    referenceCharacterSet: ContentCharacterSets.AI39,
+    requiresCheckCharacterPair: false
+};
+
+/**
+ * GMN descriptor.
+ */
+const GMN_DESCRIPTOR: NonNumericIdentifierDescriptor = {
+    identifierType: IdentifierTypes.GMN,
+    prefixType: PrefixTypes.GS1CompanyPrefix,
+    length: 25,
+    referenceCharacterSet: ContentCharacterSets.AI82,
+    requiresCheckCharacterPair: true
+};
+
+/**
+ * Identifier descriptor type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierTypeDescriptor<TIdentifierType extends IdentifierType> = TIdentifierType extends NonNumericIdentifierType ?
+    NonNumericIdentifierDescriptor :
+    TIdentifierType extends SerializableNumericIdentifierType ?
+        SerializableNumericIdentifierDescriptor :
+        TIdentifierType extends NonGTINNumericIdentifierType ?
+            NonGTINNumericIdentifierDescriptor :
+            TIdentifierType extends typeof IdentifierTypes.GTIN ?
+                GTINDescriptor :
+                IdentifierDescriptor;
+
+/**
+ * Identifier descriptors entry type based on identifier type type.
+ *
+ * @template TIdentifierType
+ * Identifier type type.
+ */
+export type IdentifierDescriptorsEntry<TIdentifierType extends IdentifierType> = TIdentifierType extends typeof IdentifierTypes.GTIN ?
+    Readonly<Record<GTINBaseType, GTINDescriptor>> :
+    IdentifierTypeDescriptor<TIdentifierType>;
+
+/**
+ * Identifier descriptors record type.
+ */
+export type IdentifierDescriptorsRecord = {
+    [TIdentifierType in IdentifierType]: IdentifierDescriptorsEntry<TIdentifierType>;
+};
+
+/**
+ * Identifier descriptors for all identifier types.
+ */
+export const IdentifierDescriptors: IdentifierDescriptorsRecord = {
+    [IdentifierTypes.GTIN]: GTIN_DESCRIPTORS,
+    [IdentifierTypes.GLN]: GLN_DESCRIPTOR,
+    [IdentifierTypes.SSCC]: SSCC_DESCRIPTOR,
+    [IdentifierTypes.GRAI]: GRAI_DESCRIPTOR,
+    [IdentifierTypes.GIAI]: GIAI_DESCRIPTOR,
+    [IdentifierTypes.GSRN]: GSRN_DESCRIPTOR,
+    [IdentifierTypes.GDTI]: GDTI_DESCRIPTOR,
+    [IdentifierTypes.GINC]: GINC_DESCRIPTOR,
+    [IdentifierTypes.GSIN]: GSIN_DESCRIPTOR,
+    [IdentifierTypes.GCN]: GCN_DESCRIPTOR,
+    [IdentifierTypes.CPID]: CPID_DESCRIPTOR,
+    [IdentifierTypes.GMN]: GMN_DESCRIPTOR
+} as const;
+
+/**
+ * Determine if identifier descriptors or descriptor is GTIN descriptors.
+ *
+ * @param identifierDescriptorsOrDescriptor
+ * Identifier descriptors or descriptor.
+ *
+ * @returns
+ * True if GTIN descriptors.
+ */
+export function isGTINDescriptors(identifierDescriptorsOrDescriptor: IdentifierDescriptorsEntry<IdentifierType>): identifierDescriptorsOrDescriptor is Readonly<Record<GTINBaseType, GTINDescriptor>> {
+    return !("identifierType" in identifierDescriptorsOrDescriptor);
+}
+
+/**
+ * Determine if an array of identifier types includes a given identifier type.
+ *
+ * @param identifierTypes
+ * Identifier types.
+ *
+ * @param identifierType
+ * Identifier type.
+ *
+ * @returns
+ * True if element is included in the array.
+ */
+function identifierTypesIncludes(identifierTypes: readonly IdentifierType[], identifierType: IdentifierType): boolean {
+    return identifierTypes.includes(identifierType);
+}
+
+const NUMERIC_IDENTIFIER_TYPES: readonly NumericIdentifierType[] = [IdentifierTypes.GTIN, IdentifierTypes.GLN, IdentifierTypes.SSCC, IdentifierTypes.GRAI, IdentifierTypes.GSRN, IdentifierTypes.GDTI, IdentifierTypes.GSIN, IdentifierTypes.GCN];
+
+/**
+ * Determine if identifier descriptor is a numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a numeric identifier descriptor.
+ */
+export function isNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NumericIdentifierDescriptor {
+    return identifierTypesIncludes(NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+}
+
+/**
+ * Determine if identifier descriptor is a GTIN descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a GTIN descriptor.
+ */
+export function isGTINDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is GTINDescriptor {
+    return identifierDescriptor.identifierType === IdentifierTypes.GTIN;
+}
+
+/**
+ * Determine if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-GTIN numeric identifier descriptor.
+ */
+export function isNonGTINNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonGTINNumericIdentifierDescriptor {
+    return isNumericIdentifierDescriptor(identifierDescriptor) && !isGTINDescriptor(identifierDescriptor);
+}
+
+const SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES: readonly SerializableNumericIdentifierType[] = [IdentifierTypes.GRAI, IdentifierTypes.GDTI, IdentifierTypes.GCN];
+
+/**
+ * Determine if identifier descriptor is a serializable numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a serializable numeric identifier descriptor.
+ */
+export function isSerializableNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is SerializableNumericIdentifierDescriptor {
+    return identifierTypesIncludes(SERIALIZABLE_NUMERIC_IDENTIFIER_TYPES, identifierDescriptor.identifierType);
+}
+
+/**
+ * Determine if identifier descriptor is a non-numeric identifier descriptor.
+ *
+ * @param identifierDescriptor
+ * Identifier descriptor.
+ *
+ * @returns
+ * True if identifier descriptor is a non-numeric identifier descriptor.
+ */
+export function isNonNumericIdentifierDescriptor(identifierDescriptor: IdentifierDescriptor): identifierDescriptor is NonNumericIdentifierDescriptor {
+    return !isNumericIdentifierDescriptor(identifierDescriptor);
+}

package/src/gtin-creator.ts

@@ -6,10 +6,11 @@ import {
     type TransformerOutput
 } from "@aidc-toolkit/utility";
 import { Mixin } from "ts-mixer";
-import { checkDigit, priceOrWeightCheckDigit } from "./check.js";
-import { type GTINType, GTINTypes, GTINValidator } from "./gtin-validator.js";
-import { i18nextGS1 } from "./locale/i18n.js";
-import { AbstractNumericIdentifierCreator } from "./numeric-identifier-creator.js";
+import { AbstractNumericIdentifierCreator } from "./abstract-numeric-identifier-creator";
+import { checkDigit, priceOrWeightCheckDigit } from "./check";
+import { type GTINBaseType, GTINTypes } from "./gtin-type";
+import { GTINValidator } from "./gtin-validator";
+import { i18nextGS1 } from "./locale/i18n";
 import type { PrefixProvider } from "./prefix-provider";
 
 /**
@@ -32,11 +33,11 @@ export class GTINCreator extends Mixin(GTINValidator, AbstractNumericIdentifierC
      * @param prefixProvider
      * Prefix provider.
      *
-     * @param gtinType
-     * GTIN type.
+     * @param gtinBaseType
+     * GTIN base type (all except GTIN-14).
      */
-    constructor(prefixProvider: PrefixProvider, gtinType: GTINType) {
-        super(gtinType);
+    constructor(prefixProvider: PrefixProvider, gtinBaseType: GTINBaseType) {
+        super(gtinBaseType);
 
         this.init(prefixProvider, prefixProvider.prefix);
     }

package/src/gtin-descriptor.ts

@@ -0,0 +1,18 @@
+import type { IdentifierTypes } from "./identifier-type";
+import type { NumericIdentifierDescriptor } from "./numeric-identifier-descriptor";
+import type { LeaderTypes } from "./numeric-identifier-type";
+
+/**
+ * GTIN descriptor.
+ */
+export interface GTINDescriptor extends NumericIdentifierDescriptor {
+    /**
+     * @inheritDoc
+     */
+    readonly identifierType: typeof IdentifierTypes.GTIN;
+
+    /**
+     * @inheritDoc
+     */
+    readonly leaderType: typeof LeaderTypes.IndicatorDigit;
+}

package/src/gtin-type.ts

@@ -0,0 +1,50 @@
+import { type PrefixType, PrefixTypes } from "./prefix-type";
+
+/**
+ * GTIN types. The numeric values are equal to the lengths of the GTIN types.
+ */
+export const GTINTypes = {
+    /**
+     * GTIN-13.
+     */
+    GTIN13: 13,
+
+    /**
+     * GTIN-12.
+     */
+    GTIN12: 12,
+
+    /**
+     * GTIN-8.
+     */
+    GTIN8: 8,
+
+    /**
+     * GTIN-14.
+     */
+    GTIN14: 14
+} as const;
+
+/**
+ * GTIN type key.
+ */
+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.
+ */
+export const GTIN_BASE_TYPES: Readonly<Record<PrefixType, GTINBaseType>> = {
+    [PrefixTypes.GS1CompanyPrefix]: GTINTypes.GTIN13,
+    [PrefixTypes.UPCCompanyPrefix]: GTINTypes.GTIN12,
+    [PrefixTypes.GS18Prefix]: GTINTypes.GTIN8
+};