cx 26.0.1 → 26.0.2

package/build/widgets/DocumentTitle.js

@@ -0,0 +1,57 @@
+import { Widget } from "../ui/Widget";
+export class DocumentTitle extends Widget {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        if (this.value)
+            this.text = this.value;
+        if (this.append)
+            this.action = "append";
+        super.init();
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            value: undefined,
+            text: undefined,
+            action: undefined,
+            separator: undefined,
+        });
+    }
+    explore(context, instance) {
+        if (!context.documentTitle) {
+            context.documentTitle = {
+                activeInstance: instance,
+                title: "",
+            };
+        }
+        let { data } = instance;
+        if (data.text) {
+            switch (data.action) {
+                case "append":
+                    if (context.documentTitle.title)
+                        context.documentTitle.title += data.separator;
+                    context.documentTitle.title += data.text;
+                    break;
+                case "prepend":
+                    context.documentTitle.title = data.text + data.separator + context.documentTitle.title;
+                    break;
+                default:
+                case "replace":
+                    context.documentTitle.title = data.text;
+                    break;
+            }
+        }
+        super.explore(context, instance);
+    }
+    prepare(context, instance) {
+        if (context.documentTitle.activeInstance == instance)
+            document.title = context.documentTitle.title;
+    }
+    render() {
+        return null;
+    }
+}
+DocumentTitle.prototype.action = "append";
+DocumentTitle.prototype.separator = "";
+Widget.alias("document-title", DocumentTitle);

package/build/widgets/FlexBox.d.ts

@@ -0,0 +1,79 @@
+import { ContainerBase, StyledContainerConfig } from "../ui/Container";
+import { RenderingContext } from "../ui/RenderingContext";
+import { Instance } from "../ui/Instance";
+export interface FlexBoxConfig extends StyledContainerConfig {
+    /** Base CSS class. Default is `flexbox`. */
+    baseClass?: string;
+    /** Flex direction. Default is `row`.  */
+    direction?: string;
+    /**
+     * Add spacing between items by applying a margin to children.
+     * Allowed values are `xsmall`, `small`, `medium`, `large` and `xlarge`.
+     * Value `true` is equivalent to `medium`.
+     */
+    spacing?: string | boolean;
+    /**
+     * Add horizontal spacing between items by applying a margin to children.
+     * Allowed values are `xsmall`, `small`, `medium`, `large` and `xlarge`.
+     * Value `true` is equivalent to `medium`.
+     */
+    hspacing?: boolean | string;
+    /**
+     * Add vertical spacing between items by applying a margin to children.
+     * Allowed values are xsmall, small, medium, large and xlarge.
+     * Value true is equivalent to medium.
+     */
+    vspacing?: boolean | string;
+    /**
+     * Add padding to the box. Allowed values are `xsmall`, `small`, `medium`, `large` and `xlarge`.
+     *  Value `true` is equivalent to `medium`.
+     */
+    pad?: boolean | string;
+    padding?: boolean | string;
+    /**
+     * Add horizontal padding to the box. Allowed values are `xsmall`, `small`, `medium`, `large` and `xlarge`.
+     *  Value `true` is equivalent to `medium`.
+     */
+    hpad?: boolean | string;
+    hpadding?: boolean | string;
+    /**
+     * Add vertical padding to the box. Allowed values are `xsmall`, `small`, `medium`, `large` and `xlarge`.
+     *  Value `true` is equivalent to `medium`.
+     */
+    vpad?: boolean | string;
+    vpadding?: boolean | string;
+    wrap?: boolean;
+    align?: "start" | "center" | "end" | "baseline" | "stretch" | false;
+    justify?: "start" | "center" | "end" | "space-between" | "space-around" | "space-evenly" | false;
+    target?: string;
+    /**
+     * Set to true to add overflow styles required for deeply nested flexbox calculations.
+     */
+    nested?: boolean;
+}
+export declare class FlexBox extends ContainerBase<FlexBoxConfig, Instance> {
+    padding?: boolean | string;
+    hpadding?: boolean | string;
+    vpadding?: boolean | string;
+    spacing?: string | boolean;
+    hspacing?: boolean | string;
+    vspacing?: boolean | string;
+    pad?: boolean | string;
+    hpad?: boolean | string;
+    vpad?: boolean | string;
+    wrap?: boolean;
+    align?: "start" | "center" | "end" | "baseline" | "stretch" | false;
+    justify?: "start" | "center" | "end" | "space-between" | "space-around" | "space-evenly" | false;
+    target?: string;
+    nested?: boolean;
+    direction?: string;
+    constructor(config?: FlexBoxConfig);
+    init(): void;
+    initInstance(context: RenderingContext, instance: Instance): void;
+    prepareCSS(context: RenderingContext, instance: Instance): void;
+    render(context: RenderingContext, instance: Instance, key: string): React.ReactNode;
+}
+export declare class FlexRow extends FlexBox {
+}
+export declare class FlexCol extends FlexBox {
+}

