@omnia/fx 8.0.558-dev → 8.0.560-dev

package/internal-do-not-import-from-here/ux/velcron/editor/store/VelcronCanvasStoreV2.d.ts

@@ -0,0 +1,96 @@
+import { Future, VelcronAppDefinition, VelcronDefinition, VelcronRendererResolverReference } from "@omnia/fx-models";
+import { useEditorChromeStore } from "@omnia/fx/ux";
+type CanvasMode = "design" | "preview";
+type PanelType = "settings" | "definition-structure" | "picker" | "code-editor";
+export type CodeViewMode = "app" | "state" | "body" | "editors";
+export declare const useVelcronCanvasStore: () => {
+    state: {
+        editing: {
+            definition: VelcronAppDefinition<object>;
+        };
+        source: {
+            editMode: CodeViewMode;
+            json: {
+                app: string;
+                appState: string;
+                appBody: string;
+                appEditors: string;
+            };
+        };
+        drawerMode: PanelType;
+        selection: {
+            item: VelcronDefinition;
+        };
+        settings: {
+            colorSchemaType: string;
+            canvasMode: {
+                current: CanvasMode;
+                previous: CanvasMode;
+            };
+        };
+    };
+    events: import("@omnia/fx/stores").StoreEvents<{
+        editing: {
+            definition: VelcronAppDefinition<object>;
+        };
+        source: {
+            editMode: CodeViewMode;
+            json: {
+                app: string;
+                appState: string;
+                appBody: string;
+                appEditors: string;
+            };
+        };
+        drawerMode: PanelType;
+        selection: {
+            item: VelcronDefinition;
+        };
+        settings: {
+            colorSchemaType: string;
+            canvasMode: {
+                current: CanvasMode;
+                previous: CanvasMode;
+            };
+        };
+    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+        editor: () => import("@omnia/fx/stores").StoreReturnDefineAction<{
+            selectItem: (item: VelcronDefinition) => void;
+        }>;
+        show: () => import("@omnia/fx/stores").StoreReturnDefineAction<{
+            sourcePanel: (action: "show" | "hide" | "toggle") => void;
+            settingsPanel: (action: "show" | "hide" | "toggle") => void;
+        }>;
+        canvas: () => import("@omnia/fx/stores").StoreReturnDefineAction<{
+            setMode: (mode: CanvasMode) => void;
+        }>;
+        template: () => import("@omnia/fx/stores").StoreReturnDefineAction<{
+            update: () => {
+                byJson: (json: string) => void;
+            };
+            edit: () => {
+                byResolverReference: (ref: VelcronRendererResolverReference) => void;
+                definition: (definition: VelcronAppDefinition) => void;
+            };
+        }>;
+        init: (editorChromeStoreRef: ReturnType<typeof useEditorChromeStore>) => void;
+    }>;
+    get: {
+        ready: () => Future<void>;
+        canvas: {
+            mode: () => CanvasMode;
+        };
+    };
+    rules: {
+        is: {
+            selected: (item: VelcronDefinition) => boolean;
+            editorEmpty: () => boolean;
+            settingsActive: () => boolean;
+            codeEditorActive: () => boolean;
+        };
+    };
+} & {
+    dispose?: () => void;
+};
+export {};

package/internal-do-not-import-from-here/ux/velcron/editor/store/index.d.ts

@@ -0,0 +1 @@
+export * from "./VelcronCanvasStoreV2";

package/internal-do-not-import-from-here/ux/velcron/editor/store/tempDefinition.d.ts

@@ -0,0 +1 @@
+export declare const tmpDefinition: any;

package/internal-do-not-import-from-here/ux/velcron/editor/views/DefineVelcronCanvasConfig.d.ts

