@aidc-toolkit/app-extension 1.0.47-beta → 1.0.49-beta

package/src/generator/functions-generator.ts

@@ -0,0 +1,292 @@
+import {
+    type ClassDescriptor,
+    type MethodDescriptor,
+    type ParameterDescriptor,
+    type Type,
+    Types
+} from "../descriptor.js";
+import { type FunctionLocalization, Generator, type Localization } from "./generator.js";
+
+/**
+ * Class type alias.
+ */
+export interface ClassTypeAlias {
+    /**
+     * Name.
+     */
+    readonly name: string;
+
+    /**
+     * Getter function.
+     */
+    readonly getter: string;
+
+    /**
+     * Declaration associating name with implementation type and creating getter function.
+     */
+    readonly declaration: string[];
+}
+
+/**
+ * Function implementation.
+ */
+export interface FunctionImplementation {
+    /**
+     * Function name.
+     */
+    readonly functionName: string;
+
+    /**
+     * Parameter localizations with JavaScript type and parameter descriptor.
+     */
+    readonly parameterLocalizations: ReadonlyArray<Localization & {
+        /**
+         * JavaScript type.
+         */
+        javaScriptType: string;
+
+        /**
+         * Parameter descriptor.
+         */
+        parameterDescriptor?: ParameterDescriptor;
+    }>;
+
+    /**
+     * Declaration.
+     */
+    readonly declaration: string[];
+}
+
+/**
+ * Generator with helpers for writing TypeScript functions file.
+ */
+export abstract class FunctionsGenerator extends Generator {
+    /**
+     * Mapping of descriptor types to JavaScript types.
+     */
+    static readonly #DESCRIPTOR_TYPE_STRINGS: Readonly<Record<Type, string>> = {
+        [Types.String]: "string",
+        [Types.Number]: "number",
+        [Types.Boolean]: "boolean",
+        [Types.Any]: "any"
+    };
+
+    protected static readonly BASE_IMPORTS = [
+        "import * as AppExtension from \"@aidc-toolkit/app-extension\";",
+        "import { appExtension } from \"./app-extension.js\";"
+    ];
+
+    /**
+     * If true, functions are declared inline rather than using `function`.
+     */
+    readonly #inline: boolean;
+
+    /**
+     * If true, application extension supports context.
+     */
+    readonly #supportsContext: boolean;
+
+    /**
+     * Invocation context type name.
+     */
+    readonly #invocationContextTypeName: string;
+
+    /**
+     * Streaming invocation context type name.
+     */
+    readonly #streamingInvocationContextTypeName: string;
+
+    /**
+     * Template declaration for type alias.
+     */
+    readonly #templateDeclaration: string;
+
+    /**
+     * Current class type alias.
+     */
+    #classTypeAlias!: ClassTypeAlias;
+
+    /**
+     * Constructor.
+     *
+     * @param version
+     * Package version.
+     *
+     * @param inline
+     * If true, functions are declared inline rather than using `function`.
+     *
+     * @param throwError
+     * If true, errors are reported through the throw/catch mechanism.
+     *
+     * @param errorTypeName
+     * Error type name.
+     *
+     * @param supportsContext
+     * If true, application extension supports context.
+     *
+     * Big integer type name.
+     * @param invocationContextTypeName
+     * Invocation context type name.
+     *
+     * @param streamingInvocationContextTypeName
+     * Streaming invocation context type name.
+     *
+     * @param bigIntTypeName
+     * Big integer type name.
+     */
+    constructor(version: string, inline: boolean, throwError: boolean, errorTypeName: string, supportsContext: boolean, invocationContextTypeName: string, streamingInvocationContextTypeName: string, bigIntTypeName: string) {
+        super(version, true);
+
+        this.#inline = inline;
+
+        this.#supportsContext = supportsContext;
+        this.#invocationContextTypeName = invocationContextTypeName;
+        this.#streamingInvocationContextTypeName = streamingInvocationContextTypeName;
+
+        this.#templateDeclaration = `<${throwError}, ${errorTypeName}, ${invocationContextTypeName}, ${streamingInvocationContextTypeName}, ${bigIntTypeName}>`;
+    }
+
+    /**
+     * Get the class type alias.
+     */
+    get classTypeAlias(): ClassTypeAlias {
+        return this.#classTypeAlias;
+    }
+
+    /**
+     * Get the import statement for a namespace.
+     *
+     * @param namespace
+     * Namespace.
+     *
+     * @returns
+     * Import statement.
+     */
+    protected getNamespaceImport(namespace: string): string {
+        return `import * as AppExtension${namespace} from "@aidc-toolkit/app-extension/${namespace.toLowerCase()}";`;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected override createClassProxy(classDescriptor: ClassDescriptor): void {
+        const classDescriptorNamespace = classDescriptor.namespace ?? "";
+        const name = `${classDescriptorNamespace}${classDescriptor.name}`;
+        const getter = `get${name}()`;
+        const implementation = `AppExtension${classDescriptorNamespace}.${classDescriptor.name}${this.#templateDeclaration}`;
+
+        this.#classTypeAlias = {
+            name,
+            getter,
+            declaration: [
+                "",
+                "/**",
+                " * Class type alias name.",
+                " */",
+                `type ${name} = ${implementation};`,
+                "",
+                "/**",
+                " * Getter function to get an instance of the class.",
+                " *",
+                " * @returns",
+                " * Class instance.",
+                " */",
+                `function ${getter}: ${name} {`,
+                `    return appExtension.getProxy(${implementation});`,
+                "}"
+            ]
+        };
+    }
+
+    /**
+     * Get a function implementation.
+     *
+     * @param methodDescriptor
+     * Method descriptor.
+     *
+     * @param functionNamePrefix
+     * Function name prefix.
+     *
+     * @param functionLocalization
+     * Function localization. May be undefined for hidden functions, in which case generated
+     *
+     * @param parameterCallback
+     * Callback to modify parameter in implementation function call.
+     *
+     * @returns
+     * Function implementation.
+     */
+    protected getFunctionImplementation(methodDescriptor: MethodDescriptor, functionNamePrefix: string, functionLocalization: FunctionLocalization | undefined, parameterCallback?: (name: string, parameterDescriptor: ParameterDescriptor) => string): FunctionImplementation {
+        const methodType = `${this.classTypeAlias.name}["${methodDescriptor.name}"]`;
+
+        const parameterDescriptors = methodDescriptor.parameterDescriptors;
+
+        const parameterLocalizations: Array<FunctionImplementation["parameterLocalizations"][number]> = parameterDescriptors.map((parameterDescriptor) => {
+            const parameterLocalization = functionLocalization?.parametersMap.get(parameterDescriptor.name) ?? {
+                name: parameterDescriptor.name,
+                description: "*** NO LOCALIZATION ***"
+            };
+
+            return {
+                ...parameterLocalization,
+                javaScriptType: FunctionsGenerator.#DESCRIPTOR_TYPE_STRINGS[parameterDescriptor.type],
+                parameterDescriptor
+            };
+        });
+
+        const dummyParameters: string[] = [];
+
+        if (this.#supportsContext) {
+            if (methodDescriptor.requiresContext === true) {
+                parameterLocalizations.push({
+                    name: "invocationContext",
+                    description: "Invocation context.",
+                    javaScriptType: this.#invocationContextTypeName
+                });
+            }
+
+            if (methodDescriptor.isStream === true) {
+                parameterLocalizations.push({
+                    name: "streamingInvocationContext",
+                    description: "Streaming invocation context.",
+                    javaScriptType: this.#streamingInvocationContextTypeName
+                });
+            }
+        } else {
+            if (methodDescriptor.requiresContext === true) {
+                // Invocation context type name represents a literal dummy value.
+                dummyParameters.push(this.#invocationContextTypeName);
+            }
+
+            if (methodDescriptor.isStream === true) {
+                // Streaming invocation context type name represents a literal dummy value.
+                dummyParameters.push(this.#streamingInvocationContextTypeName);
+            }
+        }
+
+        const asyncQualifier = methodDescriptor.isAsync === true ? "async " : "";
+        const functionName = functionNamePrefix === "" ?
+            functionLocalization?.name ?? methodDescriptor.name :
+            `${functionNamePrefix}${functionLocalization?.titleCaseName ?? methodDescriptor.name.replace(/^[a-z]/u, c => c.toUpperCase())}`;
+
+        return {
+            functionName,
+            parameterLocalizations,
+            declaration: [
+                `${
+                    !this.#inline ?
+                        `export ${asyncQualifier}function ${functionName}` :
+                        asyncQualifier
+                }(${parameterLocalizations.map((parameterLocalization, index) =>
+                    `${parameterLocalization.name}: Parameters<${methodType}>[${index}]`
+                ).join(", ")}): ReturnType<${methodType}> ${!this.#inline ? "{" : "=>"}`,
+                `    ${!this.#inline ? "return " : ""}${(this.classTypeAlias.getter)}.${methodDescriptor.name}(${[...parameterLocalizations.map(parameterLocalization =>
+                    parameterCallback === undefined || parameterLocalization.parameterDescriptor === undefined ?
+                        parameterLocalization.name :
+                        parameterCallback(parameterLocalization.name, parameterLocalization.parameterDescriptor)
+                ), ...dummyParameters].join(", ")})${(!this.#inline ? ";" : "")}`,
+                ...!this.#inline ? ["}"] : []
+            ]
+        };
+    }
+}

package/src/generator/generator.ts

@@ -1,4 +1,4 @@
-import { ALPHA_URL, getLogger, I18nEnvironments, type Promisable, websiteURL } from "@aidc-toolkit/core";
+import { ALPHA_URL, getLogger, I18nLanguageDetectors, type Promisable, websiteURL } from "@aidc-toolkit/core";
 import type { DefaultNamespace, ParseKeys } from "i18next";
 import type { Logger } from "tslog";
 import { AppHelperProxy } from "../app-helper-proxy.js";
@@ -39,9 +39,9 @@ export interface Localization {
  */
 export interface FunctionLocalization extends Localization {
     /**
-     * Namespace function name.
+     * Name in title case.
      */
-    readonly namespaceFunctionName: string;
+    readonly titleCaseName: string;
 
     /**
      * Documentation URL.
@@ -155,18 +155,15 @@ export abstract class Generator {
     protected abstract createCategory(namespace: string | undefined, category: string, categoryLocalizationsMap: ReadonlyMap<string, string>): void;
 
     /**
-     * Create a proxy object for a class.
-     *
-     * @param objectName
-     * Object name, derived from namespace and class name.
+     * Create a proxy for a class.
      *
      * @param classDescriptor
      * Class descriptor.
      */
-    protected abstract createProxyObject(objectName: string, classDescriptor: ClassDescriptor): void;
+    protected abstract createClassProxy(classDescriptor: ClassDescriptor): void;
 
     /**
-     * Create a proxy function for a class and method.
+     * Create a proxy for a method.
      *
      * @param classDescriptor
      * Class descriptor.
@@ -177,7 +174,7 @@ export abstract class Generator {
      * @param functionLocalizationsMap
      * Function localizations map.
      */
-    protected abstract createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
+    protected abstract createMethodProxy(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor, functionLocalizationsMap: ReadonlyMap<string, FunctionLocalization>): void;
 
     /**
      * Finalize the generation of the output.
@@ -205,14 +202,21 @@ export abstract class Generator {
      * @returns
      * Localization.
      */
-    static #generateLocalization<TLocalization extends Localization>(locale: string, key: string, localizationCallback: (locale: string, localization: Localization) => TLocalization): TLocalization {
+    static #generateLocalization<TLocalization extends Localization>(locale: string, key: string, localizationCallback: (locale: string, localization: Localization & Partial<TLocalization>) => TLocalization): TLocalization {
         const lngReturnObjectsOption = {
             lng: locale,
             returnObjects: true
         } as const;
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists and return type is Localization.
-        return localizationCallback(locale, i18nextAppExtension.t(key as ParseKeys<DefaultNamespace, typeof lngReturnObjectsOption>, lngReturnObjectsOption) as Localization);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Assume localized key exists.
+        const parseKey = key as ParseKeys<DefaultNamespace, typeof lngReturnObjectsOption>;
+
+        if (!i18nextAppExtension.exists(parseKey, lngReturnObjectsOption)) {
+            throw new Error(`Missing localization for ${key} in ${locale}`);
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists and return type is Localization & Partial<TLocalization>.
+        return localizationCallback(locale, i18nextAppExtension.t(key as ParseKeys<DefaultNamespace, typeof lngReturnObjectsOption>, lngReturnObjectsOption) as Localization & Partial<TLocalization>);
     }
 
     /**
@@ -221,7 +225,7 @@ export abstract class Generator {
     async generate(): Promise<void> {
         let success = false;
 
-        await i18nAppExtensionInit(I18nEnvironments.CLI);
+        await i18nAppExtensionInit(I18nLanguageDetectors.CLI);
 
         const documentationBaseURL = websiteURL(this.version, true, await ALPHA_URL);
 
@@ -278,7 +282,7 @@ export abstract class Generator {
                     const namespaceClassNamesSet = new Set<string>();
 
                     for (const classDescriptor of classDescriptors) {
-                        const namespaceClassName = classDescriptor.namespaceClassName;
+                        const namespaceClassName = `${namespacePrefix}${classDescriptor.name}`;
 
                         if (namespaceClassNamesSet.has(namespaceClassName)) {
                             throw new Error(`Duplicate class ${namespaceClassName}`);
@@ -286,39 +290,26 @@ export abstract class Generator {
 
                         namespaceClassNamesSet.add(namespaceClassName);
 
-                        // First capture group is:
-                        // - one or more uppercase letters followed by zero or more numbers; or
-                        // - single uppercase letter followed by zero or more characters except uppercase letters or period.
-                        //
-                        // Second capture group is:
-                        // - single uppercase letter followed by zero or more characters except period; or
-                        // - zero characters (empty string).
-                        //
-                        // Third capture group, separated by optional period, is:
-                        // - single uppercase letter followed by zero or more characters (remainder of string); or
-                        // - zero characters (empty string).
-                        const objectNameGroups = /^(?<namespaceFirstWord>[A-Z]+[0-9]*|[A-Z][^A-Z.]*)(?<namespaceRemaining>[A-Z][^.]*|)\.?(?<className>[A-Z].*|)$/u.exec(namespaceClassName)?.groups;
-
-                        if (objectNameGroups === undefined) {
-                            throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
-                        }
-
-                        this.createProxyObject(`${objectNameGroups["namespaceFirstWord"].toLowerCase()}${objectNameGroups["namespaceRemaining"]}${objectNameGroups["className"]}`, classDescriptor);
+                        this.createClassProxy(classDescriptor);
 
                         for (const methodDescriptor of classDescriptor.methodDescriptors) {
-                            const functionLocalizationsMap = new Map(this.locales.map(locale =>
-                                [locale, Generator.#generateLocalization<FunctionLocalization>(locale, `Functions.${methodDescriptor.namespaceFunctionName}`, (locale, localization) => ({
-                                    ...localization,
-                                    namespaceFunctionName: `${namespacePrefix}${localization.name}`,
-                                    documentationURL: `${documentationBaseURL}/${locale === this.defaultLocale ? "" : `${locale}/`}${Generator.#DOCUMENTATION_PATH}${namespacePath}${localization.name}.html`,
-                                    parametersMap: new Map(methodDescriptor.parameterDescriptors.map(parameterDescriptor =>
-                                        // eslint-disable-next-line max-nested-callbacks -- Callback is empty.
-                                        [parameterDescriptor.name, Generator.#generateLocalization(locale, `Parameters.${parameterDescriptor.name}`, (_locale, localization) => localization)]
-                                    ))
-                                }))]
-                            ));
-
-                            this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
+                            const functionLocalizationsMap = new Map(methodDescriptor.isHidden !== true ?
+                                this.locales.map(locale =>
+                                    [locale, Generator.#generateLocalization<FunctionLocalization>(locale, `Functions.${namespacePrefix}${methodDescriptor.functionName}`, (locale, localization) => ({
+                                        ...localization,
+                                        titleCaseName: localization.titleCaseName ?? localization.name.replace(/^[a-z]/u, c => c.toUpperCase()),
+                                        documentationURL: `${documentationBaseURL}/${locale === this.defaultLocale ? "" : `${locale}/`}${Generator.#DOCUMENTATION_PATH}${namespacePath}${localization.name}.html`,
+                                        parametersMap: new Map(methodDescriptor.parameterDescriptors.map(parameterDescriptor =>
+                                            // eslint-disable-next-line max-nested-callbacks -- Callback is empty.
+                                            [parameterDescriptor.name, Generator.#generateLocalization(locale, `Parameters.${parameterDescriptor.name}`, (_locale, localization) => localization)]
+                                        ))
+                                    }))]
+                                ) :
+                                // Hidden methods are not localized.
+                                []
+                            );
+
+                            this.createMethodProxy(classDescriptor, methodDescriptor, functionLocalizationsMap);
                         }
                     }
                 }

package/src/generator/index.ts

@@ -16,3 +16,4 @@
  */
 
 export * from "./generator.js";
+export * from "./functions-generator.js";

package/src/generator/locale-resources-generator.ts

@@ -1,13 +1,13 @@
 import type { LocaleResources } from "@aidc-toolkit/core";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import packageConfiguration from "../../package.json" with { type: "json" };
 import type {
     ClassDescriptor,
     ExtendsParameterDescriptor,
     MethodDescriptor,
     ParameterDescriptor
 } from "../descriptor.js";
+import { VERSION } from "../version.js";
 import { Generator } from "./generator.js";
 
 /**
@@ -91,7 +91,7 @@ class LocaleResourcesGenerator extends Generator {
      * Constructor.
      */
     constructor() {
-        super(packageConfiguration.version, false);
+        super(VERSION, false);
     }
 
     /**
@@ -115,7 +115,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected override createProxyObject(): void {
+    protected override createClassProxy(): void {
     }
 
     /**
@@ -193,7 +193,7 @@ class LocaleResourcesGenerator extends Generator {
     /**
      * @inheritDoc
      */
-    protected override createProxyFunction(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
+    protected override createMethodProxy(classDescriptor: ClassDescriptor, methodDescriptor: MethodDescriptor): void {
         // Hidden functions aren't localized.
         if (methodDescriptor.isHidden !== true) {
             // Add any parameters that are not already known.
@@ -255,15 +255,17 @@ class LocaleResourcesGenerator extends Generator {
      * Merged locale resources.
      */
     #merge(logChanges: boolean, parentKey: string, sourceLocaleResources: LocaleResources, destinationLocaleResources: LocaleResources, addMissing: boolean): LocaleResources {
-        // Some entries at the top are not part of the generator output.
-        const deleteMissing = parentKey.length !== 0;
+        // Some entries at the root are not part of the generator output.
+        const atRoot = parentKey === "";
+
+        const atFunction = parentKey.startsWith("Functions.");
 
         const newDestinationLocaleResources: LocaleResources = {};
 
         // Copy over or delete any destination keys that are not in source.
         for (const [key, destinationValue] of Object.entries(destinationLocaleResources)) {
             if (!(key in sourceLocaleResources)) {
-                if (!deleteMissing) {
+                if (atRoot || (atFunction && key === "titleCaseName")) {
                     newDestinationLocaleResources[key] = destinationValue;
                 } else if (logChanges) {
                     this.logger.info(`Deleting ${parentKey}${key}...`);

package/src/gs1/check-proxy.ts

@@ -67,7 +67,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [numericSWithCheckDigitParameterDescriptor]
     })
@@ -85,7 +85,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Singleton,
         parameterDescriptors: [{
             ...numericSFourOrFiveDigitsParameterDescriptor,
@@ -106,7 +106,7 @@ export class CheckProxy<ThrowError extends boolean, TError extends ErrorExtends<
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [ai82SWithCheckCharacterPairParameterDescriptor]
     })

package/src/gs1/gcp-length-proxy.ts

@@ -126,7 +126,6 @@ export class GCPLengthProxy<ThrowError extends boolean, TError extends ErrorExte
         type: Types.Number,
         multiplicity: Multiplicities.Matrix,
         isAsync: true,
-        titleCaseStart: 3,
         parameterDescriptors: [identifierTypeParameterDescriptor, gcpLengthIdentifierParameterDescriptor]
     })
     async gcpLengthOf(identifierType: string, matrixIdentifiers: Matrix<string>): Promise<MatrixResult<number, ThrowError, TError>> {
@@ -141,7 +140,6 @@ export class GCPLengthProxy<ThrowError extends boolean, TError extends ErrorExte
         type: Types.String,
         multiplicity: Multiplicities.Singleton,
         isAsync: true,
-        titleCaseStart: 3,
         parameterDescriptors: []
     })
     async gcpLengthDateTime(): Promise<SingletonResult<string, ThrowError, TError>> {
@@ -154,7 +152,6 @@ export class GCPLengthProxy<ThrowError extends boolean, TError extends ErrorExte
         type: Types.String,
         multiplicity: Multiplicities.Singleton,
         isAsync: true,
-        titleCaseStart: 3,
         parameterDescriptors: []
     })
     async gcpLengthDisclaimer(): Promise<SingletonResult<string, ThrowError, TError>> {

package/src/gs1/gtin-validator-proxy.ts

@@ -128,7 +128,7 @@ export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
     })
@@ -148,7 +148,7 @@ export class GTINValidatorStaticProxy<ThrowError extends boolean, TError extends
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateGTIN14ParameterDescriptor]
     })

package/src/gs1/identifier-validator-proxy.ts

@@ -61,7 +61,7 @@ abstract class NumericIdentifierValidatorProxy<ThrowError extends boolean, TErro
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateIdentifierParameterDescriptor]
     })
