cx 26.0.1 → 26.0.3

package/build/ui/selection/Selection.js

@@ -0,0 +1,75 @@
+import { Component } from "../../util/Component";
+export class Selection extends Component {
+    constructor(config) {
+        super(config);
+    }
+    isSelected(store, record, index) {
+        return !!this.bind && store.get(this.bind) === record;
+    }
+    getIsSelectedDelegate(store) {
+        return (record, index) => this.isSelected(store, record, index);
+    }
+    select(store, record, index, options) {
+        this.selectMultiple(store, [record], [index], options);
+    }
+    selectMultiple(store, records, indexes, options) {
+        //abstract
+    }
+    declareData(...args) {
+        var declaration = {
+            $selection: { structured: true },
+        };
+        return Object.assign(declaration, ...args);
+    }
+    configureWidget(widget) {
+        if (this.record || this.index) {
+            widget.$selection = Object.assign(widget.$selection || {}, {
+                record: this.record,
+                index: this.index,
+            });
+        }
+        return this.declareData();
+    }
+    selectInstance(instance, options) {
+        var { store, data } = instance;
+        if (!data.$selection)
+            throw new Error("Selection model not properly configured. Using the selectInstance method without specified record and index bindings.");
+        return this.select(store, data.$selection.record, data.$selection.index, options);
+    }
+    isInstanceSelected(instance) {
+        var { store, data } = instance;
+        return data.$selection && this.isSelected(store, data.$selection.record, data.$selection.index);
+    }
+}
+Selection.prototype.toggle = false;
+Selection.namespace = "ui.selection.";
+export class SimpleSelection extends Selection {
+    isSelected(store, record, index) {
+        return this.getIsSelectedDelegate(store)(record, index);
+    }
+    getIsSelectedDelegate(store) {
+        var selection = this.bind && store.get(this.bind);
+        return (record, index) => record === selection;
+    }
+    selectMultiple(store, records, index) {
+        if (this.bind)
+            store.set(this.bind, records[0]);
+    }
+}
+class DummySelection extends Selection {
+    isSelected(store, record, index) {
+        return false;
+    }
+    selectMultiple() {
+        //dummy
+    }
+    selectInstance() {
+        //dummy
+    }
+}
+DummySelection.prototype.isDummy = true;
+Selection.factory = (name) => {
+    if (typeof name == "object")
+        return new SimpleSelection(name);
+    return new DummySelection();
+};

package/build/ui/selection/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Selection';
+export * from './PropertySelection';
+export * from './KeySelection';

package/build/ui/selection/index.js

@@ -0,0 +1,3 @@
+export * from './Selection';
+export * from './PropertySelection';
+export * from './KeySelection';

package/build/ui/tpl.d.ts

@@ -0,0 +1,3 @@
+export declare function tpl(text: string): {
+    tpl: string;
+};

package/build/ui/tpl.js

@@ -0,0 +1,5 @@
+export function tpl(text) {
+    return {
+        tpl: text
+    };
+}

package/build/util/Component.d.ts