package/build/widgets/FlexBox.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ContainerBase } from "../ui/Container";
+import { isUndefined } from "../util/isUndefined";
+export class FlexBox extends ContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        if (this.padding)
+            this.pad = this.padding;
+        if (this.hpadding)
+            this.hpad = this.hpadding;
+        if (this.vpadding)
+            this.vpad = this.vpadding;
+        this.hpad = isUndefined(this.hpad) ? this.pad : this.hpad;
+        this.vpad = isUndefined(this.vpad) ? this.pad : this.hpad;
+        if (this.hpad === true)
+            this.hpad = "medium";
+        if (this.vpad === true)
+            this.vpad = "medium";
+        this.hspacing = isUndefined(this.hspacing) ? this.spacing : this.hspacing;
+        this.vspacing = isUndefined(this.vspacing) ? this.spacing : this.vspacing;
+        if (this.hspacing === true)
+            this.hspacing = "medium";
+        if (this.vspacing === true)
+            this.vspacing = "medium";
+        super.init();
+    }
+    initInstance(context, instance) {
+        instance.eventHandlers = instance.getJsxEventProps();
+        super.initInstance(context, instance);
+    }
+    prepareCSS(context, instance) {
+        let { data } = instance;
+        data.stateMods = {
+            ...data.stateMods,
+            [this.hpad + "-hpad"]: this.hpad,
+            [this.vpad + "-vpad"]: this.vpad,
+            nested: this.nested,
+        };
+        super.prepareCSS(context, instance);
+    }
+    render(context, instance, key) {
+        let { data } = instance;
+        let eventHandlers = instance.eventHandlers;
+        let { CSS, baseClass } = this;
+        let flexboxMods = {
+            [this.hspacing + "-hspacing"]: this.hspacing,
+            [this.vspacing + "-vspacing"]: this.vspacing,
+            ["align-" + this.align]: this.align,
+            ["justify-" + this.justify]: this.justify,
+            wrap: this.wrap,
+            ["target-" + this.target]: true,
+            [this.direction]: true,
+        };
+        return (_jsx("div", { className: data.classNames, style: data.style, ...eventHandlers, children: _jsx("div", { className: CSS.element(baseClass, "flexbox", flexboxMods), children: this.renderChildren(context, instance) }) }, key));
+    }
+}
+FlexBox.prototype.baseClass = "flexbox";
+FlexBox.prototype.styled = true;
+FlexBox.prototype.direction = 'row';
+FlexBox.prototype.spacing = false;
+FlexBox.prototype.hspacing = undefined;
+FlexBox.prototype.vspacing = undefined;
+FlexBox.prototype.pad = false;
+FlexBox.prototype.hpad = undefined;
+FlexBox.prototype.vpad = undefined;
+FlexBox.prototype.wrap = false;
+FlexBox.prototype.align = false;
+FlexBox.prototype.justify = false;
+FlexBox.prototype.target = 'any';
+FlexBox.prototype.nested = false;
+export class FlexRow extends FlexBox {
+}
+export class FlexCol extends FlexBox {
+}
+FlexCol.prototype.direction = 'column';

package/build/widgets/Heading.d.ts

