cx 26.0.1 → 26.0.3

package/build/ui/HoverSync.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+/*
+   HoverSync transfers through the context methods for reporting and subscribing to hover data to
+   its descendants. How this should work is that each component can subscribe and unsubscribe
+   to a hover channel and receive info about hover changes.
+   Also, each component should report mouse enter/leave events.
+   Similar to controllers, hover sync should transcend into child contexts.
+*/
+import { dummyCallback } from "../util/dummyCallback";
+import { parseStyle } from "../util/parseStyle";
+import { SubscriberList } from "../util/SubscriberList";
+import { StyledContainerBase } from "./Container";
+import { PureContainerBase } from "./PureContainer";
+import { VDOM } from "./VDOM";
+export class HoverSync extends PureContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    initInstance(context, instance) {
+        let channels = {};
+        instance.hoverSync = {
+            report: (channel, hoverId, active) => {
+                let ch = channels[channel];
+                if (!ch)
+                    return;
+                let state = active && hoverId != null;
+                if (ch.state !== state && (ch.state === hoverId || active)) {
+                    ch.state = state;
+                    ch.subscribers.notify(state);
+                }
+            },
+            subscribe: (channel, callback) => {
+                let ch = channels[channel];
+                if (!ch)
+                    ch = channels[channel] = {
+                        subscribers: new SubscriberList(),
+                        state: false,
+                    };
+                return ch.subscribers.subscribe(callback);
+            },
+        };
+    }
+    explore(context, instance) {
+        context.push("hoverSync", instance.hoverSync);
+        super.explore(context, instance);
+    }
+    exploreCleanup(context, instance) {
+        context.pop("hoverSync");
+    }
+}
+class HoverSyncChild extends VDOM.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hover: false };
+        this.onMouseMove = this.onMouseMove.bind(this);
+        this.onMouseLeave = this.onMouseLeave.bind(this);
+    }
+    onMouseMove() {
+        this.props.hoverSync.report(this.props.hoverChannel, this.props.hoverId, true);
+    }
+    onMouseLeave() {
+        this.props.hoverSync.report(this.props.hoverChannel, this.props.hoverId, false);
+    }
+    componentWillUnmount() {
+        this.unsubscribe();
+    }
+    componentDidMount() {
+        this.unsubscribe = this.props.hoverSync.subscribe(this.props.hoverChannel, (hoverId) => {
+            let hover = hoverId === this.props.hoverId;
+            if (hover !== this.state.hover)
+                this.setState({ hover });
+        });
+    }
+    render() {
+        return this.props.render({
+            hover: this.state.hover,
+            onMouseLeave: this.onMouseLeave,
+            onMouseMove: this.onMouseMove,
+            key: "child",
+        });
+    }
+}
+export function withHoverSync(key, hoverSync, hoverChannel, hoverId, render) {
+    if (!hoverSync || !hoverChannel || hoverId == null)
+        return render({ key, hover: false, onMouseLeave: dummyCallback, onMouseMove: dummyCallback });
+    return (_jsx(HoverSyncChild, { hoverSync: hoverSync, hoverChannel: hoverChannel, hoverId: hoverId, render: render }, key));
+}
+export class HoverSyncElement extends StyledContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            hoverId: undefined,
+            hoverClass: { structured: true },
+            hoverStyle: { structured: true },
+        });
+    }
+    prepareData(context, instance) {
+        instance.hoverSync = context.hoverSync;
+        instance.inSvg = !!context.inSvg;
+        let { data } = instance;
+        data.hoverStyle = parseStyle(data.hoverStyle);
+        super.prepareData(context, instance);
+    }
+    render(context, instance, key) {
+        let { data, inSvg } = instance;
+        let { CSS } = this;
+        let children = this.renderChildren(context, instance);
+        let eventHandlers = instance.getJsxEventProps();
+        return withHoverSync(key, instance.hoverSync, this.hoverChannel, data.hoverId, ({ hover, onMouseMove, onMouseLeave, key }) => {
+            let style = {
+                ...data.style,
+                ...(hover && data.hoverStyle),
+            };
+            return VDOM.createElement(inSvg ? "g" : "div", {
+                key,
+                className: CSS.expand(data.classNames, CSS.state({ hover }), hover && data.hoverClass),
+                style,
+                ...eventHandlers,
+                onMouseLeave,
+                onMouseMove,
+            }, children);
+        });
+    }
+}
+HoverSyncElement.prototype.baseClass = "hoversyncelement";
+HoverSyncElement.prototype.hoverChannel = "default";

