cx 26.0.1 → 26.0.3

package/build/svg/index.d.ts

@@ -0,0 +1,11 @@
+export * from './util/index';
+export * from './BoundedObject';
+export * from './TextualBoundedObject';
+export * from './Svg';
+export * from './Rectangle';
+export * from './ClipRect';
+export * from './Ellipse';
+export * from './Line';
+export * from './Text';
+export * from './NonOverlappingRect';
+export * from './NonOverlappingRectGroup';

package/build/svg/index.js

@@ -0,0 +1,11 @@
+export * from './util/index';
+export * from './BoundedObject';
+export * from './TextualBoundedObject';
+export * from './Svg';
+export * from './Rectangle';
+export * from './ClipRect';
+export * from './Ellipse';
+export * from './Line';
+export * from './Text';
+export * from './NonOverlappingRect';
+export * from './NonOverlappingRectGroup';

package/build/svg/util/Rect.d.ts

@@ -0,0 +1,31 @@
+type RectMargin = string | Rect | Array<string | number>;
+export interface IRect {
+    l: number;
+    r: number;
+    t: number;
+    b: number;
+}
+export declare class Rect implements IRect {
+    isRect: boolean;
+    l: number;
+    r: number;
+    t: number;
+    b: number;
+    constructor(config?: {
+        t?: number;
+        r?: number;
+        b?: number;
+        l?: number;
+    });
+    width(): number;
+    height(): number;
+    valid(): boolean;
+    makeValid(): Rect;
+    isEqual(r: Rect): boolean;
+    static add(a: Rect, b: Rect): Rect;
+    static multiply(a: Rect, b: Rect): Rect;
+    static margin(r: Rect, m?: RectMargin): Rect;
+    static convertMargin(m?: RectMargin): Rect;
+    static convert(r?: RectMargin | number): Rect;
+}
+export {};

package/build/svg/util/Rect.js

@@ -0,0 +1,83 @@
+import { isNumber } from "../../util/isNumber";
+import { isArray } from "../../util/isArray";
+export class Rect {
+    isRect = true;
+    l = 0; //left;
+    r = 0; //right
+    t = 0; //top
+    b = 0; //bottom
+    constructor(config) {
+        Object.assign(this, config);
+    }
+    width() {
+        return this.r - this.l;
+    }
+    height() {
+        return this.b - this.t;
+    }
+    valid() {
+        return this.r > this.l && this.b > this.t;
+    }
+    makeValid() {
+        return new Rect({
+            l: Math.min(this.l, this.r),
+            r: Math.max(this.l, this.r),
+            t: Math.min(this.t, this.b),
+            b: Math.max(this.t, this.b),
+        });
+    }
+    isEqual(r) {
+        if (!r || !r.isRect)
+            return false;
+        return r.l == this.l && r.r == this.r && r.t == this.t && r.b == this.b;
+    }
+    static add(a, b) {
+        return new Rect({
+            l: a.l + b.l,
+            t: a.t + b.t,
+            r: a.r + b.r,
+            b: a.b + b.b,
+        });
+    }
+    static multiply(a, b) {
+        return new Rect({
+            l: a.l + (a.r - a.l) * b.l,
+            r: a.l + (a.r - a.l) * b.r,
+            t: a.t + (a.b - a.t) * b.t,
+            b: a.t + (a.b - a.t) * b.b,
+        });
+    }
+    static margin(r, m) {
+        var mr = Rect.convertMargin(m);
+        return Rect.add(r, mr);
+    }
+    static convertMargin(m) {
+        if (!m)
+            return new Rect();
+        if (m.isRect)
+            return m;
+        if (isNumber(m))
+            return new Rect({ l: m, t: m, r: -m, b: -m });
+        var mr = Rect.convert(m);
+        mr.b = -mr.b;
+        mr.r = -mr.r;
+        return mr;
+    }
+    static convert(r) {
+        if (!r)
+            return new Rect({ l: 0, r: 0, t: 0, b: 0 });
+        if (r.isRect)
+            return r;
+        if (typeof r === "string")
+            r = r.split(" ");
+        if (isArray(r)) {
+            return new Rect({
+                t: parseFloat(r[0]),
+                r: parseFloat(r[1]),
+                b: parseFloat(r[2]),
+                l: parseFloat(r[3]),
+            });
+        }
+        return new Rect(r);
+    }
+}

package/build/svg/util/index.d.ts

@@ -0,0 +1 @@
+export * from './Rect';

package/build/svg/util/index.js

@@ -0,0 +1 @@
+export * from './Rect';

package/build/ui/CSS.d.ts

