@adaptabletools/adaptable-cjs 23.0.4-canary.0 → 23.0.5-canary.0

package/src/Utilities/Services/Interface/IMetamodelService.d.ts

@@ -1,20 +0,0 @@
-import { AdaptableOptions } from '../../../../types';
-import { MetamodelItemPropertyKind } from '../../../metamodel/adaptable-metamodel-model';
-import { IAdaptableService } from './IAdaptableService';
-export type GridInfoOptions = Map<string, {
-    containerLabel: string;
-    items: GridInfoOption[];
-}>;
-export interface GridInfoOption {
-    name: string;
-    value: any;
-    description: string;
-    kind: MetamodelItemPropertyKind;
-    defaultValue?: any;
-    uiLabel: string;
-}
-export interface IMetamodelService extends IAdaptableService {
-    getAdaptableOptions: () => AdaptableOptions;
-    getGridInfoNoCodeOptions(): GridInfoOptions;
-    validateAdaptableOptionsValues(): void;
-}

package/src/Utilities/Services/Interface/IMetamodelService.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/Utilities/Services/MetamodelService.d.ts

@@ -1,17 +0,0 @@
-import { GridInfoOptions, IMetamodelService } from './Interface/IMetamodelService';
-import { AdaptableOptions } from '../../../types';
-export declare class MetamodelService implements IMetamodelService {
-    getAdaptableOptions: () => AdaptableOptions;
-    constructor(getAdaptableOptions: () => AdaptableOptions, validateOptions?: boolean);
-    getGridInfoNoCodeOptions(): GridInfoOptions;
-    validateAdaptableOptionsValues(): void;
-    private validateOptionsObject;
-    private getExpectedOptionsValueType;
-    private buildGridInfoOptions;
-    private mapGridInfoContainerItems;
-    private getAdaptableOptionsDefaultValues;
-    private getAdaptableMetamodel;
-    private getAdaptableOptionsMetamodel;
-    private extractUiLabel;
-    private formatCamelCaseToHumanText;
-}