@@ -0,0 +1,16 @@
+import { HtmlElement, HtmlElementConfig, HtmlElementInstance } from "./HtmlElement";
+import { RenderingContext } from "../ui/RenderingContext";
+export interface HeadingConfig extends HtmlElementConfig {
+    /** Name of the HTML element to be rendered. Default is `div`. */
+    tag?: string;
+    /** Heading level. Allowed values go from 1 to 6. Default is 3. */
+    level?: number | string;
+    /** Base CSS class. Default is `heading`. */
+    baseClass?: string;
+}
+export declare class Heading extends HtmlElement<HeadingConfig, HtmlElementInstance> {
+    level?: number | string;
+    init(): void;
+    prepareData(context: RenderingContext, instance: HtmlElementInstance): void;
+    isValidHtmlAttribute(attrName: string): string | false;
+}

package/build/widgets/Heading.js

@@ -0,0 +1,24 @@
+import { HtmlElement } from "./HtmlElement";
+export class Heading extends HtmlElement {
+    init() {
+        this.tag = `h${this.level}`;
+        super.init();
+    }
+    prepareData(context, instance) {
+        let { data } = instance;
+        data.stateMods = {
+            ...data.stateMods,
+            [`level-${this.level}`]: true,
+        };
+        super.prepareData(context, instance);
+    }
+    isValidHtmlAttribute(attrName) {
+        switch (attrName) {
+            case "level":
+                return false;
+            default: return super.isValidHtmlAttribute(attrName);
+        }
+    }
+}
+Heading.prototype.level = 3;
+Heading.prototype.baseClass = "heading";

package/build/widgets/HighlightedSearchText.d.ts

@@ -0,0 +1,18 @@
+/** @jsxImportSource react */
+import { Instance } from "../ui/Instance";
+import type { RenderingContext } from "../ui/RenderingContext";
+import { Widget, WidgetConfig } from "../ui/Widget";
+import { StringProp, Prop } from "../ui/Prop";
+export interface HighlightedSearchTextConfig extends WidgetConfig {
+    /** Search query used to highlight matching text. */
+    query?: StringProp;
+    /** Text content to be searched and highlighted. */
+    text?: StringProp;
+    /** Pre-computed text chunks where odd-indexed chunks are highlighted. */
+    chunks?: Prop<string[]>;
+}
+export declare class HighlightedSearchText extends Widget<HighlightedSearchTextConfig> {
+    constructor(config?: HighlightedSearchTextConfig);
+    declareData(...args: Record<string, unknown>[]): void;
+    render(context: RenderingContext, instance: Instance, key: string): React.ReactNode;
+}

package/build/widgets/HighlightedSearchText.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Widget } from "../ui/Widget";
+import { getSearchQueryHighlighter } from "../util/getSearchQueryPredicate";
+export class HighlightedSearchText extends Widget {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            text: undefined,
+            chunks: undefined,
+            query: undefined,
+        });
+    }
+    render(context, instance, key) {
+        let { data } = instance;
+        let { text, chunks, query, classNames, style } = data;
+        if (!chunks && text && query) {
+            let highlighter = getSearchQueryHighlighter(query, { cache: true });
+            chunks = highlighter(text);
+        }
+        if (!chunks)
+            return text;
+        return chunks.map((text, i) => {
+            if (i % 2 == 0)
+                return text;
+            return (_jsx("span", { className: classNames, style: style, children: text }, `${key}-${i}`));
+        });
+    }
+}
+HighlightedSearchText.prototype.styled = true;
+HighlightedSearchText.prototype.baseClass = "highlightedsearchtext";

package/build/widgets/HtmlElement.d.ts

