@omnia/fx 8.0.527-dev → 8.0.529-dev

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

@@ -1,4 +1,4 @@
-import { EditorChromeView, guid, IVersionedData, Layout, LayoutCanvasEditorMode, VersionedLayout, VersionedLayoutDefinition } from "@omnia/fx-models";
+import { EditorChromeConfiguration, EditorChromePanel, EditorChromeView, guid, IVersionedData, IVersionInformation, IVersionReference, Layout, LayoutCanvasEditorMode, VersionedLayout, VersionedLayoutDefinition } from "@omnia/fx-models";
 import { useEditorChromeStore, useLayoutCanvasStore, VersionedLayoutEditorSettings } from "@omnia/fx/ux";
 export interface EditorViews {
     default: () => {
@@ -10,6 +10,15 @@ export declare const useVersionedLayoutEditorStore: () => {
     state: {
         id: guid;
         settings: VersionedLayoutEditorSettings<VersionedLayoutDefinition>;
+        versioning: {
+            originalVersion: IVersionedData<VersionedLayoutDefinition>;
+            selectedVersion: IVersionInformation;
+        };
+        permissions: {
+            currentIdentity: string;
+            canEdit: boolean;
+            canDelete: boolean;
+        };
         active: {
             parentVersionedLayout: VersionedLayout;
             versionedLayout: VersionedLayout;
@@ -26,6 +35,15 @@ export declare const useVersionedLayoutEditorStore: () => {
     events: import("@omnia/fx/stores").StoreEvents<{
         id: guid;
         settings: VersionedLayoutEditorSettings<VersionedLayoutDefinition>;
+        versioning: {
+            originalVersion: IVersionedData<VersionedLayoutDefinition>;
+            selectedVersion: IVersionInformation;
+        };
+        permissions: {
+            currentIdentity: string;
+            canEdit: boolean;
+            canDelete: boolean;
+        };
         active: {
             parentVersionedLayout: VersionedLayout;
             versionedLayout: VersionedLayout;
@@ -40,12 +58,29 @@ export declare const useVersionedLayoutEditorStore: () => {
         panels: {};
     }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
     actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+        canvas: () => {
+            configuration: {
+                extend: (extension: EditorChromeConfiguration) => void;
+            };
+        };
+        versioning: () => {
+            init: () => void;
+            select: (version: IVersionInformation) => Promise<void>;
+            reset: () => void;
+        };
+        panel: () => {
+            show: (panel: EditorChromePanel) => void;
+        };
         layout: () => {
+            takeControlAndCheckOut: () => Promise<void>;
+            delete: () => Promise<void>;
             publish: () => Promise<void>;
             saveAsDraft: () => Promise<void>;
             discardChanges: () => Promise<void>;
             checkOut: () => Promise<void>;
+            revert: (version: IVersionReference) => Promise<void>;
             set: (layout: VersionedLayout) => Promise<void>;
+            setVersion: (versionedData: IVersionedData<VersionedLayoutDefinition>, mergeWithoutCache: boolean) => Promise<Layout>;
             setDefault: () => Promise<void>;
         };
         editor: () => {
@@ -54,19 +89,281 @@ export declare const useVersionedLayoutEditorStore: () => {
                 toReadMode: () => void;
             };
         };
+        close: () => void;
         init: (editorChromeStore: ReturnType<typeof useEditorChromeStore>, views: EditorViews) => void;
     }>;
     get: {
         editorMode: () => LayoutCanvasEditorMode;
         canvasMode: () => import("@omnia/fx-models").LayoutCanvasMode;
+        chromeStore: () => {
+            state: {
+                id: guid;
+                finishedLoading: boolean;
+                compactMode: boolean;
+                navigation: {
+                    configuration: import("@omnia/fx-models").EditorChromeNavigationConfiguration;
+                    enabled: boolean;
+                    show: boolean;
+                };
+                drawers: {
+                    right: {
+                        panel: {
+                            settings: EditorChromePanel;
+                            show: boolean;
+                            actions: import("@omnia/fx-models").ChromeActionItem[];
+                            footerToolbar: {
+                                actionsLeft: import("@omnia/fx-models").ChromeActionItem[];
+                                actionsCenter: import("@omnia/fx-models").ChromeActionItem[];
+                                actionsRight: import("@omnia/fx-models").ChromeActionItem[];
+                                ExtendActionsRight: import("@omnia/fx-models").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 bottom: number;
+                                    readonly top: number;
+                                };
+                            };
+                            events: import("@omnia/fx/stores").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 bottom: number;
+                                    readonly top: number;
+                                };
+                            }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                            actions: import("@omnia/fx/stores").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 bottom: number;
+                                    readonly top: 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("@omnia/fx/stores").StoreEvents<{
+                                width: string;
+                                zoomLevel: number;
+                            }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                            actions: import("@omnia/fx/stores").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("@omnia/fx/stores").StoreReturnDefineAction<{
+                canvas: () => {
+                    syncDisplaySettings: () => 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: EditorChromeView | EditorChromeView[]) => void;
+                    active: {
+                        set: (view: EditorChromeView, addToHistory?: boolean) => void;
+                        clear: () => void;
+                        configuration: {
+                            set: (configuration: EditorChromeConfiguration) => void;
+                        };
+                    };
+                    remove: (view: EditorChromeView) => void;
+                    history: {
+                        goBack: () => boolean;
+                        goForward: () => boolean;
+                        addToHistory: (view: 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-models").EditorChromeNavigationConfiguration) => void;
+                    show: (value: boolean) => void;
+                    toggle: () => void;
+                };
+                drawers: () => {
+                    right: {
+                        panel: {
+                            show: (panel: EditorChromePanel) => void;
+                            footerToolbar: {
+                                add: {
+                                    action: (action: import("@omnia/fx-models").ChromeActionItem | import("@omnia/fx-models").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: () => EditorChromeView;
+                    all: () => EditorChromeView[];
+                    byId: (id: guid) => EditorChromeView;
+                };
+                operations: {
+                    all: () => guid[];
+                    has: (operationId: guid) => boolean;
+                    count: () => number;
+                };
+                history: () => {
+                    view: EditorChromeView;
+                    id: guid;
+                    timestamp: number;
+                }[];
+            };
+            rules: {
+                showLoading: () => boolean;
+                history: {
+                    canGoBack: () => boolean;
+                    canGoForward: () => boolean;
+                };
+                views: {
+                    hasActive: () => boolean;
+                };
+            };
+            utils: {
+                configuration: {
+                    extend: (target: EditorChromeConfiguration, configuration: EditorChromeConfiguration) => void;
+                };
+            };
+        } & {
+            dispose?: () => void;
+        };
     };
     rules: {
+        versioning: {
+            hasReverted: () => boolean;
+        };
         isCheckedOutToMe: () => boolean;
         isCheckedOut: () => boolean;
+        isDefaultLayout: () => boolean;
         actions: {
             hide: {
+                takeControl: () => boolean;
                 whenNotCheckedOut: () => boolean;
                 whenCheckedOut: () => boolean;
+                whenNotDeletable: () => boolean;
             };
         };
     };

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

@@ -1 +1,2 @@
 export * from "./VersionedLayoutEditorStore";
+export * from "./VersionedLayoutEditorStoreV2";

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

@@ -151,8 +151,7 @@ import wcba03fc7e6921468289c0a0ffe0cf942e from './ux/versionedlayout/renderer/Ve
 import wc16225d552da74599b01a49952f3d2280 from './ux/versionedlayout/renderer/v2/VersionedLayoutRenderer';
 import wc73154f51a92944acbe248779a3fa7ef5 from './ux/versionedlayout/editor/VersionedLayoutEditor_old';
 import wcf61a88097aa748dbb99b691f78da571a from './ux/versionedlayout/editor/VersionedLayoutEditor';
-import wc32a6ca3074384eb4bcef68e9cd49a334 from './ux/versionedlayout/editor/panels/versionhistory/VersionHistory';
-import wcf024796066784669a26452b2da403b70 from './ux/versionedlayout/editor/panels/Panels';
+import wc32a6ca3074384eb4bcef68e9cd49a334 from './ux/versionedlayout/editor/panels/VersionHistory';
 import wcc88e2566b07a4680aef7f575f5c5641b from './ux/versionedlayout/controller/VersionedLayoutController';
 import wc177046bfd171495bbce70d1cd9242fa1 from './ux/versionedlayout/controller/Chrome';
 import wce96730610396417c992037cda2812626 from './ux/video/VideoPlayer';
@@ -2676,21 +2675,13 @@ declare global {
                     } : typeof wc6fa4d33c8cf34130bef70161155f1cff;
                 };
             };
-            "history": (typeof wc32a6ca3074384eb4bcef68e9cd49a334 extends {
+            "history": typeof wc32a6ca3074384eb4bcef68e9cd49a334 extends {
                 propsDefinition: infer TProp;
             } ? {
                 new (...args: any[]): {
                     $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
                 };
-            } : typeof wc32a6ca3074384eb4bcef68e9cd49a334) & {
-                "panel": typeof wcf024796066784669a26452b2da403b70 extends {
-                    propsDefinition: infer TProp;
-                } ? {
-                    new (...args: any[]): {
-                        $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
-                    };
-                } : typeof wcf024796066784669a26452b2da403b70;
-            };
+            } : typeof wc32a6ca3074384eb4bcef68e9cd49a334;
         };
         "video": {
             "player": typeof wce96730610396417c992037cda2812626 extends {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.527-dev",
+  "version": "8.0.529-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.527-dev",
+    "@omnia/fx-models": "8.0.529-dev",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.11.7",

package/internal-do-not-import-from-here/ux/versionedlayout/editor/panels/Panels.css.d.ts

@@ -1,4 +0,0 @@
-import { types } from "typestyle";
-export declare const PanelsStyles: {
-    wrapper?: types.NestedCSSProperties;
-};

package/internal-do-not-import-from-here/ux/versionedlayout/editor/panels/Panels.d.ts

@@ -1,7 +0,0 @@
-declare const _default: (props: import("@omnia/fx/ux").ExtractProps<Record<string, any>> & {} & {
-    "v-slots"?: {} & Omit<{
-        default?: import("vue").Slot;
-        $stable?: boolean;
-    }, never>;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, string> & import("@omnia/fx/ux").VNodeEvents) => any;
-export default _default;

package/internal-do-not-import-from-here/ux/versionedlayout/editor/panels/versionhistory/VersionHistory.css.d.ts

@@ -1,10 +0,0 @@
-import { types } from "typestyle";
-/**
- * Styles for the Editor component
- */
-export declare const VersionPanelStyles: {
-    container?: types.NestedCSSProperties;
-    timelineWrapper?: types.NestedCSSProperties;
-    version?: types.NestedCSSProperties;
-    smallDot?: types.NestedCSSProperties;
-};