@omnia/fx 8.0.265-dev → 8.0.267-dev

package/internal-do-not-import-from-here/ux/floweditor/models/Constants.d.ts

@@ -0,0 +1,14 @@
+export declare const FlowEditorConstants: {
+    node: {
+        attributes: {
+            pluginType: string;
+            Id: string;
+        };
+    };
+    editor: {
+        container: string;
+    };
+    clipboard: {
+        container: string;
+    };
+};

package/internal-do-not-import-from-here/ux/floweditor/models/EditorPlugin.d.ts

@@ -5,8 +5,13 @@ import { useFlowEditorToolbarStore } from "../stores/FlowEditorToolbarStore";
 export interface FlowEditorPlugin {
     name: string;
     commands?: object;
+    eventListeners?: Array<FlowEditorEventListener>;
     actions?: Array<FlowEditorActionRegistration>;
 }
+export interface FlowEditorEventListener {
+    event?: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>;
+    action: (event: Event, context: FlowEditorPluginContext) => void;
+}
 export interface FlowRenderingContext {
     parentElement: HTMLElement;
 }
@@ -19,9 +24,14 @@ export interface FlowToJsonContext {
     element: HTMLElement;
     parent: FlowNode;
 }
+export interface ElementConverter {
+    canConvert: (el: HTMLElement) => boolean;
+    convert: (el: HTMLElement, pluginContext: FlowEditorPluginContext) => HTMLElement;
+}
 export interface FlowEditorContentPlugin extends FlowEditorPlugin {
     toJSON: (context: FlowToJsonContext) => FlowNode;
     toHtml: (context: FlowToHtmlContext) => HTMLElement;
+    elementConverter?: ElementConverter;
 }
 export interface FlowEditorPluginContext {
     componentCreator?: (componentDef: any, props: {}, el: HTMLElement) => void;

package/internal-do-not-import-from-here/ux/floweditor/plugins/elements/ElementPlugin.d.ts

@@ -0,0 +1,7 @@
+import { FlowNode } from "../../models/EditorModels";
+export interface ElementNode extends FlowNode {
+    name: "br";
+}
+export declare const elementPlugin: () => import("../../models/EditorPlugin").FlowEditorPlugin & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/eventhandlers/EditorEvents.d.ts

@@ -0,0 +1,4 @@
+import { FlowEditorPlugin } from "../../models/EditorPlugin";
+export declare const editorEventsPlugin: () => FlowEditorPlugin & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/eventhandlers/KeyboardEvents.d.ts

@@ -0,0 +1,4 @@
+import { FlowEditorPlugin } from "../../models/EditorPlugin";
+export declare const keyboardEventsPlugin: () => FlowEditorPlugin & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/eventhandlers/handlers/BackspaceHandler.d.ts

@@ -0,0 +1,4 @@
+import { useFlowEditorStore } from "../../../stores/FlowEditorStore";
+export declare function useBackspaceHandler(): {
+    handle: (store: ReturnType<typeof useFlowEditorStore>) => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/eventhandlers/handlers/ClipboardHandler.d.ts

@@ -0,0 +1,4 @@
+import { useFlowEditorStore } from "../../../stores/FlowEditorStore";
+export declare function useClipboardHandler(): {
+    paste: (ev: ClipboardEvent, editorStore: ReturnType<typeof useFlowEditorStore>) => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/eventhandlers/handlers/EnterHandler.d.ts

@@ -0,0 +1,4 @@
+import { useFlowEditorStore } from "../../../stores/FlowEditorStore";
+export declare function useEnterHandler(): {
+    handle: (store: ReturnType<typeof useFlowEditorStore>) => void;
+};

package/internal-do-not-import-from-here/ux/floweditor/plugins/sourceeditor/SourceEditorPlugin.d.ts

@@ -1,3 +1,4 @@
-export declare const sourceEditorPlugin: () => import("../../models/EditorPlugin").FlowEditorPlugin & {
+import { FlowEditorPlugin } from "../../models/EditorPlugin";
+export declare const sourceEditorPlugin: () => FlowEditorPlugin & {
     dispose?: () => void;
 };

package/internal-do-not-import-from-here/ux/floweditor/plugins/testdata/TestDataPlugin.d.ts

@@ -1,3 +1,4 @@
-export declare const testDataPlugin: () => import("../../models/EditorPlugin").FlowEditorPlugin & {
+import { FlowEditorPlugin } from "../../models/EditorPlugin";
+export declare const testDataPlugin: () => FlowEditorPlugin & {
     dispose?: () => void;
 };

package/internal-do-not-import-from-here/ux/floweditor/rules/EditorRules.d.ts

@@ -0,0 +1,7 @@
+export declare function useFlowEditorRules(): {
+    is: {
+        topContainer: (node: HTMLElement) => boolean;
+        editorNode: (node: HTMLElement) => boolean;
+        clipboardContainer: (node: HTMLElement) => boolean;
+    };
+};

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

@@ -13,6 +13,7 @@ export declare const useFlowEditorStore: () => {
         nodeSelection: NodeSelection;
         telePorts: JSX.Element[];
         id: string;
+        pluginContext: FlowEditorPluginContext;
         selectedRange: Range;
         showPlaceHolder: boolean;
     };
@@ -27,6 +28,7 @@ export declare const useFlowEditorStore: () => {
         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>>;
@@ -38,13 +40,7 @@ export declare const useFlowEditorStore: () => {
             content: {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setEditorMode: {
-                subscribe(fn: (editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setEditorContainer: {
-                subscribe(fn: (el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            focusEditor: {
+            set: {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             toolbarAction: {
@@ -72,20 +68,20 @@ export declare const useFlowEditorStore: () => {
             };
             content: {
                 subscribe(fn: (result: {
+                    sync: () => FlowContent;
                     set: {
                         byJSON: (content: FlowContent) => void;
                         byString: (content: string) => void;
                     };
                 }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setEditorMode: {
-                subscribe(fn: (result: void, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setEditorContainer: {
-                subscribe(fn: (result: void, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            focusEditor: {
-                subscribe(fn: (result: 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: {
@@ -111,6 +107,94 @@ export declare const useFlowEditorStore: () => {
             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;
             };
         };
@@ -121,13 +205,7 @@ export declare const useFlowEditorStore: () => {
             content: {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setEditorMode: {
-                subscribe(fn: (failureReason: any, editMode: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setEditorContainer: {
-                subscribe(fn: (failureReason: any, el: HTMLDivElement) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            focusEditor: {
+            set: {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             toolbarAction: {
@@ -152,14 +230,18 @@ export declare const useFlowEditorStore: () => {
             };
         };
         content: () => {
+            sync: () => FlowContent;
             set: {
                 byJSON: (content: FlowContent) => void;
                 byString: (content: string) => void;
             };
         };
-        setEditorMode: (editMode: boolean) => void;
-        setEditorContainer: (el: HTMLDivElement) => void;
-        focusEditor: () => void;
+        set: () => {
+            mode: (editMode: boolean) => void;
+            container: (el: HTMLDivElement) => void;
+            focus: () => void;
+            placeHolderVisibility: () => void;
+        };
         toolbarAction: () => {
             add: (action: FlowEditorActionRegistration | FlowEditorActionRegistration[]) => void;
         };
@@ -177,6 +259,94 @@ export declare const useFlowEditorStore: () => {
         };
         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: {
@@ -188,10 +358,10 @@ export declare const useFlowEditorStore: () => {
         };
         selection: {
             has: {
-                dataType: (dataType: string) => boolean;
+                type: (pluginType: string) => boolean;
             };
             get: {
-                byDataType: (dataType: string) => import("../models/EditorModels").FlowNodeReference[];
+                byType: (pluginType: string) => import("../models/EditorModels").FlowNodeReference[];
             };
         };
     };