@@ -109,7 +109,7 @@ export abstract class NonNumericIdentifierValidatorProxy<ThrowError extends bool
     }
 
     @proxy.describeMethod({
-        type: Types.String,
+        type: Types.Boolean,
         multiplicity: Multiplicities.Matrix,
         parameterDescriptors: [validateIdentifierParameterDescriptor, exclusionAllNumericParameterDescriptor]
     })

package/src/locale/en/locale-resources.ts

@@ -735,14 +735,17 @@ export default {
             },
             gcpLengthOf: {
                 name: "gcpLengthOf",
+                titleCaseName: "GCPLengthOf",
                 description: "Get the length of a GS1 Company Prefix for an identifier."
             },
             gcpLengthDateTime: {
                 name: "gcpLengthDateTime",
+                titleCaseName: "GCPLengthDateTime",
                 description: "Get the date and time the GS1 Company Prefix length data was last updated."
             },
             gcpLengthDisclaimer: {
                 name: "gcpLengthDisclaimer",
+                titleCaseName: "GCPLengthDisclaimer",
                 description: "Get the disclaimer for the GS1 Company Prefix length data."
             }
         }

package/src/locale/fr/locale-resources.ts

@@ -27,7 +27,7 @@ export default {
         tweakFactorMustBeNumber: "Le facteur de réglage doit être un nombre"
     },
     ServiceProxy: {
-        invalidIdentifierType: "Type d'identifiant invalide «{{identifierType}}»"
+        invalidIdentifierType: "Type d'identifiant invalide « {{identifierType}} »"
     },
     Parameters: {
         spillArray: {
@@ -731,18 +731,21 @@ export default {
             },
             verifiedByGS1: {
                 name: "verifiedByGS1",
-                description: "Créer un lien hypertexte «Vérifié par GS1»."
+                description: "Créer un lien hypertexte « Verified by GS1 »."
             },
             gcpLengthOf: {
                 name: "longueurGCPDe",
+                titleCaseName: undefined,
                 description: "Obtenez la longueur du préfixe d'entreprise GS1 pour un identifiant."
             },
             gcpLengthDateTime: {
                 name: "dateHeureLongueurGCP",
+                titleCaseName: undefined,
                 description: "Obtenez la date et l'heure de la dernière mise à jour des données relatives à la longueur du préfixe d'entreprise GS1."
             },
             gcpLengthDisclaimer: {
                 name: "avertissementLongueurGCP",
+                titleCaseName: undefined,
                 description: "Obtenez l'avertissement relatif aux données sur la longueur des préfixes d'entreprise GS1."
             }
         }