@omnia/fx 8.0.559-dev → 8.0.560-dev

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

@@ -0,0 +1,357 @@
+import { guid } from "@omnia/fx-models";
+import { useEditorChromeStore } from "@omnia/fx/ux";
+import { EditorChromeConfiguration } from "@omnia/fx/ux/editor";
+export declare const defineVelcronTemplatesConfiguration: (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: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                    footerToolbar: {
+                        actionsLeft: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsCenter: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsRight: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        ExtendActionsRight: import("@omnia/fx/ux/editor").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: import("@omnia/fx/ux/editor").ChromeActionItem | import("@omnia/fx/ux/editor").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;
+}, param2: {
+    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;
+}) => {
+    configuration: EditorChromeConfiguration;
+    refresh(): void;
+};

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

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

package/internal-do-not-import-from-here/ux/velcron/editor_old/VelcronEditor.d.ts

@@ -0,0 +1,27 @@
+import { DefineEmit, DefineSlot } from "@omnia/fx/ux";
+import { VNodeChild } from "vue";
+import { VelcronAppDefinition } from "@omnia/fx-models";
+export type DefinitionChanged = (definition: VelcronAppDefinition) => void;
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    "emit:update:modelValue": (value: boolean) => void;
+} & {
+    "v-model"?: boolean;
+} & {
+    modelValue?: boolean;
+} & {
+    definition?: VelcronAppDefinition<object>;
+} & {
+    mode?: "store" | "return";
+} & DefineEmit<"click:close", () => true> & DefineEmit<"save", (definition: VelcronAppDefinition) => true> & DefineSlot<"activator", () => VNodeChild>> & {
+    "onUpdate:modelValue"?: (value: boolean) => any;
+    "onClick:close"?: () => any;
+    onSave?: (definition: VelcronAppDefinition<object>) => any;
+} & {
+    "v-slots"?: {
+        activator?: () => VNodeChild;
+    } & Omit<{
+        default?: import("vue").Slot;
+        $stable?: boolean;
+    }, "activator">;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "mode" | "definition" | "v-model" | "modelValue" | "emit:update:modelValue" | "slot:activator" | "emit:click:close" | "emit:save"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor_old/components/panels/edit-component/StylingPanel.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor_old/components/panels/edit-editors/EditEditorsPanel.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/versionedlayout/editor/views/DefineDefaultView.d.ts

@@ -261,7 +261,7 @@ export declare const defineDefaultEditorView: (param1: EditorChromeConfiguration
             };
             actions: import("../../../mobile").StoreReturnDefineAction<{
                 canvas: () => {
-                    syncDisplaySettings: () => void;
+                    syncDisplaySettings: () => Promise<void>;
                     setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
                     zoomIn: (step?: number) => void;
                     zoomOut: (step?: number) => void;

package/internal-do-not-import-from-here/ux/versionedlayout/stores/VersionedLayoutEditorStoreV2.d.ts

@@ -268,7 +268,7 @@ export declare const useVersionedLayoutEditorStore: () => {
             };
             actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
                 canvas: () => {
-                    syncDisplaySettings: () => void;
+                    syncDisplaySettings: () => Promise<void>;
                     setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
                     zoomIn: (step?: number) => void;
                     zoomOut: (step?: number) => void;

package/internal-do-not-import-from-here/wctypings.d.ts

@@ -376,7 +376,8 @@ import wc762d4009466d494e94cbcc3e90dff11d from './ux/social/likehandler/LikeActi
 import wc0e7c178722cb41108b4740dbc788b4e5 from './ux/social/templates/CommentLikeTemplate';
 import wc0e7c178722cb41108b4740dbc788b4ee from './ux/social/templates/LikeListingTemplate';
 import wcc75ffd4cf2f14b6685c5c2d894fdf00f from './ux/velcron/editor/VelcronEditor';
-import wc3147213782724576b53d13e580af67ae from './ux/velcron/editor/VelcronEditorAction';
+import wc9f17d863e2ba4737a638c941e6dd4b71 from './ux/velcron/editor_old/VelcronEditor';
+import wc3147213782724576b53d13e580af67ae from './ux/velcron/editor_old/VelcronEditorAction';
 import wc3dd4d94bcc254f9fac2100a3ff84dc7e from './ux/velcron/renderer/VelcronRenderer';
 import wc64567c1ccfb84d1380725db72ad01eeb from './ux/velcron/renderer/components/ComponentCreator';
 import wcdcf9c3e24a774e4dae784a3eac29d488 from './ux/velcron/renderer/components/App';
@@ -3710,13 +3711,21 @@ declare global {
             } : typeof wc762d4009466d494e94cbcc3e90dff11d;
         };
         "velcron": {
-            "editor": typeof wcc75ffd4cf2f14b6685c5c2d894fdf00f extends {
+            "editor": (typeof wcc75ffd4cf2f14b6685c5c2d894fdf00f extends {
                 propsDefinition: infer TProp;
             } ? {
                 new (...args: any[]): {
                     $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
                 };
-            } : typeof wcc75ffd4cf2f14b6685c5c2d894fdf00f;
+            } : typeof wcc75ffd4cf2f14b6685c5c2d894fdf00f) & {
+                "old": typeof wc9f17d863e2ba4737a638c941e6dd4b71 extends {
+                    propsDefinition: infer TProp;
+                } ? {
+                    new (...args: any[]): {
+                        $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
+                    };
+                } : typeof wc9f17d863e2ba4737a638c941e6dd4b71;
+            };
             "renderer": typeof wc3dd4d94bcc254f9fac2100a3ff84dc7e extends {
                 propsDefinition: infer TProp;
             } ? {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.559-dev",
+  "version": "8.0.560-dev",
   "description": "Provide Omnia Fx typings and tooling for clientside Omnia development.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -20,7 +20,7 @@
   ],
   "author": "Omnia Digital Workplace AB",
   "dependencies": {
-    "@omnia/fx-models": "8.0.559-dev",
+    "@omnia/fx-models": "8.0.560-dev",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.11.7",