@@ -0,0 +1,358 @@
+import { guid } from "@omnia/fx-models";
+import { useEditorChromeStore } from "@omnia/fx/ux";
+import { ChromeActionItem, EditorChromeConfiguration } from "@omnia/fx/ux/editor";
+export declare const defineVelcronEditorCanvasConfiguration: (param1: {
+    state: {
+        id: guid;
+        finishedLoading: boolean;
+        compactMode: boolean;
+        navigation: {
+            configuration: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration;
+            enabled: boolean;
+            show: boolean;
+        };
+        drawers: {
+            right: {
+                panel: {
+                    settings: import("@omnia/fx/ux/editor").EditorChromePanel;
+                    show: boolean;
+                    actions: ChromeActionItem[];
+                    footerToolbar: {
+                        actionsLeft: ChromeActionItem[];
+                        actionsCenter: ChromeActionItem[];
+                        actionsRight: ChromeActionItem[];
+                        ExtendActionsRight: ChromeActionItem[];
+                    };
+                };
+                canvas: {
+                    enabled: boolean;
+                    show: boolean;
+                    customScroll: boolean;
+                    header: {
+                        enabled: boolean;
+                        icon: import("@omnia/fx-models").IIcon;
+                        title: string;
+                    };
+                };
+            };
+        };
+        views: {
+            active: import("@omnia/fx/ux").EditorChromeViewRegistration;
+            registrations: import("@omnia/fx/ux").EditorChromeViewRegistration[];
+            history: {
+                items: {
+                    id: guid;
+                    timestamp: number;
+                }[];
+                currentIndex: number;
+                maxSize: number;
+            };
+        };
+        canvasSettings: {
+            scroll: {
+                store: {
+                    state: {
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        scroll: () => void;
+                        setDisableScrolling: (disable: boolean) => void;
+                        calculateDynamicHeight: () => void;
+                        setHeight: (height: string) => void;
+                        setWidth: (width: string) => void;
+                        setScrolling: (scrolling: import("@omnia/fx-models").OScrollTypesCombination) => void;
+                        calculateScrollHeight: (referenceElementIds: string[]) => void;
+                        isElementNameStillInView: (elementName: string) => boolean;
+                        isElementIdStillInView: (elementId: string) => boolean;
+                        scrollToStart: () => void;
+                        scrollToElementId: (elementId: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                        scrollToElementName: (elementName: string, anchor?: import("@omnia/fx/ux").AnchorPosition) => void;
+                        scrollToElement: (element: HTMLElement, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void) => void;
+                        scrollToSelector: (selector: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                    }>;
+                    get: {
+                        readonly coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                        readonly scrollPosition: number;
+                    };
+                } & {
+                    dispose?: () => void;
+                };
+            };
+            zoom: {
+                enabled: boolean;
+                level: number;
+            };
+            displaySize: {
+                enabled: boolean;
+                value: "l" | "s" | "m";
+                store: {
+                    state: {
+                        width: string;
+                        zoomLevel: number;
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        width: string;
+                        zoomLevel: number;
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        setWidth: (width: string) => void;
+                        resetWidth: () => void;
+                        setBreakPoint: (breakPoint: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+                        resetZoomLevel: () => void;
+                        setZoomLevel: (zoomLevel: number) => void;
+                    }>;
+                    get: {};
+                } & {
+                    dispose?: () => void;
+                };
+            };
+        };
+        notificationMessage: {
+            key: guid;
+            message: string;
+            show: boolean;
+            timeout: number;
+            customRenderer: string;
+        };
+        operations: {
+            id: guid;
+            loading: boolean;
+        }[];
+    };
+    actions: import("../../../mobile").StoreReturnDefineAction<{
+        canvas: () => {
+            syncDisplaySettings: () => Promise<void>;
+            setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+            zoomIn: (step?: number) => void;
+            zoomOut: (step?: number) => void;
+            setZoom: (level: number) => void;
+            resetZoom: () => void;
+        };
+        editor: () => {
+            resetForNewActiveConfiguration: () => void;
+        };
+        views: () => {
+            register: (editorView: import("@omnia/fx/ux/editor").EditorChromeView | import("@omnia/fx/ux/editor").EditorChromeView[]) => void;
+            active: {
+                set: (view: import("@omnia/fx/ux/editor").EditorChromeView, addToHistory?: boolean) => void;
+                clear: () => void;
+                configuration: {
+                    set: (configuration: EditorChromeConfiguration) => void;
+                };
+            };
+            remove: (view: import("@omnia/fx/ux/editor").EditorChromeView) => void;
+            history: {
+                removeCurrent: () => void;
+                goBack: () => boolean;
+                goForward: () => boolean;
+                addToHistory: (view: import("@omnia/fx/ux/editor").EditorChromeView) => void;
+                clear: () => void;
+            };
+        };
+        showNotification: (message: import("@omnia/fx-models").NotificationMessage) => void;
+        operations: () => {
+            create: (showLoading?: boolean) => import("@omnia/fx-models").Future<null>;
+            setLoading: () => import("@omnia/fx-models").Future<null>;
+            register: (showLoading?: boolean) => guid;
+            unregister: (operationId: guid) => boolean;
+            clear: () => void;
+            waitForCompletion: () => Promise<void>;
+        };
+        navigation: () => {
+            register: (navigationItem: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration) => void;
+            show: (value: boolean) => void;
+            toggle: () => void;
+        };
+        drawers: () => {
+            right: {
+                panel: {
+                    show: (panel: import("@omnia/fx/ux/editor").EditorChromePanel) => void;
+                    footerToolbar: {
+                        add: {
+                            action: (action: ChromeActionItem | ChromeActionItem[], position?: "left" | "center" | "right" | "extended-right") => void;
+                        };
+                    };
+                    close: () => void;
+                };
+                canvas: {
+                    configure: (header: {
+                        icon?: import("@omnia/fx-models").IIcon;
+                        title?: string;
+                        enabled?: boolean;
+                    }, customScroll?: boolean) => void;
+                    toolbar: {
+                        enable: (value: boolean) => void;
+                    };
+                    syncButtons: (currentId: guid) => void;
+                    toggle: () => void;
+                    show: (value: boolean) => void;
+                };
+            };
+        };
+        init: () => void;
+        dispose: () => void;
+    }>;
+    get: {
+        views: {
+            active: () => import("@omnia/fx/ux/editor").EditorChromeView;
+            all: () => import("@omnia/fx/ux/editor").EditorChromeView[];
+            byId: (id: guid) => import("@omnia/fx/ux/editor").EditorChromeView;
+        };
+        operations: {
+            all: () => guid[];
+            has: (operationId: guid) => boolean;
+            count: () => number;
+        };
+        history: () => {
+            view: import("@omnia/fx/ux/editor").EditorChromeView;
+            id: guid;
+            timestamp: number;
+        }[];
+    };
+    rules: {
+        showLoading: () => boolean;
+        history: {
+            canGoBack: () => boolean;
+            canGoForward: () => boolean;
+        };
+        views: {
+            hasActive: () => boolean;
+            active: {
+                configuration: {
+                    hasActive: () => boolean;
+                    hasBackgNavigation: () => boolean;
+                };
+            };
+        };
+    };
+    utils: {
+        configuration: {
+            extend: (target: EditorChromeConfiguration, configuration: EditorChromeConfiguration) => void;
+        };
+    };
+} & {
+    dispose?: () => void;
+}) => {
+    configuration: EditorChromeConfiguration;
+    store: {
+        state: {
+            editing: {
+                definition: import("@omnia/fx-models").VelcronAppDefinition<object>;
+            };
+            source: {
+                editMode: import("../store").CodeViewMode;
+                json: {
+                    app: string;
+                    appState: string;
+                    appBody: string;
+                    appEditors: string;
+                };
+            };
+            drawerMode: "settings" | "picker" | "definition-structure" | "code-editor";
+            selection: {
+                item: import("@omnia/fx-models").VelcronDefinition;
+            };
+            settings: {
+                colorSchemaType: string;
+                canvasMode: {
+                    current: "preview" | "design";
+                    previous: "preview" | "design";
+                };
+            };
+        };
+        events: import("../../../mobile").StoreEvents<{
+            editing: {
+                definition: import("@omnia/fx-models").VelcronAppDefinition<object>;
+            };
+            source: {
+                editMode: import("../store").CodeViewMode;
+                json: {
+                    app: string;
+                    appState: string;
+                    appBody: string;
+                    appEditors: string;
+                };
+            };
+            drawerMode: "settings" | "picker" | "definition-structure" | "code-editor";
+            selection: {
+                item: import("@omnia/fx-models").VelcronDefinition;
+            };
+            settings: {
+                colorSchemaType: string;
+                canvasMode: {
+                    current: "preview" | "design";
+                    previous: "preview" | "design";
+                };
+            };
+        }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+        actions: import("../../../mobile").StoreReturnDefineAction<{
+            editor: () => import("../../../mobile").StoreReturnDefineAction<{
+                selectItem: (item: import("@omnia/fx-models").VelcronDefinition) => void;
+            }>;
+            show: () => import("../../../mobile").StoreReturnDefineAction<{
+                sourcePanel: (action: "show" | "hide" | "toggle") => void;
+                settingsPanel: (action: "show" | "hide" | "toggle") => void;
+            }>;
+            canvas: () => import("../../../mobile").StoreReturnDefineAction<{
+                setMode: (mode: "preview" | "design") => void;
+            }>;
+            template: () => import("../../../mobile").StoreReturnDefineAction<{
+                update: () => {
+                    byJson: (json: string) => void;
+                };
+                edit: () => {
+                    byResolverReference: (ref: import("@omnia/fx-models").VelcronRendererResolverReference) => void;
+                    definition: (definition: import("@omnia/fx-models").VelcronAppDefinition) => void;
+                };
+            }>;
+            init: (editorChromeStoreRef: ReturnType<typeof useEditorChromeStore>) => void;
+        }>;
+        get: {
+            ready: () => import("@omnia/fx-models").Future<void>;
+            canvas: {
+                mode: () => "preview" | "design";
+            };
+        };
+        rules: {
+            is: {
+                selected: (item: import("@omnia/fx-models").VelcronDefinition) => boolean;
+                editorEmpty: () => boolean;
+                settingsActive: () => boolean;
+                codeEditorActive: () => boolean;
+            };
+        };
+    } & {
+        dispose?: () => void;
+    };
+    refresh(): void;
+};