@@ -0,0 +1,149 @@
+interface DecoratorFactory<T> {
+    (t: T): T;
+}
+/** A Component class constructor (supports abstract classes) */
+export type ComponentConstructor<T extends Component = Component> = (abstract new (config?: any) => T) & {
+    isComponentType: true;
+    prototype: T;
+};
+/** Extract the config type from a Component class constructor */
+export type ComponentConfigType<T> = T extends abstract new (config?: infer C) => any ? C & {
+    isComponentType?: never;
+} : unknown;
+/** Extract the instance type from a Component class constructor */
+export type ComponentInstanceType<T> = T extends abstract new (config?: any) => infer I ? I : Component;
+/**
+ * Type representing any valid input to Component.create that will produce an instance of T.
+ *
+ * Accepts:
+ * - An instance of T (pass-through)
+ * - A constructor for T or any subtype
+ * - A config object for T (when T has a known config type)
+ * - A config object with `type` or `$type` property specifying the constructor
+ *
+ * @example
+ * // In a Chart widget config:
+ * interface ChartConfig {
+ *    xAxis?: Creatable<Axis>;  // Accepts NumericAxis, CategoryAxis, etc.
+ *    yAxis?: Creatable<Axis>;
+ * }
+ *
+ * // Usage:
+ * <Chart xAxis={NumericAxis} />  // Just the type
+ * <Chart xAxis={{ type: NumericAxis, min: 0, max: 100 }} />  // Config with type
+ * <Chart xAxis={new NumericAxis({ min: 0 })} />  // Instance
+ */
+type SubclassConstructor<TBaseCtor extends ComponentConstructor> = ComponentConstructor<ComponentInstanceType<TBaseCtor>>;
+type ResolveConfigType<TBaseCtor extends ComponentConstructor, TSubCtor extends ComponentConstructor> = 0 extends 1 & ComponentConfigType<TSubCtor> ? ComponentConfigType<TBaseCtor> : ComponentConfigType<TSubCtor>;
+type ConfigWithType<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor>> = {
+    type: TSubCtor;
+} & ResolveConfigType<TBaseCtor, TSubCtor> & (0 extends 1 & ComponentConfigType<TSubCtor> ? {
+    [key: string]: unknown;
+} : {});
+type ConfigWith$Type<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor>> = {
+    $type: TSubCtor;
+} & ResolveConfigType<TBaseCtor, TSubCtor> & (0 extends 1 & ComponentConfigType<TSubCtor> ? {
+    [key: string]: unknown;
+} : {});
+export type CreateConfig<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor> = SubclassConstructor<TBaseCtor>> = TSubCtor | ConfigWithType<TBaseCtor, TSubCtor> | ConfigWith$Type<TBaseCtor, TSubCtor>;
+export type Create<TCtor extends ComponentConstructor> = ComponentInstanceType<TCtor> | CreateConfig<TCtor>;
+/**
+ * Type-checks a CreateConfig object based on its `type` or `$type` property.
+ * This is a compile-time helper that returns the input unchanged at runtime.
+ * Uses `const` type parameter (TypeScript 5.0+) to enable excess property checking.
+ *
+ * @example
+ * // With type property
+ * const axisConfig = validateConfig({ type: NumericAxis, min: 0, max: 100 });
+ *
+ * // With $type property
+ * const selectionConfig = validateConfig({ $type: KeySelection, bind: "selection" });
+ */
+export declare function validateConfig<const TCtor extends ComponentConstructor>(config: ({
+    type: TCtor;
+    $type?: never;
+} & ComponentConfigType<TCtor>) | ({
+    $type: TCtor;
+    type?: never;
+} & ComponentConfigType<TCtor>)): any;
+export declare class Component {
+    static namespace: string;
+    static isComponentType: true;
+    static autoInit: boolean;
+    static factory: (alias: string, config?: any, more?: any) => Component;
+    isComponent: boolean;
+    constructor(config?: any);
+    init(): void;
+    /**
+     *
+     * @param alias
+     * @param type
+     */
+    static alias<T>(alias: string, type: T): void;
+    static alias<T>(alias: string): DecoratorFactory<T>;
+    /**
+     * Creates a component instance from various input types.
+     *
+     * Supported signatures:
+     * - Pass-through: If input is already a component instance, returns it unchanged
+     * - Array: Maps over array elements, creating components for each
+     * - Class type: Creates instance of the specified class with config
+     * - Config with type/$type: Creates instance of the type specified in config
+     * - String alias: Looks up registered alias and creates that type
+     * - Plain config: Creates instance of the class `create` was called on
+     *
+     * @example
+     * // Pass-through
+     * const btn = new Button();
+     * Button.create(btn) // returns btn as Button
+     *
+     * // Class type with config
+     * Button.create(Button, { text: "Click" }) // returns Button
+     *
+     * // Config with type property
+     * Widget.create({ type: Button, text: "Click" }) // returns Button
+     *
+     * // Plain config on specific class
+     * Button.create({ text: "Click" }) // returns Button with ButtonConfig typing
+     */
+    static create<T extends Component>(instance: T, unused?: any): T;
+    static create<T extends ({
+        type: ComponentConstructor;
+        $type?: never;
+    } | {
+        $type: ComponentConstructor;
+        type?: never;
+    })[]>(configs: [...T], more?: Record<string, any>): {
+        [K in keyof T]: T[K] extends {
+            type: ComponentConstructor<infer U>;
+        } ? U : T[K] extends {
+            $type: ComponentConstructor<infer U>;
+        } ? U : Component;
+    };
+    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(config: ({
+        type: TCtor;
+        $type?: never;
+        isComponentType?: never;
+    } | {
+        $type: TCtor;
+        type?: never;
+        isComponentType?: never;
+    }) & Partial<ComponentConfigType<ComponentConstructor<T>>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
+    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(type: TCtor, configs: ComponentConfigType<ComponentConstructor<T>>[], more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T[];
+    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(type: TCtor, config?: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
+    static create<T extends Component>(this: {
+        prototype: T;
+        isComponentType: true;
+    }, configs: ComponentConfigType<ComponentConstructor<T>>[], more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T[];
+    static create<T extends Component>(this: {
+        prototype: T;
+        isComponentType: true;
+    }, config: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
+    static create<T extends Component>(this: {
+        prototype: T;
+        isComponentType: true;
+    }, alias: string, config?: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
+}
+export declare function createComponentFactory(factory: any, jsxDriver: any, meta?: any): any;
+export declare function isComponentFactory(factory: any): boolean;
+export {};

package/build/util/Component.js

@@ -0,0 +1,109 @@
+import { isString } from "./isString";
+import { isFunction } from "./isFunction";
+import { isArray } from "./isArray";
+/**
+ * Type-checks a CreateConfig object based on its `type` or `$type` property.
+ * This is a compile-time helper that returns the input unchanged at runtime.
+ * Uses `const` type parameter (TypeScript 5.0+) to enable excess property checking.
+ *
+ * @example
+ * // With type property
+ * const axisConfig = validateConfig({ type: NumericAxis, min: 0, max: 100 });
+ *
+ * // With $type property
+ * const selectionConfig = validateConfig({ $type: KeySelection, bind: "selection" });
+ */
+export function validateConfig(config) {
+    return config;
+}
+const componentAlias = {};
+export class Component {
+    static namespace;
+    static isComponentType;
+    static autoInit;
+    static factory;
+    constructor(config) {
+        if (config && config.$props) {
+            Object.assign(config, config.$props);
+            delete config.$props;
+        }
+        Object.assign(this, config);
+    }
+    init() { }
+    static alias(alias, type) {
+        if (type) {
+            type.prototype.componentAlias = alias;
+            componentAlias[this.namespace + alias] = type;
+        } //decorator usage
+        else
+            return (t) => {
+                this.alias(alias, t);
+                return t;
+            };
+    }
+    // Implementation
+    static create(typeAlias, config, more) {
+        if (!typeAlias)
+            return this.factory(typeAlias, config, more);
+        if (typeAlias.isComponent)
+            return typeAlias;
+        if (isComponentFactory(typeAlias))
+            return this.create(typeAlias.create(config), config, more);
+        if (isArray(typeAlias))
+            return typeAlias.map((c) => this.create(c, config, more));
+        if (typeAlias.$type)
+            return this.create(typeAlias.$type, typeAlias, config);
+        if (typeAlias.type)
+            return this.create(typeAlias.type, typeAlias, config);
+        let cmpType, alias;
+        if (typeAlias.isComponentType)
+            cmpType = typeAlias;
+        else if (isFunction(typeAlias)) {
+            if (this.factory)
+                return this.factory(typeAlias, config, more);
+            throw new Error(`Unsupported component type ${typeAlias}.`);
+        }
+        else if (isString(typeAlias)) {
+            alias = this.namespace + typeAlias;
+            cmpType = componentAlias[alias];
+            if (!cmpType) {
+                if (typeAlias && this.factory)
+                    return this.factory(typeAlias, config, more);
+                throw new Error(`Unknown component alias ${alias}.`);
+            }
+        }
+        else if (typeof typeAlias == "object") {
+            cmpType = typeAlias.type || typeAlias.$type;
+            if (!cmpType) {
+                cmpType = this;
+                more = more ? Object.assign({}, config, more) : config;
+                config = typeAlias;
+            }
+        }
+        if (isArray(config))
+            return config.map((cfg) => this.create(cmpType, cfg, more));
+        let cfg = config;
+        if (more)
+            cfg = Object.assign({}, config, more);
+        let cmp = new cmpType(cfg);
+        if (cmpType.autoInit && cmp.init)
+            cmp.init();
+        return cmp;
+    }
+}
+Component.prototype.isComponent = true;
+Component.isComponentType = true;
+Component.namespace = "";
+Component.autoInit = false;
+Component.factory = (alias, _config, _more) => {
+    throw new Error(`Unknown component alias ${alias}.`);
+};
+export function createComponentFactory(factory, jsxDriver, meta) {
+    factory.$isComponentFactory = true;
+    factory.$meta = meta;
+    factory.create = jsxDriver;
+    return factory;
+}
+export function isComponentFactory(factory) {
+    return factory && factory.$isComponentFactory;
+}

package/build/util/Console.d.ts

@@ -0,0 +1,4 @@
+export declare const Console: {
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+};

package/build/util/Console.js

@@ -0,0 +1,10 @@
+export const Console = {
+    log: (...args) => {
+        if (typeof window != 'undefined' && window.console)
+            console.log(...args);
+    },
+    warn: (...args) => {
+        if (typeof window != 'undefined' && window.console)
+            console.warn(...args);
+    }
+};

package/build/util/DOM.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns first child element, or the parent element itself, that satisfies the `condition` function.
+ * @param el
+ * @param condition
+ * @returns {Element}
+ */
+export declare function findFirst<T extends Element>(el: Element, condition: (el: Element) => el is T): T | null;
+export declare function findFirst(el: Element, condition: (el: Element) => boolean): Element | null;
+export declare function findFirstChild<T extends Element>(el: Element, condition: (el: Element) => el is T): T | null;
+export declare function findFirstChild(el: Element, condition: (el: Element) => boolean): Element | null;
+export declare function closest(el: HTMLElement | null, condition: (el: HTMLElement) => boolean): HTMLElement | null;
+export declare function closest(el: Element | null, condition: (el: Element) => boolean): Element | null;
+export declare function closestParent(el: HTMLElement, condition: (el: HTMLElement) => boolean): HTMLElement | null;
+export declare function closestParent(el: Element, condition: (el: HTMLElement) => boolean): HTMLElement | null;
+export declare function isFocused(el: Element): boolean;
+export declare function isFocusedDeep(el: Element): boolean;
+export declare function isFocusable(el: Element): el is HTMLElement;
+/**
+ * Returns focused element.
+ * @returns {Element}
+ */
+export declare function getFocusedElement(): Element | null;
+export declare function isDescendant(el: Element, descEl: Element): boolean;
+export declare function isSelfOrDescendant(el: Element, descEl: Element): boolean;

package/build/util/DOM.js

@@ -0,0 +1,64 @@
+import { isNumber } from "../util/isNumber";
+export function findFirst(el, condition) {
+    if (condition(el))
+        return el;
+    var children = el.children;
+    if (children)
+        for (var i = 0; i < children.length; i++) {
+            var child = findFirst(children[i], condition);
+            if (child)
+                return child;
+        }
+    return null;
+}
+export function findFirstChild(el, condition) {
+    var children = el.children;
+    if (children)
+        for (var i = 0; i < children.length; i++) {
+            var child = findFirst(children[i], condition);
+            if (child)
+                return child;
+        }
+    return null;
+}
+export function closest(el, condition) {
+    while (el) {
+        if (condition(el))
+            return el;
+        el = el.parentElement;
+    }
+    return null;
+}
+export function closestParent(el, condition) {
+    return el && closest(el.parentElement, condition);
+}
+export function isFocused(el) {
+    return document.activeElement == el;
+}
+export function isFocusedDeep(el) {
+    return document.activeElement == el || (!!document.activeElement && el.contains(document.activeElement));
+}
+const focusableWithoutTabIndex = ["INPUT", "SELECT", "TEXTAREA", "A", "BUTTON"];
+export function isFocusable(el) {
+    if (!(el instanceof HTMLElement))
+        return false;
+    var firstPass = el && isNumber(el.tabIndex) && el.tabIndex >= 0;
+    if (!firstPass)
+        return false;
+    if (focusableWithoutTabIndex.indexOf(el.tagName) != -1 && !el.hasAttribute("disabled"))
+        return true;
+    return el.hasAttribute("tabindex");
+}
+/**
+ * Returns focused element.
+ * @returns {Element}
+ */
+export function getFocusedElement() {
+    return document.activeElement;
+}
+export function isDescendant(el, descEl) {
+    return el.contains(descEl);
+}
+export function isSelfOrDescendant(el, descEl) {
+    return el == descEl || el.contains(descEl);
+}

package/build/util/Debug.d.ts

@@ -0,0 +1,25 @@
+export type DebugFlag = 'render' | 'prepare' | 'process-data' | 'cleanup' | 'menu' | 'focus' | 'internal' | 'should-update' | 'app-data' | 'tooltips' | 'deprecated' | 'destroy' | string;
+interface DebugFlags {
+    [flag: string]: boolean;
+}
+export declare function debug(flag: DebugFlag, ...args: any[]): void;
+export declare const Debug: {
+    enable(flag: DebugFlag): void;
+    disable(flag: DebugFlag): void;
+    isEnabled(flag: DebugFlag): boolean;
+    getActiveFlags(): Readonly<DebugFlags>;
+    log: typeof debug;
+};
+export declare const renderFlag: DebugFlag;
+export declare const prepareFlag: DebugFlag;
+export declare const processDataFlag: DebugFlag;
+export declare const cleanupFlag: DebugFlag;
+export declare const menuFlag: DebugFlag;
+export declare const focusFlag: DebugFlag;
+export declare const internalFlag: DebugFlag;
+export declare const shouldUpdateFlag: DebugFlag;
+export declare const appDataFlag: DebugFlag;
+export declare const tooltipsFlag: DebugFlag;
+export declare const deprecatedFlag: DebugFlag;
+export declare const destroyFlag: DebugFlag;
+export {};

package/build/util/Debug.js

@@ -0,0 +1,42 @@
+import { Console } from './Console';
+let activeFlags = {
+    deprecated: true
+};
+export function debug(flag, ...args) {
+    if (process.env.NODE_ENV !== "production") {
+        if (!activeFlags[flag])
+            return;
+        Console.log(flag + ':', ...args);
+    }
+}
+export const Debug = {
+    enable(flag) {
+        if (process.env.NODE_ENV !== "production") {
+            activeFlags[flag] = true;
+        }
+    },
+    disable(flag) {
+        if (process.env.NODE_ENV !== "production") {
+            activeFlags[flag] = false;
+        }
+    },
+    isEnabled(flag) {
+        return process.env.NODE_ENV !== "production" && !!activeFlags[flag];
+    },
+    getActiveFlags() {
+        return { ...activeFlags };
+    },
+    log: debug
+};
+export const renderFlag = 'render';
+export const prepareFlag = 'prepare';
+export const processDataFlag = 'process-data';
+export const cleanupFlag = 'cleanup';
+export const menuFlag = 'menu';
+export const focusFlag = 'focus';
+export const internalFlag = 'internal';
+export const shouldUpdateFlag = 'should-update';
+export const appDataFlag = 'app-data';
+export const tooltipsFlag = 'tooltips';
+export const deprecatedFlag = 'deprecated';
+export const destroyFlag = 'destroy';

package/build/util/Format.d.ts

@@ -0,0 +1,14 @@
+type Formatter = (value: any) => string;
+export declare function setGetFormatCacheCallback(callback: () => Record<string, Formatter>): void;
+export declare class Format {
+    static value(v: any, format: string): string;
+    static parse(format: string): Formatter;
+    static register(format: string | string[], formatter: Formatter): void;
+    static registerFactory(format: string | string[], factory: (...args: any[]) => Formatter): void;
+}
+export declare function resolveMinMaxFractionDigits(minimumFractionDigits: number, maximumFractionDigits: number): {
+    minimumFractionDigits: number;
+    maximumFractionDigits: number;
+};
+export declare function trimFractionZeros(str: string, max: number): string;
+export {};