@interopio/workspaces-api 4.6.0 → 5.0.0-next.0

package/changelog.md

@@ -1,9 +1,16 @@
+## 5.0.0-next.0
 
-## 4.6.0
+### Major Changes
+
+- b7b1ac5: chore: bump all packages to v5.0.0
+
+### Minor Changes
+
+- c5e2cfa: feat: G4E-10611 Workspace layout can now have appRestrictions for showing apps in add application popup and for allowing apps to be dropped
 
 ### Patch Changes
 
-- Cascade patch bump for internal dependents
+- 04c50d6: feature: Added support for IDs in layouts and general support for layout sharing
 
 ## 4.5.0
 

package/dist/workspaces.es.js

@@ -924,6 +924,19 @@ const allParentDecoder = oneOf(constant("workspace"), constant("row"), constant(
 const subParentDecoder = oneOf(constant("row"), constant("column"), constant("group"));
 const frameStateDecoder = oneOf(constant("maximized"), constant("minimized"), constant("normal"));
 const loadingAnimationTypeDecoder = oneOf(constant("workspace"));
+const appRestrictionRuleDecoder = object({
+    allowInApplicationPopup: optional(boolean()),
+    allowDrop: optional(boolean())
+});
+const appRestrictionEntryDecoder = object({
+    appName: nonEmptyStringDecoder,
+    allowInApplicationPopup: optional(boolean()),
+    allowDrop: optional(boolean())
+});
+const appRestrictionsDecoder = object({
+    apps: optional(array(appRestrictionEntryDecoder)),
+    default: optional(appRestrictionRuleDecoder)
+});
 const checkThrowCallback = (callback, allowUndefined) => {
     const argumentType = typeof callback;
     if (allowUndefined && argumentType !== "function" && argumentType !== "undefined") {
@@ -939,6 +952,9 @@ const workspaceBuilderCreateConfigDecoder = optional(object({
 const deleteLayoutConfigDecoder = object({
     name: nonEmptyStringDecoder
 });
+const deleteLayoutByIdConfigDecoder = object({
+    layoutId: nonEmptyStringDecoder
+});
 const windowDefinitionConfigDecoder = object({
     minWidth: optional(number()),
     maxWidth: optional(number()),
@@ -1045,7 +1061,13 @@ const restoreWorkspaceConfigDecoder = optional(object({
     isPinned: optional(boolean()),
     isSelected: optional(boolean()),
     positionIndex: optional(nonNegativeNumberDecoder),
-    allowSystemHibernation: optional(boolean())
+    allowSystemHibernation: optional(boolean()),
+}));
+const restoreWorkspaceByIdConfigDecoder = intersection(restoreWorkspaceConfigDecoder, object({
+    layoutId: nonEmptyStringDecoder,
+}));
+const openWorkspaceByIdConfigDecoder = intersection(restoreWorkspaceConfigDecoder, object({
+    layoutId: nonEmptyStringDecoder,
 }));
 const openWorkspaceConfigDecoder = object({
     name: nonEmptyStringDecoder,
@@ -1081,7 +1103,8 @@ const workspaceDefinitionDecoder = object({
         isPinned: optional(boolean()),
         isSelected: optional(boolean()),
         positionIndex: optional(nonNegativeNumberDecoder),
-        windowDragMode: optional(windowDragModeDecoder)
+        windowDragMode: optional(windowDragModeDecoder),
+        appRestrictions: optional(appRestrictionsDecoder)
     })),
     frame: optional(object({
         activate: optional(boolean()),
@@ -1097,6 +1120,10 @@ const restoreWorkspaceDefinitionDecoder = object({
     name: nonEmptyStringDecoder,
     restoreOptions: optional(restoreWorkspaceConfigDecoder)
 });
+const restoreWorkspaceByIdDefinitionDecoder = object({
+    id: nonEmptyStringDecoder,
+    restoreOptions: optional(restoreWorkspaceConfigDecoder)
+});
 const emptyFrameDefinitionDecoder = optional(object({
     applicationName: optional(string()),
     frameConfig: optional(newFrameConfigDecoder),
@@ -1104,11 +1131,11 @@ const emptyFrameDefinitionDecoder = optional(object({
     layoutComponentId: optional(nonEmptyStringDecoder)
 }));
 const frameInitConfigDecoder = object({
-    workspaces: array(oneOf(optional(workspaceDefinitionDecoder), optional(restoreWorkspaceDefinitionDecoder)))
+    workspaces: array(oneOf(optional(workspaceDefinitionDecoder), optional(restoreWorkspaceDefinitionDecoder), optional(restoreWorkspaceByIdDefinitionDecoder)))
 });
 const frameInitProtocolConfigDecoder = object({
     frameId: nonEmptyStringDecoder,
-    workspaces: array(oneOf(workspaceDefinitionDecoder, restoreWorkspaceDefinitionDecoder))
+    workspaces: array(oneOf(workspaceDefinitionDecoder, restoreWorkspaceDefinitionDecoder, restoreWorkspaceByIdDefinitionDecoder))
 });
 const builderConfigDecoder = object({
     type: allParentDecoder,
@@ -1149,6 +1176,7 @@ const workspaceConfigResultDecoder = object({
     title: nonEmptyStringDecoder,
     positionIndex: nonNegativeNumberDecoder,
     name: nonEmptyStringDecoder,
+    layoutId: optional(nonEmptyStringDecoder),
     layoutName: optional(nonEmptyStringDecoder),
     isHibernated: optional(boolean()),
     isSelected: optional(boolean()),
@@ -1176,7 +1204,8 @@ const workspaceConfigResultDecoder = object({
     heightInPx: optional(number()),
     isPinned: optional(boolean()),
     windowDragMode: optional(windowDragModeDecoder),
-    loadingStrategy: optional(loadingStrategyDecoder)
+    loadingStrategy: optional(loadingStrategyDecoder),
+    appRestrictions: optional(appRestrictionsDecoder)
 });
 const baseChildSnapshotConfigDecoder = object({
     frameId: nonEmptyStringDecoder,
@@ -1261,6 +1290,7 @@ const rowLayoutItemDecoder = object({
     children: array(oneOf(columnLayoutItemDecoder, groupLayoutItemDecoder, windowLayoutItemDecoder, lazy(() => rowLayoutItemDecoder)))
 });
 const workspaceLayoutDecoder = object({
+    id: optional(nonEmptyStringDecoder),
     name: nonEmptyStringDecoder,
     type: constant("Workspace"),
     metadata: optional(anyJson()),
@@ -1307,6 +1337,7 @@ const frameSnapshotResultDecoder = object({
     workspaces: array(workspaceSnapshotResultDecoder)
 });
 const layoutSummaryDecoder = object({
+    id: optional(nonEmptyStringDecoder),
     name: nonEmptyStringDecoder,
     applicationName: optional(string())
 });
@@ -1435,6 +1466,16 @@ const windowStreamDataDecoder = object({
     })
 });
 const workspaceLayoutSaveConfigDecoder = object({
+    id: optional(nonEmptyStringDecoder),
+    name: nonEmptyStringDecoder,
+    workspaceId: nonEmptyStringDecoder,
+    saveContext: optional(boolean()),
+    allowMultiple: optional(boolean()),
+    metadata: optional(object()),
+    saveWindowContexts: optional(boolean())
+});
+const workspaceLayoutSaveByIdConfigDecoder = object({
+    id: optional(nonEmptyStringDecoder),
     name: nonEmptyStringDecoder,
     workspaceId: nonEmptyStringDecoder,
     saveContext: optional(boolean()),
@@ -1671,9 +1712,12 @@ const OPERATIONS = {
     getAllWorkspacesSummaries: { name: "getAllWorkspacesSummaries", resultDecoder: workspaceSummariesResultDecoder },
     getWorkspaceSnapshot: { name: "getWorkspaceSnapshot", resultDecoder: workspaceSnapshotResultDecoder, argsDecoder: simpleItemConfigDecoder },
     getAllLayoutsSummaries: { name: "getAllLayoutsSummaries", resultDecoder: layoutSummariesDecoder },
+    openWorkspaceById: { name: "openWorkspaceById", argsDecoder: openWorkspaceByIdConfigDecoder, resultDecoder: workspaceSnapshotResultDecoder },
     openWorkspace: { name: "openWorkspace", argsDecoder: openWorkspaceConfigDecoder, resultDecoder: workspaceSnapshotResultDecoder },
     deleteLayout: { name: "deleteLayout", resultDecoder: voidResultDecoder, argsDecoder: deleteLayoutConfigDecoder },
+    deleteLayoutById: { name: "deleteLayoutById", resultDecoder: voidResultDecoder, argsDecoder: deleteLayoutByIdConfigDecoder },
     saveLayout: { name: "saveLayout", resultDecoder: workspaceLayoutDecoder, argsDecoder: workspaceLayoutSaveConfigDecoder },
+    saveLayoutById: { name: "saveLayoutById", resultDecoder: workspaceLayoutDecoder, argsDecoder: workspaceLayoutSaveByIdConfigDecoder },
     importLayout: { name: "importLayout", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutDecoder },
     importLayouts: { name: "importLayouts", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutsDecoder },
     exportAllLayouts: { name: "exportAllLayouts", resultDecoder: exportedLayoutsResultDecoder },
@@ -2741,6 +2785,9 @@ class Workspace {
     get title() {
         return getData$3(this).config.title;
     }
+    get layoutId() {
+        return getData$3(this).config.layoutId;
+    }
     get layoutName() {
         return getData$3(this).config.layoutName;
     }
@@ -2783,6 +2830,9 @@ class Workspace {
     get allowWindowReorder() {
         return getData$3(this).config.allowWindowReorder;
     }
+    get appRestrictions() {
+        return getData$3(this).config.appRestrictions;
+    }
     get showCloseButton() {
         return getData$3(this).config.showCloseButton;
     }
@@ -4297,11 +4347,13 @@ class BaseController {
     windows;
     contexts;
     layouts;
-    constructor(ioc, windows, contexts, layouts) {
+    layoutsV2;
+    constructor(ioc, windows, contexts, layouts, layoutsV2) {
         this.ioc = ioc;
         this.windows = windows;
         this.contexts = contexts;
         this.layouts = layouts;
+        this.layoutsV2 = layoutsV2;
     }
     get bridge() {
         return this.ioc.bridge;
@@ -4331,6 +4383,16 @@ class BaseController {
     async initFrame(frameId, config) {
         await this.bridge.send(OPERATIONS.initFrame.name, { frameId, ...config });
     }
+    async restoreWorkspaceById(options) {
+        const snapshot = await this.bridge.send(OPERATIONS.openWorkspaceById.name, { ...options });
+        const frameSummary = await this.bridge.send(OPERATIONS.getFrameSummary.name, { itemId: snapshot.config.frameId });
+        const frameConfig = {
+            summary: frameSummary
+        };
+        const frame = this.ioc.getModel("frame", frameConfig);
+        const workspaceConfig = { frame, snapshot };
+        return this.ioc.getModel("workspace", workspaceConfig);
+    }
     async restoreWorkspace(name, options) {
         const snapshot = await this.bridge.send(OPERATIONS.openWorkspace.name, { name, restoreOptions: options });
         const frameSummary = await this.bridge.send(OPERATIONS.getFrameSummary.name, { itemId: snapshot.config.frameId });
@@ -4383,13 +4445,20 @@ class BaseController {
             return Object.assign({}, { id: summary.id, width: summary.config.widthInPx, height: summary.config.heightInPx }, summary.config);
         });
     }
-    handleOnSaved(callback) {
+    async handleOnSaved(callback) {
         const wrappedCallback = (layout) => {
             if (layout.type !== "Workspace") {
                 return;
             }
             callback(layout);
         };
+        if (this.layoutsV2) {
+            const [addedUnSub, changedUnSub] = await Promise.all([this.layoutsV2.onAdded(wrappedCallback), this.layoutsV2.onChanged(wrappedCallback)]);
+            return () => {
+                addedUnSub();
+                changedUnSub();
+            };
+        }
         const addedUnSub = this.layouts.onAdded(wrappedCallback);
         const changedUnSub = this.layouts.onChanged(wrappedCallback);
         return () => {
@@ -4397,13 +4466,16 @@ class BaseController {
             changedUnSub();
         };
     }
-    handleOnRemoved(callback) {
+    async handleOnRemoved(callback) {
         const wrappedCallback = (layout) => {
             if (layout.type !== "Workspace") {
                 return;
             }
             callback(layout);
         };
+        if (this.layoutsV2) {
+            return this.layoutsV2.onRemoved(wrappedCallback);
+        }
         return this.layouts.onRemoved(wrappedCallback);
     }
     async importLayouts(layouts, mode) {
@@ -4727,6 +4799,21 @@ class MainController {
     async initFrame(frameId, config) {
         return this.base.initFrame(frameId, config);
     }
+    async restoreWorkspaceById(options) {
+        const allLayouts = await this.getLayoutSummaries();
+        const layoutExists = allLayouts.some((summary) => summary.id === options.layoutId);
+        if (!layoutExists) {
+            throw new Error(`This layout: ${options.layoutId} cannot be restored, because it doesn't exist.`);
+        }
+        if (options?.frameId) {
+            const allFrameSummaries = await this.bridge.send(OPERATIONS.getAllFramesSummaries.name);
+            const foundMatchingFrame = allFrameSummaries.summaries.some((summary) => summary.id === options.frameId);
+            if (!foundMatchingFrame) {
+                throw new Error(`Cannot reuse the frame with id: ${options.frameId}, because there is no frame with that ID found`);
+            }
+        }
+        return await this.base.restoreWorkspaceById(options);
+    }
     async restoreWorkspace(name, options) {
         const allLayouts = await this.getLayoutSummaries();
         const layoutExists = allLayouts.some((summary) => summary.name === name);
@@ -4845,6 +4932,9 @@ class MainController {
     async deleteLayout(name) {
         await this.bridge.send(OPERATIONS.deleteLayout.name, { name });
     }
+    async deleteLayoutById(layoutId) {
+        await this.bridge.send(OPERATIONS.deleteLayoutById.name, { layoutId });
+    }
     async exportLayout(predicate) {
         const allLayoutsResult = await this.bridge.send(OPERATIONS.exportAllLayouts.name);
         return allLayoutsResult.layouts.reduce((matchingLayouts, layout) => {
@@ -4857,6 +4947,9 @@ class MainController {
     async saveLayout(config) {
         return await this.bridge.send(OPERATIONS.saveLayout.name, config);
     }
+    async saveLayoutById(config) {
+        return await this.bridge.send(OPERATIONS.saveLayoutById.name, config);
+    }
     async importLayouts(layouts, mode) {
         if (isDesktop()) {
             try {
@@ -4869,10 +4962,10 @@ class MainController {
         }
         await this.base.importLayouts(layouts, mode);
     }
-    handleOnSaved(callback) {
+    async handleOnSaved(callback) {
         return this.base.handleOnSaved(callback);
     }
-    handleOnRemoved(callback) {
+    async handleOnRemoved(callback) {
         return this.base.handleOnRemoved(callback);
     }
     async bundleWorkspaceTo(type, workspaceId) {
@@ -5193,6 +5286,7 @@ class IoC {
     windows;
     layouts;
     contexts;
+    layoutsV2;
     _controllerInstance;
     _bridgeInstance;
     _transportInstance;
@@ -5201,15 +5295,16 @@ class IoC {
     _baseController;
     _shortcutsController;
     _closingController;
-    constructor(agm, windows, layouts, contexts) {
+    constructor(agm, windows, layouts, contexts, layoutsV2) {
         this.agm = agm;
         this.windows = windows;
         this.layouts = layouts;
         this.contexts = contexts;
+        this.layoutsV2 = layoutsV2;
     }
     get baseController() {
         if (!this._baseController) {
-            this._baseController = new BaseController(this, this.windows, this.contexts, this.layouts);
+            this._baseController = new BaseController(this, this.windows, this.contexts, this.layouts, this.layoutsV2);
         }
         return this._baseController;
     }
@@ -5364,7 +5459,7 @@ class IoC {
     }
 }
 
-var version = "4.6.0";
+var version = "5.0.0-next.0";
 
 const composeAPI = (glue, ioc) => {
     const controller = ioc.controller;
@@ -5432,6 +5527,10 @@ const composeAPI = (glue, ioc) => {
         checkThrowCallback(predicate);
         return controller.getParent(predicate);
     };
+    const restoreWorkspaceById = async (options) => {
+        const validatedOptions = restoreWorkspaceByIdConfigDecoder.runWithException(options);
+        return controller.restoreWorkspaceById(validatedOptions);
+    };
     const restoreWorkspace = async (name, options) => {
         nonEmptyStringDecoder.runWithException(name);
         const validatedOptions = restoreWorkspaceConfigDecoder.runWithException(options);
@@ -5454,6 +5553,10 @@ const composeAPI = (glue, ioc) => {
             nonEmptyStringDecoder.runWithException(name);
             return controller.deleteLayout(name);
         },
+        deleteById: async (layoutId) => {
+            nonEmptyStringDecoder.runWithException(layoutId);
+            return controller.deleteLayoutById(layoutId);
+        },
         export: async (predicate) => {
             checkThrowCallback(predicate, true);
             return controller.exportLayout(predicate);
@@ -5469,6 +5572,10 @@ const composeAPI = (glue, ioc) => {
             const verifiedConfig = workspaceLayoutSaveConfigDecoder.runWithException(config);
             return controller.saveLayout(verifiedConfig);
         },
+        saveById: async (config) => {
+            const verifiedConfig = workspaceLayoutSaveByIdConfigDecoder.runWithException(config);
+            return controller.saveLayoutById(verifiedConfig);
+        },
         onSaved: async (callback) => {
             checkThrowCallback(callback);
             return controller.handleOnSaved(callback);
@@ -5688,6 +5795,7 @@ const composeAPI = (glue, ioc) => {
         getWindow,
         getBox: getParent,
         restoreWorkspace,
+        restoreWorkspaceById,
         createWorkspace,
         createEmptyFrame,
         waitForFrame,
@@ -5711,7 +5819,7 @@ const composeAPI = (glue, ioc) => {
 };
 
 const factoryFunction = async (io) => {
-    const ioc = new IoC(io.agm, io.windows, io.layouts, io.contexts);
+    const ioc = new IoC(io.agm, io.windows, io.layouts, io.contexts, io.layouts.v2);
     const actualWindowId = io.interop.instance.windowId;
     await ioc.initiate(actualWindowId);
     io.workspaces = composeAPI(io, ioc);