@omnia/fx 8.0.288-dev → 8.0.289-dev

package/internal-do-not-import-from-here/ux/flow/editor/plugins/typography/TypographyButton.d.ts

@@ -1,2 +1,441 @@
-declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{}>) => any;
+import { guid } from "@omnia/fx-models";
+import { FlowNodeReference } from "../../models";
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
+    store?: {
+        state: {
+            editorContent: import("@omnia/fx/ux").FlowContent;
+            plugins: import("../../models").FlowEditorPlugin[];
+            pluginsLoadedPromise: import("@omnia/fx-models").Future<void>;
+            hideToolbar: boolean;
+            toolbarActions: import("@omnia/fx-models").FlowEditorActionRegistration[];
+            editor: HTMLDivElement;
+            nodeSelection: import("../../models").NodeSelection;
+            telePorts: JSX.Element[];
+            id: string;
+            pluginContext: import("../../models").FlowEditorPluginContext;
+            selectedRange: Range;
+            storedRange: Range;
+            showPlaceHolder: boolean;
+            definitionSelector: {
+                show: boolean;
+                categoryFilters: guid[];
+                rendererTypeFilters: guid[];
+            };
+        };
+        events: {
+            onMutatedEditorContent: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx/ux").FlowContent>;
+            onMutatedPlugins: import("../../../../..").MessageBusExposeOnlySubscription<import("../../models").FlowEditorPlugin[]>;
+            onMutatedPluginsLoadedPromise: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx-models").Future<void>>;
+            onMutatedHideToolbar: import("../../../../..").MessageBusExposeOnlySubscription<boolean>;
+            onMutatedToolbarActions: import("../../../../..").MessageBusExposeOnlySubscription<import("@omnia/fx-models").FlowEditorActionRegistration[]>;
+            onMutatedEditor: import("../../../../..").MessageBusExposeOnlySubscription<HTMLDivElement>;
+            onMutatedNodeSelection: import("../../../../..").MessageBusExposeOnlySubscription<import("../../models").NodeSelection>;
+            onMutatedTelePorts: import("../../../../..").MessageBusExposeOnlySubscription<JSX.Element[]>;
+            onMutatedId: import("../../../../..").MessageBusExposeOnlySubscription<string>;
+            onMutatedPluginContext: import("../../../../..").MessageBusExposeOnlySubscription<import("../../models").FlowEditorPluginContext>;
+            onMutatedSelectedRange: import("../../../../..").MessageBusExposeOnlySubscription<Range>;
+            onMutatedStoredRange: import("../../../../..").MessageBusExposeOnlySubscription<Range>;
+            onMutatedShowPlaceHolder: import("../../../../..").MessageBusExposeOnlySubscription<boolean>;
+            onMutatedDefinitionSelector: import("../../../../..").MessageBusExposeOnlySubscription<{
+                show: boolean;
+                categoryFilters: guid[];
+                rendererTypeFilters: guid[];
+            }>;
+        } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+        actions: {
+            onDispatching: {
+                confirm: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                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: {
+                confirm: {
+                    subscribe(fn: (result: {
+                        delete: {
+                            container: (element: HTMLElement) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: (result: {
+                        set: (elements: Node | Array<Node>) => void;
+                        capture: () => void;
+                        store: () => void;
+                        revertToStored: () => void;
+                        ensure: () => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                plugin: {
+                    subscribe(fn: (result: {
+                        register: {
+                            plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                            plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                            context: (ctx: import("../../models").FlowEditorPluginContext) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                content: {
+                    subscribe(fn: (result: {
+                        sync: () => void;
+                        set: {
+                            byObject: (content: import("@omnia/fx/ux").FlowContent) => void;
+                            byString: (content: string) => void;
+                        };
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                set: {
+                    subscribe(fn: (result: {
+                        container: (el: HTMLDivElement) => void;
+                        focus: () => void;
+                        placeHolderVisibility: () => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                toolbarAction: {
+                    subscribe(fn: (result: {
+                        add: (action: import("@omnia/fx-models").FlowEditorActionRegistration | import("@omnia/fx-models").FlowEditorActionRegistration[]) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                formatting: {
+                    subscribe(fn: (result: {
+                        wrapLine: (element: HTMLElement) => void;
+                        add: (element: HTMLElement) => void;
+                        toggle: (element: HTMLElement) => void;
+                        remove: (dataType: string) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                element: {
+                    subscribe(fn: (result: {
+                        createForComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                        createText: () => HTMLParagraphElement;
+                        create: (tagName: string, dataType: string) => HTMLElement;
+                        createTextNode: (data: any) => Text;
+                        add: (element: HTMLElement) => void;
+                        insert: (element: HTMLElement, ref: HTMLElement, preInsert: boolean) => void;
+                        delete: (element: HTMLElement) => void;
+                    }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                commands: {
+                    subscribe(fn: (result: {
+                        exec: (command: string, data: object | string) => void;
+                        builtIn: {
+                            content: {
+                                convert: (element: HTMLElement) => void;
+                            };
+                            ensure: {
+                                lastElement: {
+                                    isText: () => void;
+                                };
+                                unique: {
+                                    ids: (element: HTMLElement) => void;
+                                };
+                            };
+                            selection: {
+                                get: {
+                                    byPluginType: (pluginType: string) => FlowNodeReference[];
+                                };
+                                ensure: {
+                                    storedRange: () => void;
+                                };
+                            };
+                            cursor: {
+                                isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                                isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                            };
+                            actions: {
+                                captureSelection: () => void;
+                            };
+                            formatting: {
+                                add: (element: HTMLElement) => void;
+                                wrapLine: (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: string) => HTMLElement;
+                                createText: () => HTMLParagraphElement;
+                                createTextNode: (data: any) => Text;
+                                createComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                                insert: {
+                                    text: (element: Node, text: string, offset: any) => void;
+                                };
+                                ids: {
+                                    unique: (element: HTMLElement) => void;
+                                };
+                            };
+                            helpers: {
+                                editor: {
+                                    ensure: {
+                                        uniqueIds: (element: HTMLElement) => 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<FlowNodeReference>, dataType: string) => Array<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;
+                                        topContainerForComponent: (element: HTMLElement) => HTMLElement;
+                                        nodeSelectionForRange: (range: Range) => import("../../models").NodeSelection;
+                                        htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
+                                    };
+                                    remove: {
+                                        nodes: (nodes2Remove: Array<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: {
+                confirm: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                selection: {
+                    subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                };
+                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;
+                };
+            };
+        } & {
+            confirm: () => {
+                delete: {
+                    container: (element: HTMLElement) => void;
+                };
+            };
+            selection: () => {
+                set: (elements: Node | Array<Node>) => void;
+                capture: () => void;
+                store: () => void;
+                revertToStored: () => void;
+                ensure: () => void;
+            };
+            plugin: () => {
+                register: {
+                    plugin: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings) => void;
+                    plugins: (pluginSettings: import("@omnia/fx-models").FlowEditorPluginSettings | import("@omnia/fx-models").FlowEditorPluginSettings[]) => Promise<void>;
+                    context: (ctx: import("../../models").FlowEditorPluginContext) => void;
+                };
+            };
+            content: () => {
+                sync: () => void;
+                set: {
+                    byObject: (content: import("@omnia/fx/ux").FlowContent) => void;
+                    byString: (content: string) => void;
+                };
+            };
+            set: () => {
+                container: (el: HTMLDivElement) => void;
+                focus: () => void;
+                placeHolderVisibility: () => void;
+            };
+            toolbarAction: () => {
+                add: (action: import("@omnia/fx-models").FlowEditorActionRegistration | import("@omnia/fx-models").FlowEditorActionRegistration[]) => void;
+            };
+            formatting: () => {
+                wrapLine: (element: HTMLElement) => void;
+                add: (element: HTMLElement) => void;
+                toggle: (element: HTMLElement) => void;
+                remove: (dataType: string) => void;
+            };
+            element: () => {
+                createForComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                createText: () => HTMLParagraphElement;
+                create: (tagName: string, dataType: string) => HTMLElement;
+                createTextNode: (data: any) => Text;
+                add: (element: HTMLElement) => void;
+                insert: (element: HTMLElement, ref: HTMLElement, preInsert: boolean) => void;
+                delete: (element: HTMLElement) => void;
+            };
+            commands: () => {
+                exec: (command: string, data: object | string) => void;
+                builtIn: {
+                    content: {
+                        convert: (element: HTMLElement) => void;
+                    };
+                    ensure: {
+                        lastElement: {
+                            isText: () => void;
+                        };
+                        unique: {
+                            ids: (element: HTMLElement) => void;
+                        };
+                    };
+                    selection: {
+                        get: {
+                            byPluginType: (pluginType: string) => FlowNodeReference[];
+                        };
+                        ensure: {
+                            storedRange: () => void;
+                        };
+                    };
+                    cursor: {
+                        isAfterEndOfContent: (range: Range, container: HTMLElement) => boolean;
+                        isBeforeContent: (range: Range, container: HTMLElement) => boolean;
+                    };
+                    actions: {
+                        captureSelection: () => void;
+                    };
+                    formatting: {
+                        add: (element: HTMLElement) => void;
+                        wrapLine: (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: string) => HTMLElement;
+                        createText: () => HTMLParagraphElement;
+                        createTextNode: (data: any) => Text;
+                        createComponent: <TElementType extends HTMLDivElement = HTMLDivElement>(componentName: string) => TElementType;
+                        insert: {
+                            text: (element: Node, text: string, offset: any) => void;
+                        };
+                        ids: {
+                            unique: (element: HTMLElement) => void;
+                        };
+                    };
+                    helpers: {
+                        editor: {
+                            ensure: {
+                                uniqueIds: (element: HTMLElement) => 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<FlowNodeReference>, dataType: string) => Array<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;
+                                topContainerForComponent: (element: HTMLElement) => HTMLElement;
+                                nodeSelectionForRange: (range: Range) => import("../../models").NodeSelection;
+                                htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
+                            };
+                            remove: {
+                                nodes: (nodes2Remove: Array<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: import("../../models").FlowEditorPlugin[];
+            content: {
+                isEmpty: () => boolean;
+                asObject: () => import("@omnia/fx/ux").FlowContent;
+                asString: () => string;
+            };
+            selection: {
+                has: {
+                    type: (pluginType: string) => boolean;
+                };
+                get: {
+                    byType: (pluginType: string) => FlowNodeReference[];
+                    all: () => import("../../models").NodeSelection;
+                };
+            };
+            element: {
+                byId: (id: string) => HTMLElement;
+                byRef: (ref: HTMLElement) => HTMLElement;
+            };
+        };
+    } & {
+        dispose?: () => void;
+    };
+}>) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/flow/editor/plugins/velcron/VelcronPlugin.d.ts

@@ -1,9 +1,3 @@
-import { DynamicState, VelcronAppDefinition, VelcronDefinitionRegistrationWithoutApp } from "@omnia/fx-models";
-export type VelcronHtmlDivElement = HTMLDivElement & {
-    velcron: VelcronAppDefinition;
-    velcronRegistration: VelcronDefinitionRegistrationWithoutApp;
-    state: DynamicState;
-};
-export declare const velcronRendererPlugin: () => import("../../models").FlowEditorPlugin & {
+export declare const velcronRendererPlugin: () => import("../..").FlowEditorPlugin & {
     dispose?: () => void;
 };

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

@@ -7,7 +7,6 @@ export declare const useFlowEditorStore: () => {
         plugins: FlowEditorPlugin[];
         pluginsLoadedPromise: Future<void>;
         hideToolbar: boolean;
-        maxNodeId: number;
         toolbarActions: FlowEditorActionRegistration[];
         editor: HTMLDivElement;
         nodeSelection: NodeSelection;
@@ -28,7 +27,6 @@ export declare const useFlowEditorStore: () => {
         onMutatedPlugins: import("@omnia/fx").MessageBusExposeOnlySubscription<FlowEditorPlugin[]>;
         onMutatedPluginsLoadedPromise: import("@omnia/fx").MessageBusExposeOnlySubscription<Future<void>>;
         onMutatedHideToolbar: 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>;
@@ -84,6 +82,7 @@ export declare const useFlowEditorStore: () => {
             };
             selection: {
                 subscribe(fn: (result: {
+                    set: (elements: Node | Array<Node>) => void;
                     capture: () => void;
                     store: () => void;
                     revertToStored: () => void;
@@ -192,9 +191,7 @@ export declare const useFlowEditorStore: () => {
                         helpers: {
                             editor: {
                                 ensure: {
-                                    uniqueIds: (element: HTMLElement, state: {
-                                        maxNodeId: number;
-                                    }) => HTMLElement;
+                                    uniqueIds: (element: HTMLElement) => HTMLElement;
                                     selectionIsInEditor: (range: Range) => void;
                                 };
                                 cursor: {
@@ -222,7 +219,7 @@ export declare const useFlowEditorStore: () => {
                                     topContainerForContent: (element: HTMLElement) => HTMLElement;
                                     topContainerForComponent: (element: HTMLElement) => HTMLElement;
                                     nodeSelectionForRange: (range: Range) => NodeSelection;
-                                    htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                                    htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
                                 };
                                 remove: {
                                     nodes: (nodes2Remove: Array<import("../models").FlowNodeReference>, editor: HTMLElement) => void;
@@ -276,6 +273,7 @@ export declare const useFlowEditorStore: () => {
             };
         };
         selection: () => {
+            set: (elements: Node | Array<Node>) => void;
             capture: () => void;
             store: () => void;
             revertToStored: () => void;
@@ -370,9 +368,7 @@ export declare const useFlowEditorStore: () => {
                 helpers: {
                     editor: {
                         ensure: {
-                            uniqueIds: (element: HTMLElement, state: {
-                                maxNodeId: number;
-                            }) => HTMLElement;
+                            uniqueIds: (element: HTMLElement) => HTMLElement;
                             selectionIsInEditor: (range: Range) => void;
                         };
                         cursor: {
@@ -400,7 +396,7 @@ export declare const useFlowEditorStore: () => {
                             topContainerForContent: (element: HTMLElement) => HTMLElement;
                             topContainerForComponent: (element: HTMLElement) => HTMLElement;
                             nodeSelectionForRange: (range: Range) => NodeSelection;
-                            htmlElementInStructureById: (id: number, currentElement: HTMLElement) => HTMLElement;
+                            htmlElementInStructureById: (id: string, currentElement: HTMLElement) => HTMLElement;
                         };
                         remove: {
                             nodes: (nodes2Remove: Array<import("../models").FlowNodeReference>, editor: HTMLElement) => void;
@@ -434,7 +430,8 @@ export declare const useFlowEditorStore: () => {
             };
         };
         element: {
-            byId: (id: number) => HTMLElement;
+            byId: (id: string) => HTMLElement;
+            byRef: (ref: HTMLElement) => HTMLElement;
         };
     };
 } & {