package/src/Utilities/Services/MetamodelService.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetamodelService = void 0;
-const tslib_1 = require("tslib");
-const adaptable_metamodel_1 = require("../../metamodel/adaptable.metamodel");
-const DocumentationLinkConstants_1 = require("../Constants/DocumentationLinkConstants");
-const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
-const AdaptableLogger_1 = require("../../agGrid/AdaptableLogger");
-const DefaultAdaptableOptions_1 = require("../../AdaptableOptions/DefaultAdaptableOptions");
-const supportedMetamodelTypes = ['s', 'n', 'b', 'a', 'f', 'R'];
-class MetamodelService {
-    getAdaptableOptions = () => null;
-    constructor(getAdaptableOptions, validateOptions) {
-        this.getAdaptableOptions = getAdaptableOptions;
-        if (validateOptions) {
-            this.validateAdaptableOptionsValues();
-        }
-    }
-    getGridInfoNoCodeOptions() {
-        return this.buildGridInfoOptions({
-            filterItemProperty: (itemProperty) => itemProperty.nC === 'item',
-            filterEmptyAdaptableOptions: false,
-        });
-    }
-    validateAdaptableOptionsValues() {
-        const adaptableOptionsValues = this.getAdaptableOptions();
-        const adaptableOptionsMetamodel = this.getAdaptableOptionsMetamodel();
-        const adaptableOptionsDefaultValues = this.getAdaptableOptionsDefaultValues();
-        if (adaptableOptionsValues.adaptableId?.includes('.')) {
-            AdaptableLogger_1.AdaptableLogger.consoleWarnBase("The 'AdaptableOptions.adaptableId' property should NOT include a '.' character.  We strongly recommend to remove it to avoid unexpected AdapTable behavior.");
-        }
-        const validationErrors = [];
-        this.validateOptionsObject(validationErrors, 'AdaptableOptions', adaptableOptionsValues, adaptableOptionsMetamodel, adaptableOptionsDefaultValues);
-        if (validationErrors.length) {
-            AdaptableLogger_1.AdaptableLogger.consoleWarnBase([
-                'AdaptableOptions validation errors:',
-                '\n',
-                ...validationErrors,
-                '\n',
-                `See AdaptableOptions documentation at ${DocumentationLinkConstants_1.AdaptableOptionsDocsLink} for details`,
-            ].join('\n'));
-        }
-    }
-    validateOptionsObject(validationErrors, optionsObjectName, optionsObject, optionsObjectMetamodel, optionsObjectDefaultValues) {
-        Object.entries(optionsObject).forEach(([optionKey, optionValue]) => {
-            // ignore fdc3options
-            if (optionKey === 'fdc3Options') {
-                return;
-            }
-            const optionMetamodel = optionsObjectMetamodel?.p?.find((metamodelProperty) => metamodelProperty.n === optionKey);
-            // Return if property not found - log if not 'Revision' or 'Uuid' or 'AdaptableVersion'
-            if (!optionMetamodel) {
-                if (optionKey === 'Revision' || optionKey === 'Uuid' || optionKey === 'AdaptableVersion') {
-                    return;
-                }
-                else {
-                    validationErrors.push(`${optionsObjectName}.${optionKey} (value=${optionValue}) :: unknown/unsupported property, will be ignored`);
-                    return;
-                }
-            }
-            // let's try to validate the type of the provided value
-            const expectedOptionsValueType = this.getExpectedOptionsValueType(optionMetamodel);
-            const providedOptionsValueType = Array.isArray(optionValue) ? 'a' : typeof optionValue;
-            if (!expectedOptionsValueType) {
-                return;
-            }
-            // if it's a REFERENCE, we try to go (recursively) deeper
-            if (expectedOptionsValueType === 'R') {
-                const referenceObjectName = optionMetamodel.r;
-                const referenceObject = optionsObject[optionKey];
-                const referenceObjectMetamodel = this.getAdaptableMetamodel()[referenceObjectName];
-                if (referenceObject && referenceObjectMetamodel?.k === 'I') {
-                    this.validateOptionsObject(validationErrors, referenceObjectName, referenceObject, referenceObjectMetamodel, optionsObjectDefaultValues?.[optionKey]);
-                }
-            }
-            else if (supportedMetamodelTypes.includes(providedOptionsValueType) &&
-                providedOptionsValueType !== expectedOptionsValueType) {
-                validationErrors.push(`${optionsObjectName}.${optionKey} (value=${optionValue}) :: wrong type (${providedOptionsValueType}), expected ${expectedOptionsValueType}`);
-            }
-        });
-    }
-    getExpectedOptionsValueType(metamodelProperty) {
-        const metamodelPropertyKind = metamodelProperty.k;
-        if (supportedMetamodelTypes.includes(metamodelPropertyKind)) {
-            return metamodelPropertyKind;
-        }
-    }
-    buildGridInfoOptions(options) {
-        const { filterItemProperty, filterEmptyAdaptableOptions = true } = options;
-        const gridInfoOptions = new Map();
-        const adaptableMetamodel = this.getAdaptableMetamodel();
-        const adaptableOptionsMetamodel = this.getAdaptableOptionsMetamodel();
-        const adaptableOptionsValues = this.getAdaptableOptions();
-        const adaptableOptionsDefaultValues = this.getAdaptableOptionsDefaultValues();
-        if (!adaptableOptionsMetamodel) {
-            // should never happen
-            return gridInfoOptions;
-        }
-        // root-level properties are grouped in a synthetic 'Base Options' container
-        const baseOptionsItems = this.mapGridInfoContainerItems(adaptableOptionsMetamodel, adaptableOptionsValues, adaptableOptionsDefaultValues, filterItemProperty);
-        gridInfoOptions.set('baseOptions', {
-            containerLabel: 'Base Options',
-            items: baseOptionsItems,
-        });
-        // map containers — any top-level property that points to another
-        // metamodel item (k === 'R') is a nested *Options object
-        adaptableOptionsMetamodel.p
-            .filter((optionItem) => optionItem.k === 'R')
-            .forEach((containerOptionItem) => {
-            const containerMetamodelName = containerOptionItem.r;
-            const adaptableOptionsName = containerOptionItem.n;
-            const containerOptionsMetamodel = adaptableMetamodel[containerMetamodelName];
-            // @ts-ignore
-            const containerOptionsValues = adaptableOptionsValues[adaptableOptionsName];
-            // @ts-ignore
-            const containerOptionsDefaultValues = adaptableOptionsDefaultValues[adaptableOptionsName];
-            if (!containerOptionsMetamodel ||
-                (!containerOptionsValues && filterEmptyAdaptableOptions) ||
-                !containerOptionsDefaultValues) {
-                // should never happen
-                return;
-            }
-            const optionItems = this.mapGridInfoContainerItems(containerOptionsMetamodel, containerOptionsValues, containerOptionsDefaultValues, filterItemProperty);
-            gridInfoOptions.set(containerOptionItem.n, {
-                containerLabel: this.extractUiLabel(containerOptionItem),
-                items: optionItems,
-            });
-        });
-        return gridInfoOptions;
-    }
-    mapGridInfoContainerItems(optionItemContainer, adaptableOptionsValues, defaultAdaptableOptionsValues, filter) {
-        return optionItemContainer.p.filter(filter).map((itemProperty) => {
-            return {
-                name: itemProperty.n,
-                value: adaptableOptionsValues?.[itemProperty.n],
-                defaultValue: defaultAdaptableOptionsValues[itemProperty.n],
-                kind: itemProperty.k,
-                description: StringExtensions_1.default.UnescapeHtmlEntities(itemProperty.d ?? ''),
-                uiLabel: this.extractUiLabel(itemProperty),
-            };
-        });
-    }
-    getAdaptableOptionsDefaultValues() {
-        return (0, DefaultAdaptableOptions_1.getDefaultAdaptableOptions)();
-    }
-    getAdaptableMetamodel() {
-        return adaptable_metamodel_1.ADAPTABLE_METAMODEL;
-    }
-    getAdaptableOptionsMetamodel() {
-        return this.getAdaptableMetamodel()['AdaptableOptions'];
-    }
-    extractUiLabel(item) {
-        return item.l || this.formatCamelCaseToHumanText(item.n);
-    }
-    formatCamelCaseToHumanText(camelCase) {
-        if (!camelCase || camelCase == null) {
-            return null;
-        }
-        const rex = /([A-Z])([A-Z])([a-z])|([a-z])([A-Z])/g;
-        const words = camelCase.replace(rex, '$1$4 $2$3$5').replace('.', ' ').split(' ');
-        return words
-            .map((word) => word.substring(0, 1).toUpperCase() +
-            (word.length > 1 ? word.substring(1, word.length) : ''))
-            .join(' ');
-    }
-}
-exports.MetamodelService = MetamodelService;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableOptionsForm.d.ts

