@aidc-toolkit/app-extension 1.0.26-beta → 1.0.28-beta

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

@@ -0,0 +1,87 @@
+import type { Nullishable } from "@aidc-toolkit/core";
+import type {
+    GTINType,
+    IdentifierType,
+    IdentifierTypeValidator,
+    NonGTINNumericIdentifierType,
+    NonNumericIdentifierType,
+    NonNumericIdentifierValidation,
+    NonSerializableNumericIdentifierType,
+    NumericIdentifierType,
+    SerializableNumericIdentifierType
+} from "@aidc-toolkit/gs1";
+import type { AppExtension } from "../app-extension.js";
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import { exclusionAllNumericParameterDescriptor } from "../utility/character-set-descriptor.js";
+import { StringProxy } from "../utility/string-proxy.js";
+
+export const identifierParameterDescriptor: ParameterDescriptor = {
+    name: "identifier",
+    type: Types.String,
+    isMatrix: true,
+    isRequired: true
+};
+
+const validateIdentifierParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: identifierParameterDescriptor,
+    sortOrder: 0,
+    name: "validateIdentifier"
+};
+
+abstract class IdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TIdentifierType extends IdentifierType> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    readonly #validator: IdentifierTypeValidator<TIdentifierType>;
+
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, validator: IdentifierTypeValidator<TIdentifierType>) {
+        super(appExtension);
+
+        this.#validator = validator;
+    }
+
+    protected get validator(): IdentifierTypeValidator<TIdentifierType> {
+        return this.#validator;
+    }
+}
+
+@proxy.describeClass(true, {
+    namespace: "GS1"
+})
+abstract class NumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNumericIdentifierType extends NumericIdentifierType> extends IdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNumericIdentifierType> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [validateIdentifierParameterDescriptor]
+    })
+    validate(matrixIdentifiers: Matrix<string>): MatrixResultError<string, ThrowError, TError> {
+        return this.validateString(this.validator, matrixIdentifiers);
+    }
+}
+
+export abstract class GTINValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, GTINType> {
+}
+
+abstract class NonGTINNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt, TNonGTINNumericIdentifierType extends NonGTINNumericIdentifierType = NonGTINNumericIdentifierType> extends NumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, TNonGTINNumericIdentifierType> {
+}
+
+export abstract class NonSerializableNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonSerializableNumericIdentifierType> {
+}
+
+export abstract class SerializableNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonGTINNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, SerializableNumericIdentifierType> {
+}
+
+@proxy.describeClass(true, {
+    namespace: "GS1"
+})
+export abstract class NonNumericIdentifierValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends IdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonNumericIdentifierType> {
+    @proxy.describeMethod({
+        type: Types.String,
+        isMatrix: true,
+        parameterDescriptors: [validateIdentifierParameterDescriptor, exclusionAllNumericParameterDescriptor]
+    })
+    validate(matrixIdentifiers: Matrix<string>, exclusion: Nullishable<NonNumericIdentifierValidation["exclusion"]>): MatrixResultError<string, ThrowError, TError> {
+        return this.validateString(this.validator, matrixIdentifiers, {
+            exclusion: exclusion ?? undefined
+        } satisfies NonNumericIdentifierValidation);
+    }
+}

package/src/gs1/index.ts

@@ -1,3 +1,7 @@
 export * from "./character-set-proxy.js";
 export * from "./check-proxy.js";
-export * from "./identifier-proxy.js";
+export * from "./gtin-validator-proxy.js";
+export * from "./non-gtin-validator-proxy.js";
+export * from "./prefix-manager-proxy.js";
+export * from "./gtin-creator-proxy.js";
+export * from "./non-gtin-creator-proxy.js";

package/src/gs1/non-gtin-creator-proxy.ts

@@ -0,0 +1,119 @@
+import type { NonGTINNumericIdentifierCreator, NonSerializableNumericIdentifierType } from "@aidc-toolkit/gs1";
+import type { AppExtension } from "../app-extension.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends } from "../type.js";
+import {
+    NonNumericIdentifierCreatorProxy,
+    NonSerializableNumericIdentifierCreatorProxy,
+    SerializableNumericIdentifierCreatorProxy
+} from "./identifier-creator-proxy.js";
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GLN"
+})
+export class GLNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonSerializableNumericIdentifierType, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.glnCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "SSCC"
+})
+export class SSCCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonSerializableNumericIdentifierType, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.ssccCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GRAI"
+})
+export class GRAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.graiCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GIAI"
+})
+export class GIAICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.giaiCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GSRN"
+})
+export class GSRNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonSerializableNumericIdentifierType, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gsrnCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GDTI"
+})
+export class GDTICreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gdtiCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GINC"
+})
+export class GINCCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gincCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GSIN"
+})
+export class GSINCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt, NonSerializableNumericIdentifierType, NonGTINNumericIdentifierCreator> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gsinCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GCN"
+})
+export class GCNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gcnCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "CPID"
+})
+export class CPIDCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.cpidCreator);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GMN"
+})
+export class GMNCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, prefixManager => prefixManager.gmnCreator);
+    }
+}

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