@@ -0,0 +1,46 @@
+/** @jsxImportSource react */
+import { ContainerBase, StyledContainerConfig } from "../ui/Container";
+import { TooltipParentInstance } from "./overlay/tooltip-ops";
+import type { TooltipInstance } from "./overlay/Tooltip";
+import type { RenderingContext } from "../ui/RenderingContext";
+import type { RenderProps } from "../ui/Instance";
+import { Instance } from "../ui/Instance";
+import type { TooltipConfig, TooltipProp } from "./overlay/tooltip-ops";
+import { StringProp, NumberProp } from "../ui/Prop";
+export declare let urlAttributes: Record<string, boolean>;
+export interface HtmlElementConfig extends StyledContainerConfig {
+    id?: StringProp | NumberProp;
+    /** Inner text contents. */
+    text?: StringProp | NumberProp;
+    /** Tooltip configuration. */
+    tooltip?: StringProp | TooltipConfig;
+}
+export declare class HtmlElementInstance<E extends HtmlElement<any, any> = HtmlElement<any, any>> extends Instance<E> implements TooltipParentInstance {
+    events?: Record<string, (e: React.SyntheticEvent, instance: Instance) => any>;
+    tooltips: {
+        [key: string]: TooltipInstance;
+    };
+}
+export declare class HtmlElement<Config extends HtmlElementConfig = HtmlElementConfig, InstanceType extends HtmlElementInstance<any> = HtmlElementInstance<any>> extends ContainerBase<Config, InstanceType> {
+    tag?: string;
+    html?: string;
+    innerText?: string;
+    text?: string;
+    innerHtml?: string;
+    attrs?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    events?: Record<string, (e: Event, instance: Instance) => unknown>;
+    urlAttributes?: string[];
+    extraProps?: Record<string, unknown>;
+    tooltip?: TooltipProp;
+    onRef?: (element: HTMLElement | null, instance: Instance) => void;
+    autoFocus?: boolean | string;
+    [key: string]: unknown;
+    constructor(config?: Config);
+    declareData(...args: Record<string, unknown>[]): void;
+    isValidHtmlAttribute(attrName: string): string | false;
+    init(): void;
+    prepareData(context: RenderingContext, instance: InstanceType): void;
+    attachProps(context: RenderingContext, instance: InstanceType, props: RenderProps): void;
+    render(context: RenderingContext, instance: InstanceType, key: string): React.ReactNode;
+}

package/build/widgets/HtmlElement.js

@@ -0,0 +1,253 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+import { Widget, VDOM } from "../ui/Widget";
+import { ContainerBase } from "../ui/Container";
+import { tooltipMouseMove, tooltipParentWillUnmount, tooltipMouseLeave, tooltipParentWillReceiveProps, tooltipParentDidMount, tooltipParentDidUpdate, } from "./overlay/tooltip-ops";
+import { Url } from "../ui/app/Url";
+import { debug } from "../util/Debug";
+import { isString } from "../util/isString";
+import { isUndefined } from "../util/isUndefined";
+import { isDefined } from "../util/isDefined";
+import { isArray } from "../util/isArray";
+import { autoFocus } from "./autoFocus";
+import { Instance } from "../ui/Instance";
+const isDataAttribute = (attr) => (attr.indexOf("data-") === 0 ? attr.substring(5) : false);
+export let urlAttributes = {
+    "a.href": true,
+    "img.src": true,
+    "iframe.src": true,
+};
+export class HtmlElementInstance extends Instance {
+    events;
+}
+export class HtmlElement extends ContainerBase {
+    constructor(config) {
+        super(config);
+        if (isUndefined(this.jsxAttributes) && config)
+            this.jsxAttributes = Object.keys(config).filter(this.isValidHtmlAttribute.bind(this));
+    }
+    declareData(...args) {
+        const data = {
+            text: undefined,
+            innerHtml: undefined,
+            attrs: {
+                structured: true,
+            },
+            data: {
+                structured: true,
+            },
+            autoFocus: undefined,
+        };
+        let name;
+        this.urlAttributes = [];
+        if (this.jsxAttributes) {
+            this.jsxAttributes.forEach((attr) => {
+                if (urlAttributes[`${this.tag}.${attr}`])
+                    this.urlAttributes.push(attr);
+                if ((name = isDataAttribute(attr))) {
+                    if (!this.data)
+                        this.data = {};
+                    this.data[name] = this[attr];
+                }
+                else if ((name = this.isValidHtmlAttribute(attr)) && !data.hasOwnProperty(name)) {
+                    if (name.indexOf("on") === 0) {
+                        if (this[attr]) {
+                            if (!this.events)
+                                this.events = {};
+                            this.events[name] = this[attr];
+                        }
+                    }
+                    else {
+                        if (!this.attrs)
+                            this.attrs = {};
+                        this.attrs[name] = this[attr];
+                    }
+                }
+            });
+        }
+        if (this.urlAttributes.length === 0)
+            delete this.urlAttributes;
+        // Combine args array with data object for super call
+        super.declareData(...args, data);
+    }
+    isValidHtmlAttribute(attrName) {
+        switch (attrName) {
+            case "tag":
+            case "type":
+            case "$type":
+            case "$props":
+            case "text":
+            case "layout":
+            case "class":
+            case "className":
+            case "style":
+            case "controller":
+            case "outerLayout":
+            case "items":
+            case "children":
+            case "visible":
+            case "if":
+            case "mod":
+            case "putInto":
+            case "contentFor":
+            case "trimWhitespace":
+            case "preserveWhitespace":
+            case "ws":
+            case "plainText":
+            case "vertical":
+            case "memoize":
+            case "onInit":
+            case "onExplore":
+            case "onDestroy":
+            case "onRef":
+            case "html":
+            case "innerText":
+            case "baseClass":
+            case "CSS":
+            case "tooltip":
+            case "styles":
+            case "jsxAttributes":
+            case "jsxSpread":
+            case "instance":
+            case "store":
+            case "autoFocus":
+            case "vdomKey":
+                return false;
+            default:
+                if (isDataAttribute(attrName))
+                    return false;
+                break;
+        }
+        return attrName;
+    }
+    init() {
+        if (this.html)
+            this.innerHtml = this.html;
+        if (this.innerText)
+            this.text = this.innerText;
+        super.init();
+    }
+    prepareData(context, instance) {
+        const { data } = instance;
+        if (this.urlAttributes && data.attrs) {
+            data.attrs = { ...data.attrs };
+            this.urlAttributes.forEach((attr) => {
+                const attrValue = data.attrs[attr];
+                if (isString(attrValue)) {
+                    data.attrs[attr] = Url.resolve(attrValue);
+                }
+            });
+        }
+        super.prepareData(context, instance);
+    }
+    attachProps(context, instance, props) {
+        Object.assign(props, this.extraProps);
+        if (!isString(this.tag))
+            props.instance = instance;
+    }
+    render(context, instance, key) {
+        //rebind events to pass instance
+        if (this.events && !instance.events) {
+            instance.events = {};
+            for (const eventName in this.events) {
+                const handler = this.events[eventName];
+                instance.events[eventName] = (e) => instance.invoke(eventName, e, instance);
+            }
+        }
+        const { data, events } = instance;
+        const props = Object.assign({
+            key: key,
+        }, data.attrs, events);
+        if (data.classNames)
+            props.className = data.classNames;
+        if (data.style)
+            props.style = data.style;
+        let children;
+        if (isDefined(data.text))
+            children = data.text;
+        else if (isString(data.innerHtml)) {
+            props.dangerouslySetInnerHTML = { __html: data.innerHtml };
+        }
+        else {
+            children = this.renderChildren(context, instance);
+            if (children && isArray(children) && children.length === 0)
+                children = undefined;
+        }
+        props.children = children;
+        this.attachProps(context, instance, props);
+        if (this.tooltip || this.onRef || this.autoFocus)
+            return (_jsx(ContainerComponent, { tag: this.tag, props: props, instance: instance, data: data, children: props.children }, key));
+        return VDOM.createElement(this.tag, props, props.children);
+    }
+}
+HtmlElement.prototype.tag = "div";
+HtmlElement.prototype.styled = true;
+class ContainerComponent extends VDOM.Component {
+    el = null;
+    constructor(props) {
+        super(props);
+        this.ref = (c) => {
+            this.el = c;
+            const { instance } = this.props;
+            const widget = instance.widget;
+            if (widget.onRef) {
+                instance.invoke("onRef", c, instance);
+            }
+        };
+    }
+    render() {
+        const { tag, props, children, instance } = this.props;
+        const widget = instance.widget;
+        props.ref = this.ref;
+        if (widget.tooltip) {
+            const { onMouseLeave, onMouseMove } = props;
+            props.onMouseLeave = (e) => {
+                tooltipMouseLeave(e, instance, widget.tooltip);
+                if (onMouseLeave)
+                    onMouseLeave(e);
+            };
+            props.onMouseMove = (e) => {
+                tooltipMouseMove(e, instance, widget.tooltip);
+                if (onMouseMove)
+                    onMouseMove(e);
+            };
+        }
+        return VDOM.createElement(tag, props, children);
+    }
+    componentWillUnmount() {
+        tooltipParentWillUnmount(this.props.instance);
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        const widget = this.props.instance.widget;
+        if (this.el && widget.tooltip) {
+            tooltipParentWillReceiveProps(this.el, props.instance, widget.tooltip);
+        }
+    }
+    componentDidMount() {
+        const widget = this.props.instance.widget;
+        if (this.el && widget.tooltip) {
+            tooltipParentDidMount(this.el, this.props.instance, widget.tooltip);
+        }
+        autoFocus(this.el, this);
+    }
+    componentDidUpdate() {
+        const widget = this.props.instance.widget;
+        if (this.el && widget.tooltip) {
+            tooltipParentDidUpdate(this.el, this.props.instance, widget.tooltip);
+        }
+        autoFocus(this.el, this);
+    }
+}
+const originalWidgetFactory = Widget.factory;
+//support for React components
+Widget.factory = function (type, config, more) {
+    const typeType = typeof type;
+    if (typeType === "undefined") {
+        debug("Creating a widget of unknown type.", config, more);
+        return new HtmlElement(Object.assign({}, config, more));
+    }
+    if (typeType === "function")
+        return HtmlElement.create(HtmlElement, { tag: type }, config);
+    return originalWidgetFactory.call(Widget, type, config, more);
+};
+Widget.alias("html-element", HtmlElement);

package/build/widgets/HtmlElement.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/widgets/HtmlElement.spec.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "cx/jsx-runtime";
+import { Store } from "../data/Store";
+import assert from "assert";
+import { createTestRenderer } from "../util/test/createTestRenderer";
+import { bind } from "../ui/bind";
+describe("HtmlElement", () => {
+    it("renders textual content provided through the text property", () => {
+        let widget = (_jsx("cx", { children: _jsx("div", { text: bind("text") }) }));
+        let store = new Store({
+            data: {
+                text: "Test",
+            },
+        });
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert(tree && !Array.isArray(tree), "Expected single element");
+        assert.equal(tree.type, "div");
+        assert.deepEqual(tree.children, ["Test"]);
+    });
+    it("allows spread bindings", () => {
+        let store = new Store({
+            data: {
+                title: "title",
+            },
+        });
+        const component = createTestRenderer(store, (_jsx("cx", { children: _jsx("a", { href: "#", title: { bind: "title" }, children: "Link" }) })));
+        let tree = component.toJSON();
+        assert(tree && !Array.isArray(tree), "Expected single element");
+        assert.deepEqual(tree, {
+            type: "a",
+            children: ["Link"],
+            props: {
+                href: "#",
+                title: "title",
+            },
+        });
+    });
+});

package/build/widgets/Icon.d.ts

@@ -0,0 +1,29 @@
+import { Widget, WidgetConfig } from "../ui/Widget";
+import "./icons/index";
+import { RenderingContext } from "../ui/RenderingContext";
+import { Instance } from "../ui/Instance";
+import { StringProp, ClassProp, StyleProp } from "../ui/Prop";
+export interface IconConfig extends WidgetConfig {
+    /** Name under which the icon is registered. */
+    name?: StringProp;
+    /** Additional CSS classes to be applied to the field.
+     * If an object is provided, all keys with a "truthy" value will be added to the CSS class list. */
+    className?: ClassProp;
+    /** Additional CSS classes to be applied to the field.
+     * If an object is provided, all keys with a "truthy" value will be added to the CSS class list. */
+    class?: ClassProp;
+    /** Style object applied to the wrapper div. Used for setting the dimensions of the field. */
+    style?: StyleProp;
+    /** Base CSS class to be applied to the element. Default is `icon`. */
+    baseClass?: string;
+}
+export declare class Icon extends Widget<IconConfig> {
+    declareData(...args: Record<string, unknown>[]): void;
+    render(context: RenderingContext, instance: Instance, key: string): React.ReactNode;
+    static register(name: string, icon: any, defaultIcon?: boolean): (props: Record<string, any>) => React.ReactNode;
+    static unregister(...args: string[]): void;
+    static render(name: string, props: Record<string, any>): React.ReactNode;
+    static clear(): void;
+    static registerFactory(factory: (name: string, props: Record<string, any>) => any): void;
+    static restoreDefaultIcons(): void;
+}