@@ -0,0 +1,10 @@
+export declare class CSS {
+    static classPrefix: string;
+    static resolve(...args: any[]): any[];
+    static block(baseClass: string, styleModifiers?: any, stateModifiers?: any): string;
+    static element(baseClass: string, elementClass: string, stateModifiers?: any): string;
+    static state(stateModifiers: any): string | undefined;
+    static mod(mods: any): string | undefined;
+    static expand(...args: any[]): string | undefined;
+    static parseStyle(str: any): any;
+}

package/build/ui/CSS.js

@@ -0,0 +1,77 @@
+import { CSSHelper } from "./CSSHelper";
+import { parseStyle } from "../util/parseStyle";
+import { isArray } from "../util/isArray";
+function push(list, item) {
+    if (!item)
+        return list || [];
+    if (!list)
+        list = [];
+    list.push(item);
+    return list;
+}
+function pushMore(list, itemArray) {
+    if (!itemArray || itemArray.length == 0)
+        return list || [];
+    if (!list)
+        list = [];
+    list.push.apply(list, itemArray);
+    return list;
+}
+function pushMap(list, itemArray, mapF) {
+    return itemArray ? pushMore(list, itemArray.map(mapF)) : list;
+}
+function join(list) {
+    return list ? list.join(" ") : undefined;
+}
+export class CSS {
+    static classPrefix;
+    static resolve(...args) {
+        let list = undefined, type, arg, i, key;
+        for (i = 0; i < args.length; i++) {
+            arg = args[i];
+            if (arg) {
+                type = typeof arg;
+                if (type == "string")
+                    list = push(list, arg);
+                else if (type == "object") {
+                    if (isArray(arg))
+                        list = pushMore(list, this.resolve(...arg));
+                    else
+                        for (key in arg)
+                            if (arg[key])
+                                list = push(list, key);
+                }
+            }
+        }
+        return list || [];
+    }
+    static block(baseClass, styleModifiers, stateModifiers) {
+        let list;
+        if (baseClass)
+            list = push(list, this.classPrefix + "b-" + baseClass);
+        list = pushMap(list, this.resolve(styleModifiers), (m) => this.classPrefix + "m-" + m);
+        list = pushMap(list, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m);
+        return join(list);
+    }
+    static element(baseClass, elementClass, stateModifiers) {
+        let list;
+        if (baseClass && elementClass)
+            list = push(list, this.classPrefix + "e-" + baseClass + "-" + elementClass);
+        list = pushMap(list, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m);
+        return join(list);
+    }
+    static state(stateModifiers) {
+        return join(pushMap(undefined, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m));
+    }
+    static mod(mods) {
+        return join(pushMap(undefined, this.resolve(mods), (m) => this.classPrefix + "m-" + m));
+    }
+    static expand(...args) {
+        return join(this.resolve(...args));
+    }
+    static parseStyle(str) {
+        return parseStyle(str);
+    }
+}
+CSS.classPrefix = "cx";
+CSSHelper.alias("cx", CSS);

package/build/ui/CSSHelper.d.ts

@@ -0,0 +1,5 @@
+export declare class CSSHelper {
+    static get(code: string): any;
+    static register(code: string, helper: any): void;
+    static alias(code: string, helper: any): void;
+}

package/build/ui/CSSHelper.js

@@ -0,0 +1,15 @@
+var cssHelperCache = {};
+export class CSSHelper {
+    static get(code) {
+        var helper = cssHelperCache[code];
+        if (!helper)
+            throw new Error(`Unknown CSS helper '${code}'.`);
+        return helper;
+    }
+    static register(code, helper) {
+        cssHelperCache[code] = helper;
+    }
+    static alias(code, helper) {
+        cssHelperCache[code] = helper;
+    }
+}

package/build/ui/Container.d.ts