package/build/ui/Instance.d.ts

@@ -0,0 +1,219 @@
+import { Controller } from "./Controller";
+import { RenderingContext } from "./RenderingContext";
+import type { Widget } from "./Widget";
+import { View } from "../data/View";
+/**
+ * Serializable value types that can be safely passed through the framework
+ */
+export type SerializableValue = string | number | boolean | object | null | undefined;
+/**
+ * Core instance data structure used by widgets
+ *
+ * For custom widget data, extend this interface:
+ * @example
+ * interface MyWidgetData extends WidgetData {
+ *    customProp: string;
+ * }
+ */
+export interface WidgetData {
+    visible?: boolean;
+    disabled?: boolean;
+    enabled?: boolean;
+    text?: string;
+    innerHtml?: string;
+    attrs?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    classNames?: string;
+    className?: string;
+    class?: string;
+    style?: Record<string, string | number> | string;
+    stateMods?: Record<string, boolean | undefined>;
+    mod?: Record<string, boolean | undefined>;
+    pressed?: boolean;
+    icon?: string | boolean;
+    confirm?: string | ConfirmConfig;
+    parentDisabled?: boolean;
+    parentStrict?: boolean;
+    error?: string;
+}
+/**
+ * Confirmation dialog configuration
+ */
+export interface ConfirmConfig {
+    message: string;
+    title?: string;
+    yesText?: string;
+    noText?: string;
+}
+/**
+ * Parent options passed down from overlay/modal components
+ *
+ * For custom parent options, extend this interface:
+ * @example
+ * interface MyParentOptions extends ParentOptions {
+ *    customOption: string;
+ * }
+ */
+export interface ParentOptions {
+    dismiss?: () => void;
+}
+/**
+ * Props object used for rendering (passed to React.createElement)
+ */
+export type RenderProps = Record<string, any>;
+/**
+ * Result type for yes/no dialogs
+ */
+export declare const enum YesNoResult {
+    Yes = "yes",
+    No = "no"
+}
+/**
+ * Partial instance-like object used in some render methods
+ * This is a hack to allow passing only the data property instead of full Instance
+ */
+export interface PartialInstance {
+    data: Record<string, any>;
+    widget?: Widget;
+    state?: Record<string, any>;
+}
+/**
+ * Example widget-specific properties for dropdown widgets
+ */
+export interface DropdownWidgetProps {
+    lastDropdown?: Instance;
+    dropdownOpen?: boolean;
+    selectedIndex?: number;
+}
+/**
+ * Example widget-specific properties for form field widgets
+ */
+export interface FieldWidgetProps {
+    inputElement?: HTMLInputElement;
+    validationState?: "valid" | "invalid" | "pending";
+}
+/**
+ * Type aliases for common widget instance types using intersection types
+ */
+export type DropdownInstance = Instance & DropdownWidgetProps;
+export type FieldInstance = Instance & FieldWidgetProps;
+/**
+ * Base Instance class
+ */
+export declare class Instance<WidgetType extends Widget<any, any> = Widget<any, any>> {
+    widget: WidgetType;
+    key: string;
+    id: string;
+    parent?: Instance;
+    parentStore: View;
+    store: View;
+    controller?: Controller;
+    data: Record<string, any>;
+    rawData: Record<string, any>;
+    state?: Record<string, any>;
+    cached: Record<string, any>;
+    cacheList?: Record<string, any> | null;
+    dataSelector?: (store: any) => Record<string, any>;
+    initialized?: boolean;
+    visible?: boolean;
+    explored?: boolean;
+    prepared?: boolean;
+    shouldUpdate?: boolean;
+    childStateDirty?: boolean;
+    detached?: boolean;
+    needsExploreCleanup?: boolean;
+    needsPrepare?: boolean;
+    needsCleanup?: boolean;
+    destroyTracked?: boolean;
+    destroySubscriptions?: Array<() => void> | null;
+    instanceCache?: InstanceCache | null;
+    children?: Instance[];
+    helpers?: Record<string, Instance>;
+    components?: Record<string, Instance>;
+    vdom?: any;
+    contentVDOM?: any;
+    renderList?: any;
+    assignedRenderList?: any;
+    outerLayout?: Instance;
+    contentPlaceholder?: any;
+    parentOptions?: any;
+    setters?: Record<string, any>;
+    record?: any;
+    mappedRecords?: any[];
+    instances?: Instance[];
+    selected?: boolean;
+    constructor(widget: WidgetType, key: string, parent?: Instance, parentStore?: any);
+    setParentStore(parentStore: any): void;
+    init(context: RenderingContext): void;
+    checkVisible(context: RenderingContext): boolean;
+    scheduleExploreIfVisible(context: RenderingContext): boolean;
+    cache(key: string, value: any): boolean;
+    markShouldUpdate(context: RenderingContext): void;
+    explore(context: RenderingContext): void;
+    prepare(context: RenderingContext): void;
+    render(context: RenderingContext): null | Record<string, React.ReactNode> | React.ReactNode[];
+    cleanup(context: RenderingContext): void;
+    private trackDestroy;
+    private trackDestroyableChild;
+    subscribeOnDestroy(callback: () => void): () => void;
+    destroy(): void;
+    setState(state: Record<string, any>): void;
+    set(prop: string, value: any, options?: {
+        internal?: boolean;
+        immediate?: boolean;
+    }): boolean;
+    definePropertySetter(prop: string, setter: any): void;
+    protected doSet(prop: string, value: any): boolean;
+    nestedDataSet(key: string, value: any, dataConfig: Record<string, any>, useParentStore?: boolean): boolean;
+    replaceState(state: Record<string, any>): void;
+    getInstanceCache(): InstanceCache;
+    clearChildrenCache(): void;
+    getChild(context: RenderingContext | null, widget: Widget, key?: string | number | null, store?: any): Instance;
+    getDetachedChild(widget: Widget, key: string, store?: any): Instance;
+    prepareRenderCleanupChild(widget: any, store?: any, keyPrefix?: string, options?: any): any;
+    getJsxEventProps(): Record<string, any> | null;
+    getCallback(methodName: string): (...args: any[]) => any;
+    /**
+     * Finds the first controller in the instance tree matching the predicate
+     * @param predicate Function to test each controller
+     * @returns The matching controller or undefined
+     */
+    findController(predicate: (controller: Controller) => boolean): Controller | undefined;
+    /**
+     * Finds a controller of the specified type in the instance tree
+     * @param type Controller class/constructor to find
+     * @returns The matching controller cast to the specified type, or undefined
+     */
+    findControllerByType<T extends Controller>(type: new (...args: any[]) => T): T | undefined;
+    /**
+     * Gets the first controller in the instance tree matching the predicate
+     * @param predicate Function to test each controller
+     * @returns The matching controller
+     * @throws Error if no matching controller is found
+     */
+    getController(predicate: (controller: Controller) => boolean): Controller;
+    /**
+     * Gets a controller of the specified type in the instance tree
+     * @param type Controller class/constructor to find
+     * @returns The matching controller cast to the specified type
+     * @throws Error if no controller of the specified type is found
+     */
+    getControllerByType<T extends Controller>(type: new (...args: any[]) => T): T;
+    getControllerMethod(methodName: string): (...args: any[]) => any;
+    invoke(methodName: string, ...args: any[]): any;
+    invokeControllerMethod(methodName: string, ...args: any[]): any;
+}
+export declare class InstanceCache {
+    children: Record<string, Instance>;
+    parent: Instance;
+    marked: Record<string, Instance>;
+    monitored: Record<string, Instance> | null;
+    keyPrefix: string;
+    constructor(parent: Instance, keyPrefix?: string | number | null);
+    getChild(widget: Widget, parentStore: any, key?: string | number | null): Instance;
+    addChild(instance: Instance): void;
+    mark(): void;
+    trackDestroy(instance: Instance): void;
+    destroy(): void;
+    sweep(): void;
+}