@aidc-toolkit/app-extension 1.0.31-beta → 1.0.33-beta

package/src/app-utility-proxy.ts

@@ -1,273 +0,0 @@
-import { isNullish, type NonNullishable, type Nullishable } from "@aidc-toolkit/core";
-import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "./descriptor.js";
-import { LibProxy } from "./lib-proxy.js";
-import { i18nextAppExtension } from "./locale/i18n.js";
-import { proxy } from "./proxy.js";
-import type { ErrorExtends, Matrix } from "./type.js";
-
-const spillMatrix: ParameterDescriptor = {
-    name: "spillMatrix",
-    type: Types.Any,
-    isMatrix: true,
-    isRequired: true
-};
-
-const spillMaximumParameterDescriptor: ParameterDescriptor = {
-    name: "spillMaximum",
-    type: Types.Number,
-    isMatrix: false,
-    isRequired: false
-};
-
-const spillMaximumWidthParameterDescriptor: ExtendsParameterDescriptor = {
-    extendsDescriptor: spillMaximumParameterDescriptor,
-    sortOrder: 0,
-    name: "spillMaximumWidth"
-};
-
-const spillMaximumHeightParameterDescriptor: ExtendsParameterDescriptor = {
-    extendsDescriptor: spillMaximumParameterDescriptor,
-    sortOrder: 1,
-    name: "spillMaximumHeight"
-};
-
-/**
- * Maximum dimensions.
- */
-interface MaximumDimensions {
-    /**
-     * Optional maximum width.
-     */
-    width: Nullishable<number>;
-
-    /**
-     * Optional maximum height.
-     */
-    height: Nullishable<number>;
-}
-
-/**
- * Application utilities.
- *
- *@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.
- */
-@proxy.describeClass(false)
-export class AppUtilityProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    /**
-     * Get the version.
-     *
-     * @returns
-     * Version.
-     */
-    @proxy.describeMethod({
-        type: Types.String,
-        isMatrix: false,
-        parameterDescriptors: []
-    })
-    version(): string {
-        return this.appExtension.version;
-    }
-
-    /**
-     * Provide default values for maximum width and height if required.
-     *
-     * @param maximumDimensions
-     * Maximum dimensions provided to function.
-     *
-     * @param invocationContext
-     * Invocation context.
-     *
-     * @returns
-     * Array of maximum width and maximum height.
-     */
-    async #defaultMaximums(maximumDimensions: MaximumDimensions, invocationContext: Nullishable<TInvocationContext>): Promise<NonNullishable<MaximumDimensions>> {
-        if (isNullish(invocationContext)) {
-            // Application error; no localization necessary.
-            throw new Error("Invocation context not provided by application");
-        }
-
-        const maximumWidth = maximumDimensions.width;
-        const maximumHeight = maximumDimensions.height;
-
-        let definedMaximumWidth: number;
-        let definedMaximumHeight: number;
-
-        // Skip any extra work if both values are provided.
-        if (isNullish(maximumWidth) || isNullish(maximumHeight)) {
-            const sheetAddress = await this.appExtension.getSheetAddress(invocationContext);
-
-            definedMaximumWidth = maximumWidth ?? await this.appExtension.maximumWidth() - sheetAddress.columnIndex;
-            definedMaximumHeight = maximumHeight ?? await this.appExtension.maximumHeight() - sheetAddress.rowIndex;
-        } else {
-            definedMaximumWidth = maximumWidth;
-            definedMaximumHeight = maximumHeight;
-        }
-
-        return {
-            width: definedMaximumWidth,
-            height: definedMaximumHeight
-        };
-    }
-
-    /**
-     * Spill a horizontal matrix vertically to fit within a maximum width and height.
-     *
-     * @param hMatrixValues
-     * Horizontal matrix values. Matrix has length 1 and contains a single array with the values.
-     *
-     * @param maximumWidth
-     * Maximum width.
-     *
-     * @param maximumHeight
-     * Maximum height.
-     *
-     * @param invocationContext
-     * Invocation context.
-     *
-     * @returns
-     * Matrix spilled within maximum width and maximum height.
-     */
-    @proxy.describeMethod({
-        requiresContext: true,
-        type: Types.Any,
-        isMatrix: true,
-        parameterDescriptors: [spillMatrix, spillMaximumWidthParameterDescriptor, spillMaximumHeightParameterDescriptor]
-    })
-    async vSpill(hMatrixValues: Matrix<unknown>, maximumWidth: Nullishable<number>, maximumHeight: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>> {
-        let result: Matrix<unknown>;
-
-        if (hMatrixValues.length !== 1) {
-            throw new RangeError(i18nextAppExtension.t("Proxy.vSpillMustBeHorizontalArray"));
-        }
-
-        const maximumDimensions = await this.#defaultMaximums({
-            width: maximumWidth,
-            height: maximumHeight
-        }, invocationContext);
-
-        const hArrayValues = hMatrixValues[0];
-        const hLength = hArrayValues.length;
-        const maximumArea = maximumDimensions.width * maximumDimensions.height;
-
-        // Lengths 0 and 1 are valid and require no special processing.
-        if (hLength > 1 && hLength <= maximumArea) {
-            // Make spill as square as possible.
-            let spillWidth = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.width);
-
-            // Array that has a length of a power of 10 is treated specially.
-            if (Number.isInteger(Math.log10(hLength))) {
-                // Try spill width that is a power of 10.
-                const spillWidth10 = 10 ** Math.floor(Math.log10(spillWidth));
-
-                // Keep default if not enough space for power of 10 matrix.
-                if (hLength / spillWidth10 <= maximumDimensions.height) {
-                    spillWidth = spillWidth10;
-                }
-            }
-
-            result = [];
-
-            let hStartIndex = 0;
-
-            do {
-                const hEndIndex = hStartIndex + spillWidth;
-
-                result.push(hArrayValues.slice(hStartIndex, hEndIndex));
-
-                hStartIndex = hEndIndex;
-            } while (hStartIndex < hLength);
-        } else {
-            // Return matrix unmodified and let application handle spill error if any.
-            result = hMatrixValues;
-        }
-
-        return result;
-    }
-
-    /**
-     * Spill a vertical matrix horizontally to fit within a maximum width and height.
-     *
-     * @param vMatrixValues
-     * Vertical matrix values. Matrix contains arrays of length 1 with the values.
-     *
-     * @param maximumHeight
-     * Maximum height.
-     *
-     * @param maximumWidth
-     * Maximum width.
-     *
-     * @param invocationContext
-     * Invocation context.
-     *
-     * @returns
-     * Matrix spilled within maximum height and maximum width.
-     */
-    @proxy.describeMethod({
-        requiresContext: true,
-        type: Types.Any,
-        isMatrix: true,
-        parameterDescriptors: [spillMatrix, spillMaximumHeightParameterDescriptor, spillMaximumWidthParameterDescriptor]
-    })
-    async hSpill(vMatrixValues: Matrix<unknown>, maximumHeight: Nullishable<number>, maximumWidth: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<Matrix<unknown>> {
-        let result: Matrix<unknown>;
-
-        for (const hArrayValues of vMatrixValues) {
-            // This test should be necessary only once but account for zero-size matrix and misuse of method.
-            if (hArrayValues.length !== 1) {
-                throw new RangeError(i18nextAppExtension.t("Proxy.hSpillMustBeVerticalArray"));
-            }
-        }
-
-        const maximumDimensions = await this.#defaultMaximums({
-            width: maximumWidth,
-            height: maximumHeight
-        }, invocationContext);
-
-        const vLength = vMatrixValues.length;
-        const maximumArea = maximumDimensions.width * maximumDimensions.height;
-
-        // Lengths 0 and 1 are valid and require no special processing.
-        if (vLength > 1 && vLength <= maximumArea) {
-            // Make spill as square as possible.
-            let spillHeight = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.height);
-
-            // Array that has a length of a power of 10 is treated specially.
-            if (Number.isInteger(Math.log10(vLength))) {
-                // Try spill height that is a power of 10.
-                const spillHeight10 = 10 ** Math.floor(Math.log10(spillHeight));
-
-                // Keep default if not enough space for power of 10 matrix.
-                if (vLength / spillHeight10 <= maximumDimensions.width) {
-                    spillHeight = spillHeight10;
-                }
-            }
-
-            result = [];
-
-            for (let rowIndex = 0; rowIndex < spillHeight; rowIndex++) {
-                const row = new Array<unknown>();
-
-                for (let cellIndex = rowIndex; cellIndex < vLength; cellIndex++) {
-                    row.push(vMatrixValues[cellIndex][0]);
-                }
-
-                result.push(row);
-            }
-        } else {
-            // Return matrix unmodified and let application handle spill error if any.
-            result = vMatrixValues;
-        }
-
-        return result;
-    }
-}