@@ -0,0 +1,55 @@
+import { Widget, WidgetConfig, WidgetStyleConfig } from "./Widget";
+import { ClassProp, ModProp, StyleProp } from "./Prop";
+import { Instance } from "./Instance";
+import { CxChild, RenderingContext } from "./RenderingContext";
+import { Create } from "../util";
+export type ChildNode = Create<typeof Widget> | string | number | boolean | null | undefined;
+export interface ContainerConfig extends WidgetConfig {
+    /** Keep whitespace in text based children. Default is `false`. See also `trimWhitespace`. */
+    ws?: boolean;
+    /** Remove all whitespace in text based children. Default is `true`. See also `preserveWhitespace`. */
+    trimWhitespace?: boolean;
+    /** Keep whitespace in text based children. Default is `false`. See also `trimWhitespace`. */
+    preserveWhitespace?: boolean;
+    /** List of child elements. */
+    items?: ChildNode | ChildNode[];
+    /** List of child elements. */
+    children?: ChildNode | ChildNode[];
+    plainText?: boolean;
+}
+export interface StyledContainerConfig extends ContainerConfig, WidgetStyleConfig {
+}
+export declare class ContainerBase<Config extends ContainerConfig = ContainerConfig, InstanceType extends Instance = Instance> extends Widget<Config, InstanceType> {
+    ws?: boolean;
+    preserveWhitespace?: boolean;
+    trimWhitespace?: boolean;
+    items: Widget[];
+    children?: Widget[];
+    layout?: Container | null;
+    useParentLayout?: boolean;
+    itemDefaults?: any;
+    plainText?: boolean;
+    init(context?: any): void;
+    protected exploreItems(context: RenderingContext, instance: Instance, items: CxChild[]): void;
+    explore(context: any, instance: any): void;
+    render(context: any, instance: any, key: any): any;
+    protected renderChildren(_context: any, instance: any, key?: string): any;
+    clear(): void;
+    add(...args: any[]): void;
+    protected wrapItem(item: any): any;
+    protected addText(text: string): void;
+    find(filter: any, options?: any): any[];
+    findFirst(filter: any, options?: any): any;
+}
+export declare class Container extends ContainerBase<ContainerConfig, Instance> {
+}
+export declare class StyledContainerBase<Config extends StyledContainerConfig = StyledContainerConfig, InstanceType extends Instance = Instance> extends ContainerBase<Config, InstanceType> {
+    class?: ClassProp;
+    className?: ClassProp;
+    style?: StyleProp;
+    styles?: StyleProp;
+    baseClass?: string;
+    mod?: ModProp;
+}
+export declare class StyledContainer extends StyledContainerBase<StyledContainerConfig, Instance> {
+}

package/build/ui/Container.js

@@ -0,0 +1,160 @@
+import { contentAppend, Widget } from "./Widget";
+import { StaticText } from "./StaticText";
+import { Text } from "./Text";
+import { innerTextTrim } from "../util/innerTextTrim";
+import { isString } from "../util/isString";
+import { isArray } from "../util/isArray";
+import { exploreChildren } from "./layout/exploreChildren";
+// Base class for extending with custom Config types
+export class ContainerBase extends Widget {
+    init(context) {
+        if (typeof this.ws !== "undefined")
+            this.preserveWhitespace = this.ws;
+        if (this.preserveWhitespace)
+            this.trimWhitespace = false;
+        let items = this.items || this.children || [];
+        delete this.children;
+        this.items = [];
+        if (this.layout) {
+            let layout = Container.create(this.layout, { items });
+            layout.init(context);
+            this.layout = null;
+            if ("noLayout" in layout && layout.noLayout) {
+                this.useParentLayout = true;
+                this.add(items);
+            }
+            else {
+                this.add(layout);
+                this.layout = layout;
+            }
+        }
+        else {
+            this.add(items);
+        }
+        super.init();
+    }
+    exploreItems(context, instance, items) {
+        instance.children = exploreChildren(context, instance, items, instance.cached.children, null, instance.store);
+        if (instance.cache("children", instance.children))
+            instance.markShouldUpdate(context);
+    }
+    explore(context, instance) {
+        super.explore(context, instance);
+        this.exploreItems(context, instance, this.items);
+    }
+    render(context, instance, key) {
+        return this.renderChildren(context, instance, key);
+    }
+    renderChildren(_context, instance, key) {
+        let preserveComplexContent = this.useParentLayout;
+        function append(result, r) {
+            if (r == null)
+                return;
+            //react element
+            if (!r.hasOwnProperty("content")) {
+                contentAppend(result, r);
+                return;
+            }
+            if (r.useParentLayout)
+                return r.content.forEach((x) => append(result, x));
+            if (r.atomic || preserveComplexContent) {
+                result.push(r);
+            }
+            else {
+                let first = true;
+                for (let k in r)
+                    if (contentAppend(result, r[k], !first))
+                        first = false;
+            }
+        }
+        let result = [];
+        for (let i = 0; i < instance.children.length; i++) {
+            append(result, instance.children[i].vdom);
+        }
+        if (this.useParentLayout)
+            return {
+                useParentLayout: true,
+                content: result,
+            };
+        return result;
+    }
+    clear() {
+        if (this.layout)
+            this.layout.clear();
+        else
+            this.items = [];
+    }
+    add(...args) {
+        if (this.layout)
+            return this.layout.add(...args);
+        for (let a of args) {
+            if (!a)
+                continue;
+            if (isArray(a)) {
+                for (let c of a)
+                    this.add(c);
+            }
+            else if (isString(a)) {
+                if (this.trimWhitespace)
+                    a = innerTextTrim(a);
+                if (a)
+                    this.addText(a);
+            }
+            else if (a.isComponent)
+                this.items.push(this.wrapItem(a));
+            else {
+                this.add(Widget.create(a, this.itemDefaults, {}));
+            }
+        }
+    }
+    wrapItem(item) {
+        return item;
+    }
+    addText(text) {
+        if (this.plainText || text.indexOf("{") == -1 || text.indexOf("}") == -1)
+            this.add(Widget.create(StaticText, { text: text }, {}));
+        else
+            this.add(Widget.create(Text, { text: { tpl: text } }, {}));
+    }
+    find(filter, options) {
+        if (!options)
+            options = {};
+        if (!filter || !this.items)
+            return [];
+        let alias = filter;
+        if (isString(filter))
+            filter = (w) => w.componentAlias == alias;
+        if (filter.isComponentType)
+            filter = (w) => w instanceof alias;
+        let results = [];
+        for (let i = 0; i < this.items.length; i++) {
+            let w = this.items[i];
+            if (w && !w.initialized)
+                w.init();
+            if (filter(w)) {
+                results.push(w);
+                if (options.first)
+                    break;
+            }
+            if (w && w.find)
+                results.push(...w.find(filter, options));
+        }
+        return results;
+    }
+    findFirst(filter, options) {
+        return this.find(filter, { ...options, first: true })[0];
+    }
+}
+ContainerBase.prototype.trimWhitespace = true;
+ContainerBase.prototype.plainText = true;
+ContainerBase.prototype.styled = false;
+// Closed type for direct usage - preserves ControllerProp ThisType
+export class Container extends ContainerBase {
+}
+// Base class for styled containers with custom Config types
+export class StyledContainerBase extends ContainerBase {
+}
+StyledContainerBase.prototype.styled = true;
+// Closed type for direct usage
+export class StyledContainer extends StyledContainerBase {
+}

package/build/ui/ContentResolver.d.ts

@@ -0,0 +1,51 @@
+import { PureContainerBase, PureContainerConfig } from "./PureContainer";
+import { RenderingContext } from "./RenderingContext";
+import { BooleanProp, StructuredProp, ResolveStructuredProp } from "./Prop";
+import { Instance } from "./Instance";
+/**
+ * Configuration for ContentResolver widget.
+ *
+ * The params type parameter enables type inference for the onResolve callback:
+ * - Literal values (numbers, strings, booleans) preserve their types
+ * - AccessorChain<T> resolves to T
+ * - Bind/Tpl/Expr resolve to any (type cannot be determined at compile time)
+ *
+ * @example
+ * ```typescript
+ * <ContentResolver
+ *    params={{
+ *       count: 42,           // number
+ *       name: model.user.name // AccessorChain<string> -> string
+ *    }}
+ *    onResolve={(params) => {
+ *       // params.count is number, params.name is string
+ *    }}
+ * />
+ * ```
+ */
+export interface ContentResolverConfig<P extends StructuredProp = StructuredProp> extends PureContainerConfig {
+    /** Parameters that trigger content resolution when changed. */
+    params?: P;
+    /**
+     * Callback function that resolves content based on params. Can return content directly or a Promise.
+     * The params type is inferred from the params property - literal values and AccessorChain<T>
+     * preserve their types, while bindings (bind/tpl/expr) resolve to `any`.
+     */
+    onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
+    /** How to combine resolved content with initial content. Default is 'replace'. */
+    mode?: "replace" | "prepend" | "append";
+    /** Indicates if content is being loaded. */
+    loading?: BooleanProp;
+}
+export declare class ContentResolver<P extends StructuredProp = StructuredProp> extends PureContainerBase<ContentResolverConfig<P>> {
+    constructor(config?: ContentResolverConfig<P>);
+    mode: "replace" | "prepend" | "append";
+    onResolve?: string | ((params: ResolveStructuredProp<P>, instance: Instance) => any);
+    initialItems: any;
+    declareData(...args: any[]): void;
+    init(): void;
+    initInstance(context: RenderingContext, instance: any): void;
+    prepareData(context: RenderingContext, instance: any): void;
+    setContent(instance: any, content: any): void;
+    explore(context: RenderingContext, instance: any): void;
+}

package/build/ui/ContentResolver.js