@@ -1,6 +0,0 @@
-import * as React from 'react';
-import { AdaptableOptions } from '../../../types';
-export declare const AdaptableOptionsForm: React.FunctionComponent<{
-    adaptableOptions: AdaptableOptions;
-    onChangedAdaptableOptions: (adaptableOptions: AdaptableOptions) => void;
-}>;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableOptionsForm.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableOptionsForm = void 0;
-const tslib_1 = require("tslib");
-const jsx_runtime_1 = require("react/jsx-runtime");
-const React = tslib_1.__importStar(require("react"));
-const CheckBox_1 = require("../../../components/CheckBox");
-const DropdownButton_1 = require("../../../components/DropdownButton");
-const HelpBlock_1 = tslib_1.__importDefault(require("../../../components/HelpBlock"));
-const Input_1 = tslib_1.__importDefault(require("../../../components/Input"));
-const StringExtensions_1 = tslib_1.__importDefault(require("../../../Utilities/Extensions/StringExtensions"));
-const MetamodelService_1 = require("../../../Utilities/Services/MetamodelService");
-const AdaptablePopover_1 = require("../../AdaptablePopover");
-const Flex_1 = require("../../../components/Flex");
-const SUPPORTED_PRIMITEVE_TYPES = ['s', 'n', 'b'];
-const OptionInput = (props) => {
-    const { name, defaultValue, value, description, uiLabel } = props.option;
-    const label = uiLabel ?? StringExtensions_1.default.Humanize(name);
-    let input = (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, {});
-    const info = ((0, jsx_runtime_1.jsx)(Flex_1.Box, { className: "twa:ml-2", children: (0, jsx_runtime_1.jsx)(AdaptablePopover_1.AdaptablePopover, { headerText: null, bodyText: [description] }) }));
-    const handleInputChange = (event) => props.onChange({ ...props.option, value: event.currentTarget.value });
-    const handleCheckboxChange = (checked) => props.onChange({ ...props.option, value: checked });
-    // option is mutated to acomodate complex types overrides
-    const option = { ...props.option };
-    const isOptionNonHomogenusUnion = (option) => {
-        const isUnion = option.kind.includes('|');
-        return isUnion && option.kind.split('|').some((unionEl) => !/['"]/.test(unionEl));
-    };
-    if (isOptionNonHomogenusUnion(option)) {
-        // pick the first type
-        const newKind = option.kind
-            .split('|')
-            .find((unionEl) => SUPPORTED_PRIMITEVE_TYPES.includes(unionEl.trim()))
-            .trim();
-        if (newKind)
-            option.kind = newKind;
-    }
-    const inputProps = {
-        value: value ?? defaultValue,
-        minWidth: 200,
-        fontSize: 3,
-        mr: 2,
-    };
-    if (option.kind.includes('|')) {
-        const options = option.kind
-            .split('|')
-            .map((str) => str.trim().replace(/['"]/g, ''))
-            .map((str) => ({
-            label: StringExtensions_1.default.Humanize(str),
-            onClick: () => props.onChange({ ...option, value: str }),
-        }));
-        input = ((0, jsx_runtime_1.jsx)(DropdownButton_1.NewDropdownButton, { className: "twa:min-w-[200px] twa:mr-2", items: options, children: StringExtensions_1.default.Humanize(value) }));
-    }
-    else {
-        switch (option.kind) {
-            case 'n':
-                input = (0, jsx_runtime_1.jsx)(Input_1.default, { type: "number", onChange: handleInputChange, ...inputProps });
-                break;
-            case 's':
-                input = (0, jsx_runtime_1.jsx)(Input_1.default, { type: "text", onChange: handleInputChange, ...inputProps });
-                break;
-            case 'b':
-                input = ((0, jsx_runtime_1.jsx)(CheckBox_1.CheckBox, { onChange: handleCheckboxChange, checked: Boolean(value), type: "date", children: label }));
-                break;
-        }
-    }
-    let content = ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsxs)(Flex_1.Flex, { alignItems: "center", className: "twa:min-w-[250px]", children: [label, " ", info] }), input] }));
-    if (option.kind === 'b') {
-        content = ((0, jsx_runtime_1.jsxs)(Flex_1.Flex, { alignItems: "center", children: [input, " ", info] }));
-    }
-    return (0, jsx_runtime_1.jsx)(Flex_1.Flex, { className: "twa:mb-2 twa:pl-1", children: content });
-};
-const OptionsSection = (props) => {
-    if (!props.options.length) {
-        return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, {});
-    }
-    return ((0, jsx_runtime_1.jsxs)(Flex_1.Box, { className: "twa:mb-2", children: [(0, jsx_runtime_1.jsx)(HelpBlock_1.default, { className: "twa:mb-2", children: props.name ?? props.id }), props.options.map((option, index) => ((0, jsx_runtime_1.jsx)(OptionInput, { option: option, onChange: props.onChange }, index)))] }));
-};
-const AdaptableOptionsForm = (props) => {
-    const nocodeOptions = React.useMemo(() => {
-        const metamodelService = new MetamodelService_1.MetamodelService(() => props.adaptableOptions);
-        return [...metamodelService.getGridInfoNoCodeOptions()];
-    }, [props.adaptableOptions]);
-    const handleOptionChange = (sectionName) => (option) => {
-        const adaptableOptions = { ...props.adaptableOptions };
-        if (sectionName === 'baseOptions') {
-            // @ts-ignore
-            adaptableOptions[option.name] = option.value;
-        }
-        else {
-            // @ts-ignore
-            adaptableOptions[sectionName] = {
-                // @ts-ignore
-                ...adaptableOptions[sectionName],
-                [option.name]: option.value,
-            };
-        }
-        props.onChangedAdaptableOptions(adaptableOptions);
-    };
-    return ((0, jsx_runtime_1.jsx)(Flex_1.Box, { className: "twa:p-2", children: nocodeOptions.map(([sectionName, { containerLabel, items }]) => {
-            return ((0, jsx_runtime_1.jsx)(OptionsSection, { onChange: handleOptionChange(sectionName), id: sectionName, name: containerLabel, options: items }, sectionName));
-        }) }));
-};
-exports.AdaptableOptionsForm = AdaptableOptionsForm;

package/src/metamodel/adaptable-metamodel-model.d.ts

@@ -1,26 +0,0 @@
-export type AdaptableMetamodel = Record<string, MetamodelItem>;
-export interface MetamodelItem {
-    /** Item kind: 'A' (type alias), 'I' (interface), 'C' (class) */
-    k: 'A' | 'I' | 'C';
-    /** Description (only present for noCode-tagged items) */
-    d?: string;
-    /** Properties of this item */
-    p?: MetamodelItemProperty[];
-}
-export interface MetamodelItemProperty {
-    /** Property name */
-    n: string;
-    /** Property kind / type */
-    k: MetamodelItemPropertyKind;
-    /** Description (only present for noCode-tagged properties) */
-    d?: string;
-    /** UI label override for display */
-    l?: string;
-    /** Reference to another MetamodelItem key */
-    r?: string;
-    /** Whether the property is optional */
-    o?: boolean;
-    /** No-Code role: 'item' or 'container' */
-    nC?: 'item' | 'container';
-}
-export type MetamodelItemPropertyKind = 'R' | 'n' | 's' | 'b' | 'd' | 'f' | 'a' | 'i' | 'u';

package/src/metamodel/adaptable-metamodel-model.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });