@omnia/fx 8.0.264-dev → 8.0.266-dev

package/internal-do-not-import-from-here/ux/floweditor/stores/FlowEditorStore.d.ts

@@ -0,0 +1,370 @@
+import { FlowEditorActionRegistration, FlowEditorPluginSettings } from "@omnia/fx-models";
+import { FlowEditorPlugin, FlowEditorPluginContext } from "../models/EditorPlugin";
+import { FlowContent, NodeSelection } from "../models/EditorModels";
+export declare const useFlowEditorStore: () => {
+    state: {
+        editorContent: FlowContent;
+        plugins: FlowEditorPlugin[];
+        hideToolbar: boolean;
+        editMode: boolean;
+        maxNodeId: number;
+        toolbarActions: FlowEditorActionRegistration[];
+        editor: HTMLDivElement;
+        nodeSelection: NodeSelection;
+        telePorts: JSX.Element[];
+        id: string;
+        pluginContext: FlowEditorPluginContext;
+        selectedRange: Range;
+        showPlaceHolder: boolean;
+    };
+    events: {
+        onMutatedEditorContent: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowContent>;
+        onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorPlugin[]>;
+        onMutatedHideToolbar: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedEditMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedMaxNodeId: import("@omnia/fx").MessageBusExposeOnlySubscription<number>;
+        onMutatedToolbarActions: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorActionRegistration[]>;
+        onMutatedEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<HTMLDivElement>;
+        onMutatedNodeSelection: import("@omnia/fx").MessageBusExposeOnlySubscription<NodeSelection>;
+        onMutatedTelePorts: import("@omnia/fx").MessageBusExposeOnlySubscription<JSX.Element[]>;
+        onMutatedId: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+        onMutatedPluginContext: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorPluginContext>;
+        onMutatedSelectedRange: import("@omnia/fx").MessageBusExposeOnlySubscription<Range>;
+        onMutatedShowPlaceHolder: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching: {
+            plugin: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            content: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            set: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toolbarAction: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            formatting: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            element: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            commands: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            plugin: {
+                subscribe(fn: (result: {
+                    register: {
+                        plugin: (pluginSettings: FlowEditorPluginSettings) => void;
+                        plugins: (pluginSettings: FlowEditorPluginSettings | FlowEditorPluginSettings[]) => Promise<void>;
+                        context: (ctx: FlowEditorPluginContext) => void;
+                    };
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            content: {
+                subscribe(fn: (result: {
+                    sync: () => FlowContent;
+                    set: {
+                        byJSON: (content: FlowContent) => void;
+                        byString: (content: string) => void;
+                    };
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            set: {
+                subscribe(fn: (result: {
+                    mode: (editMode: boolean) => void;
+                    container: (el: HTMLDivElement) => void;
+                    focus: () => void;
+                    placeHolderVisibility: () => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toolbarAction: {
+                subscribe(fn: (result: {
+                    add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            formatting: {
+                subscribe(fn: (result: {
+                    add: (element: HTMLElement) => void;
+                    toggle: (element: HTMLElement) => void;
+                    remove: (dataType: string) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            element: {
+                subscribe(fn: (result: {
+                    createForComponent: (componentName: string) => HTMLDivElement;
+                    createText: () => HTMLParagraphElement;
+                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                    createTextNode: (data: any) => Text;
+                    add: (element: HTMLElement) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            commands: {
+                subscribe(fn: (result: {
+                    exec: (command: string, data: object) => void;
+                    builtIn: {
+                        content: {
+                            convert: (element: HTMLElement) => void;
+                        };
+                        ensure: {
+                            lastElement: () => void;
+                            unique: {
+                                ids: (element: HTMLElement) => void;
+                            };
+                        };
+                        selection: {
+                            get: {
+                                byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                            };
+                        };
+                        cursor: {
+                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                        };
+                        actions: {
+                            setSelection: () => void;
+                        };
+                        formatting: {
+                            add: (element: HTMLElement) => void;
+                            remove: (dataType: string | HTMLElement) => void;
+                            has: (dataType: string | HTMLElement) => boolean;
+                        };
+                        element: {
+                            clean: (element: HTMLElement) => void;
+                            add: (element: HTMLElement) => void;
+                            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                            createText: () => HTMLParagraphElement;
+                            createTextNode: (data: any) => Text;
+                            createComponent: (componentName: string) => HTMLDivElement;
+                            insert: {
+                                text: (element: Node, text: string, offset: any) => void;
+                            };
+                            ids: {
+                                unique: (element: HTMLElement) => void;
+                            };
+                        };
+                        helpers: {
+                            editor: {
+                                ensure: {
+                                    uniqueIds: (element: HTMLElement, state: {
+                                        maxNodeId: number;
+                                    }) => HTMLElement;
+                                    selectionIsInEditor: (range: Range) => void;
+                                };
+                                cursor: {
+                                    storePosition: (state: {
+                                        selectedRange: Range;
+                                    }) => void;
+                                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                                };
+                            };
+                            editorNode: {
+                                get: {
+                                    nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                                };
+                            };
+                            htmlNode: {
+                                copy: {
+                                    children: (from: HTMLElement, to: HTMLElement) => void;
+                                };
+                                insert: {
+                                    text: (element: Node, text: string, offset: any) => void;
+                                    elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                                };
+                                get: {
+                                    topContainerForContent: (element: HTMLElement) => HTMLElement;
+                                    nodeSelectionForRange: (range: Range) => NodeSelection;
+                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                };
+                                remove: {
+                                    nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                                };
+                                strip: {
+                                    after: (element: HTMLElement, splitter: string) => void;
+                                    before: (element: HTMLElement, splitter: string) => void;
+                                };
+                                surround: {
+                                    selectionWithElement: (element: HTMLElement, range: Range) => void;
+                                };
+                            };
+                        };
+                    };
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            plugin: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            content: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            set: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            toolbarAction: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            formatting: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            element: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            commands: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        plugin: () => {
+            register: {
+                plugin: (pluginSettings: FlowEditorPluginSettings) => void;
+                plugins: (pluginSettings: FlowEditorPluginSettings | FlowEditorPluginSettings[]) => Promise<void>;
+                context: (ctx: FlowEditorPluginContext) => void;
+            };
+        };
+        content: () => {
+            sync: () => FlowContent;
+            set: {
+                byJSON: (content: FlowContent) => void;
+                byString: (content: string) => void;
+            };
+        };
+        set: () => {
+            mode: (editMode: boolean) => void;
+            container: (el: HTMLDivElement) => void;
+            focus: () => void;
+            placeHolderVisibility: () => void;
+        };
+        toolbarAction: () => {
+            add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
+        };
+        formatting: () => {
+            add: (element: HTMLElement) => void;
+            toggle: (element: HTMLElement) => void;
+            remove: (dataType: string) => void;
+        };
+        element: () => {
+            createForComponent: (componentName: string) => HTMLDivElement;
+            createText: () => HTMLParagraphElement;
+            create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+            createTextNode: (data: any) => Text;
+            add: (element: HTMLElement) => void;
+        };
+        commands: () => {
+            exec: (command: string, data: object) => void;
+            builtIn: {
+                content: {
+                    convert: (element: HTMLElement) => void;
+                };
+                ensure: {
+                    lastElement: () => void;
+                    unique: {
+                        ids: (element: HTMLElement) => void;
+                    };
+                };
+                selection: {
+                    get: {
+                        byPluginType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+                    };
+                };
+                cursor: {
+                    isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                    isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                };
+                actions: {
+                    setSelection: () => void;
+                };
+                formatting: {
+                    add: (element: HTMLElement) => void;
+                    remove: (dataType: string | HTMLElement) => void;
+                    has: (dataType: string | HTMLElement) => boolean;
+                };
+                element: {
+                    clean: (element: HTMLElement) => void;
+                    add: (element: HTMLElement) => void;
+                    create: (tagName: string, dataType: import("../commands/EditorCommands").builtIndataTypes | string) => HTMLElement;
+                    createText: () => HTMLParagraphElement;
+                    createTextNode: (data: any) => Text;
+                    createComponent: (componentName: string) => HTMLDivElement;
+                    insert: {
+                        text: (element: Node, text: string, offset: any) => void;
+                    };
+                    ids: {
+                        unique: (element: HTMLElement) => void;
+                    };
+                };
+                helpers: {
+                    editor: {
+                        ensure: {
+                            uniqueIds: (element: HTMLElement, state: {
+                                maxNodeId: number;
+                            }) => HTMLElement;
+                            selectionIsInEditor: (range: Range) => void;
+                        };
+                        cursor: {
+                            storePosition: (state: {
+                                selectedRange: Range;
+                            }) => void;
+                            isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                            isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                        };
+                    };
+                    editorNode: {
+                        get: {
+                            nodesInArrayByPluginType: (nodes: Array<import("../models/EditorModels").FlowNodeReference>, dataType: string) => Array<import("../models/EditorModels").FlowNodeReference>;
+                        };
+                    };
+                    htmlNode: {
+                        copy: {
+                            children: (from: HTMLElement, to: HTMLElement) => void;
+                        };
+                        insert: {
+                            text: (element: Node, text: string, offset: any) => void;
+                            elementInContainer: (element: HTMLElement, container: HTMLElement) => void;
+                        };
+                        get: {
+                            topContainerForContent: (element: HTMLElement) => HTMLElement;
+                            nodeSelectionForRange: (range: Range) => NodeSelection;
+                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                        };
+                        remove: {
+                            nodes: (nodes2Remove: Array<import("../models/EditorModels").FlowNodeReference>, editor: HTMLElement) => void;
+                        };
+                        strip: {
+                            after: (element: HTMLElement, splitter: string) => void;
+                            before: (element: HTMLElement, splitter: string) => void;
+                        };
+                        surround: {
+                            selectionWithElement: (element: HTMLElement, range: Range) => void;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    get: {
+        plugins: FlowEditorPlugin[];
+        content: {
+            isEmpty: () => boolean;
+            asJSON: () => FlowContent;
+            asString: () => string;
+        };
+        selection: {
+            has: {
+                type: (pluginType: string) => boolean;
+            };
+            get: {
+                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
+            };
+        };
+    };
+} & {
+    dispose?: () => void;
+};