@@ -0,0 +1,119 @@
+import { IdentifierValidators } from "@aidc-toolkit/gs1";
+import type { AppExtension } from "../app-extension.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends } from "../type.js";
+import {
+    NonNumericIdentifierValidatorProxy,
+    NonSerializableNumericIdentifierValidatorProxy,
+    SerializableNumericIdentifierValidatorProxy
+} from "./identifier-validator-proxy.js";
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GLN"
+})
+export class GLNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GLN);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "SSCC"
+})
+export class SSCCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.SSCC);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GRAI"
+})
+export class GRAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GRAI);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GIAI"
+})
+export class GIAIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GIAI);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GSRN"
+})
+export class GSRNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GSRN);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GDTI"
+})
+export class GDTIValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GDTI);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GINC"
+})
+export class GINCValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GINC);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GSIN"
+})
+export class GSINValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonSerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GSIN);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GCN"
+})
+export class GCNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends SerializableNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GCN);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "CPID"
+})
+export class CPIDValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.CPID);
+    }
+}
+
+@proxy.describeClass(false, {
+    namespace: "GS1",
+    methodInfix: "GMN"
+})
+export class GMNValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends NonNumericIdentifierValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+        super(appExtension, IdentifierValidators.GMN);
+    }
+}

package/src/gs1/prefix-definition-descriptor.ts

@@ -0,0 +1,18 @@
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+
+const prefixDefinitionParameterDescriptor: ParameterDescriptor = {
+    name: "prefixDefinition",
+    type: Types.Any,
+    isMatrix: true,
+    isRequired: true
+};
+
+export const prefixDefinitionGS1UPCParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: prefixDefinitionParameterDescriptor,
+    name: "prefixDefinitionGS1UPC"
+};
+
+export const prefixDefinitionAnyParameterDescriptor: ExtendsParameterDescriptor = {
+    extendsDescriptor: prefixDefinitionParameterDescriptor,
+    name: "prefixDefinitionAny"
+};

package/src/gs1/prefix-manager-proxy.ts

@@ -0,0 +1,42 @@
+import type { Nullishable } from "@aidc-toolkit/core";
+import type { PrefixType } from "@aidc-toolkit/gs1";
+import { type ParameterDescriptor, Types } from "../descriptor.js";
+import { LibProxy } from "../lib-proxy.js";
+import { proxy } from "../proxy.js";
+import type { ErrorExtends, Matrix } from "../type.js";
+
+const prefixParameterDescriptor: ParameterDescriptor = {
+    name: "prefix",
+    type: Types.String,
+    isMatrix: false,
+    isRequired: true
+};
+
+const prefixTypeParameterDescriptor: ParameterDescriptor = {
+    name: "prefixType",
+    type: Types.Number,
+    isMatrix: false,
+    isRequired: false
+};
+
+const tweakFactorParameterDescriptor: ParameterDescriptor = {
+    name: "tweakFactor",
+    type: Types.Number,
+    isMatrix: false,
+    isRequired: false
+};
+
+@proxy.describeClass(false, {
+    namespace: "GS1"
+})
+export class PrefixManagerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+    @proxy.describeMethod({
+        type: Types.Any,
+        isMatrix: true,
+        parameterDescriptors: [prefixParameterDescriptor, prefixTypeParameterDescriptor, tweakFactorParameterDescriptor]
+    })
+    definePrefix(prefix: string, prefixType: Nullishable<PrefixType>, tweakFactor: Nullishable<number>): Matrix<unknown> {
+        // Parameters will be validated by IdentifierCreatorProxy.getCreator().
+        return [[prefix, prefixType, tweakFactor]];
+    }
+}

package/src/index.ts

@@ -23,3 +23,4 @@ export * from "./app-utility-proxy.js";
 export * from "./utility/index.js";
 export * as GS1 from "./gs1/index.js";
 export * from "./generator/index.js";
+export { expandParameterDescriptor } from "./proxy.js";

package/src/lib-proxy.ts