@@ -0,0 +1,71 @@
+import { PureContainerBase } from "./PureContainer";
+import { isPromise } from "../util/isPromise";
+export class ContentResolver extends PureContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            params: { structured: true },
+            loading: undefined,
+        });
+    }
+    init() {
+        super.init();
+        this.initialItems = this.layout ? this.layout.items : this.items;
+        this.clear();
+    }
+    initInstance(context, instance) {
+        instance.content = this.initialItems;
+        instance.cachedParams = {}; //unique value which will never pass the equality check
+    }
+    prepareData(context, instance) {
+        let { data } = instance;
+        if (data.params !== instance.cachedParams && this.onResolve) {
+            instance.cachedParams = data.params;
+            let content = instance.invoke("onResolve", data.params, instance);
+            if (isPromise(content)) {
+                instance.set("loading", true);
+                this.setContent(instance, null);
+                content.then((cnt) => {
+                    this.setContent(instance, cnt);
+                    instance.setState({ cacheBuster: {} });
+                    instance.set("loading", false);
+                });
+            }
+            else
+                this.setContent(instance, content);
+        }
+    }
+    setContent(instance, content) {
+        if (content) {
+            this.clear();
+            switch (this.mode) {
+                case "prepend":
+                    this.add(content);
+                    this.add(this.initialItems);
+                    break;
+                case "append":
+                    this.add(this.initialItems);
+                    this.add(content);
+                    break;
+                case "replace":
+                    this.add(content);
+                    break;
+            }
+            instance.content = this.layout ? this.layout.items : this.items;
+            this.clear();
+        }
+        else
+            instance.content = this.initialItems;
+    }
+    explore(context, instance) {
+        //a little bit hacky
+        if (this.layout)
+            this.layout.items = instance.content;
+        else
+            this.items = instance.content;
+        super.explore(context, instance);
+    }
+}
+ContentResolver.prototype.mode = "replace";

package/build/ui/Controller.d.ts

@@ -0,0 +1,64 @@
+import { ComputableSelector, InferSelectorValue } from "../data/computable";
+import { Component } from "../util/Component";
+import { RenderingContext } from "./RenderingContext";
+import { View, ViewMethods } from "../data/View";
+import { Widget } from "./Widget";
+import { Instance } from "./Instance";
+interface ComputableEntry {
+    name: string;
+    selector: any;
+    type: "computable" | "trigger";
+}
+export interface ControllerMethods {
+    store: View;
+    instance: Instance;
+    widget?: Widget;
+    invokeParentMethod(method: string, ...args: any[]): any;
+    addTrigger<Selectors extends readonly ComputableSelector[]>(name: string, args: [...Selectors], callback: (...values: {
+        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
+    }) => any, autoRun?: boolean): void;
+    addComputable<Selectors extends readonly ComputableSelector[]>(name: string, args: [...Selectors], callback: (...values: {
+        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
+    }) => any): void;
+}
+export interface BaseControllerConfig {
+    store?: View;
+    instance?: Instance;
+    widget?: Widget;
+    onInit?: (context: RenderingContext) => void;
+    onExplore?: (context: RenderingContext) => void;
+    onPrepare?: (context: RenderingContext) => void;
+    onCleanup?: (context: RenderingContext) => void;
+    onDestroy?: () => void;
+}
+export type ControllerConfig<T extends BaseControllerConfig = BaseControllerConfig> = T & ThisType<ControllerMethods & T>;
+/** Controller factory function type */
+export type ControllerFactory<T extends BaseControllerConfig = BaseControllerConfig> = (config: ViewMethods) => ControllerConfig<T>;
+export declare class Controller extends Component implements ControllerMethods {
+    initialized?: boolean;
+    onInit?(context: RenderingContext): void;
+    onExplore?(context: RenderingContext): void;
+    onPrepare?(context: RenderingContext): void;
+    onCleanup?(context: RenderingContext): void;
+    onDestroy?(): void;
+    instance: Instance;
+    store: View;
+    widget?: Widget;
+    computables?: Record<string, ComputableEntry>;
+    constructor(config?: BaseControllerConfig);
+    init(context?: RenderingContext): void;
+    explore(context: RenderingContext): void;
+    prepare(context: RenderingContext): void;
+    cleanup(context: RenderingContext): void;
+    addComputable<Selectors extends readonly ComputableSelector[]>(name: string, args: [...Selectors], callback: (...values: {
+        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
+    }) => any): void;
+    addTrigger<Selectors extends readonly ComputableSelector[]>(name: string, args: [...Selectors], callback: (...values: {
+        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
+    }) => any, autoRun?: boolean): void;
+    removeTrigger(name: string): void;
+    removeComputable(name: string): void;
+    invokeParentMethod(methodName: string, ...args: any[]): any;
+    invokeMethod(methodName: string, ...args: any[]): any;
+}
+export {};