@@ -6,20 +6,23 @@ import type { ErrorExtends, Matrix, MatrixResultError, ResultError } from "./typ
 /**
  * Library proxy.
  *
- * @template TBigInt
- * Type to which big integer is mapped.
- *
  * @template ThrowError
  * If true, errors are reported through the throw/catch mechanism.
  *
  * @template TError
  * Error type.
+ *
+ * @template TInvocationContext
+ * Application-specific invocation context type.
+ *
+ * @template TBigInt
+ * Type to which big integer is mapped.
  */
 export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> {
     /**
      * Application extension.
      */
-    private readonly _appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>;
+    readonly #appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>;
 
     /**
      * Constructor.
@@ -28,14 +31,14 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * Application extension.
      */
     constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
-        this._appExtension = appExtension;
+        this.#appExtension = appExtension;
     }
 
     /**
      * Get the application extension.
      */
-    protected get appExtension(): AppExtension<ThrowError, TError, TInvocationContext, TBigInt> {
-        return this._appExtension;
+    get appExtension(): AppExtension<ThrowError, TError, TInvocationContext, TBigInt> {
+        return this.#appExtension;
     }
 
     /**
@@ -48,7 +51,7 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * Mapped big integer value.
      */
     mapBigInt(value: bigint): ResultError<TBigInt, ThrowError, TError> {
-        return this._appExtension.mapBigInt(value);
+        return this.#appExtension.mapBigInt(value);
     }
 
     /**
@@ -60,13 +63,13 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * @returns
      * Error if errors are not thrown.
      */
-    private handleError<TResult>(e: unknown): ResultError<TResult, ThrowError, TError> {
+    #handleError<TResult>(e: unknown): ResultError<TResult, ThrowError, TError> {
         let result: ResultError<TResult, ThrowError, TError>;
 
         if (e instanceof RangeError) {
-            const error = this._appExtension.mapRangeError(e);
+            const error = this.#appExtension.mapRangeError(e);
 
-            if (this._appExtension.throwError) {
+            if (this.#appExtension.throwError) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type is determined by application mapping.
                 throw error as Error;
             }
@@ -94,13 +97,13 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * @returns
      * Callback result or error if errors are not thrown.
      */
-    private doCallback<TValue, TResult>(value: TValue, callback: (value: TValue) => TResult): ResultError<TResult, ThrowError, TError> {
+    #doCallback<TValue, TResult>(value: TValue, callback: (value: TValue) => TResult): ResultError<TResult, ThrowError, TError> {
         let result: ResultError<TResult, ThrowError, TError>;
 
         try {
             result = callback(value);
         } catch (e: unknown) {
-            result = this.handleError(e);
+            result = this.#handleError(e);
         }
 
         return result;
@@ -119,7 +122,7 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * Matrix of callback results and errors if errors are not thrown.
      */
     protected mapMatrix<TValue, TResult>(matrixValues: Matrix<TValue>, callback: (value: TValue) => TResult): MatrixResultError<TResult, ThrowError, TError> {
-        return matrixValues.map(rowValues => rowValues.map(value => this.doCallback(value, callback)));
+        return matrixValues.map(rowValues => rowValues.map(value => this.#doCallback(value, callback)));
     }
 
     /**
@@ -134,8 +137,8 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
      * @returns
      * Callback result or error as array if errors are not thrown.
      */
-    private doArrayCallback<TValue, TResult>(value: TValue, callback: (value: TValue) => TResult[]): Array<ResultError<TResult, ThrowError, TError>> {
-        const result = this.doCallback(value, callback);
+    #doArrayCallback<TValue, TResult>(value: TValue, callback: (value: TValue) => TResult[]): Array<ResultError<TResult, ThrowError, TError>> {
+        const result = this.#doCallback(value, callback);
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type determination is handled.
         return result instanceof Array ? result : [result as ResultError<TResult, ThrowError, TError>];
@@ -163,7 +166,7 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
             matrixResultError = [];
 
             matrixValues[0].forEach((value, columnIndex) => {
-                const arrayResultError = this.doArrayCallback(value, callback);
+                const arrayResultError = this.#doArrayCallback(value, callback);
 
                 arrayResultError.forEach((resultError, rowIndex) => {
                     if (matrixResultError.length <= rowIndex) {
@@ -182,9 +185,9 @@ export abstract class LibProxy<ThrowError extends boolean, TError extends ErrorE
                     // Special case; unlikely to occur.
                     arrayResultError = [];
                 } else if (rowValue.length === 1) {
-                    arrayResultError = this.doArrayCallback(rowValue[0], callback);
+                    arrayResultError = this.#doArrayCallback(rowValue[0], callback);
                 } else {
-                    arrayResultError = [this.handleError(new RangeError(i18nextAppExtension.t("Proxy.matrixMustBeArray")))];
+                    arrayResultError = [this.#handleError(new RangeError(i18nextAppExtension.t("Proxy.matrixMustBeArray")))];
                 }
 
                 return arrayResultError;