@interopio/workspaces-api 3.2.1 → 3.2.3

package/src/models/base/base.ts

@@ -1,397 +0,0 @@
-import { Workspace } from "../workspace";
-import { ParentBuilder } from "../../builders/parentBuilder";
-import { strictParentDefinitionDecoder, swimlaneWindowDefinitionDecoder, checkThrowCallback } from "../../shared/decoders";
-import { SubParent, AllParentTypes, Child, SubParentTypes, AllParent, ContainerLockConfig } from "../../types/builders";
-import { PrivateDataManager } from "../../shared/privateDataManager";
-import { ParentPrivateData, WorkspacePrivateData } from "../../types/privateData";
-import { Window } from "../../models/window";
-import { IOConnectWorkspaces } from "../../../workspaces";
-import { Group } from "../group";
-import { Row } from "../row";
-import { Column } from "../column";
-import { ColumnSnapshotConfig, GroupSnapshotConfig, RowSnapshotConfig } from "../../types/protocol";
-import { SubscriptionConfig } from "../../types/subscription";
-
-interface PrivateData {
-    manager: PrivateDataManager;
-}
-
-const data = new WeakMap<Base, PrivateData>();
-
-const getData = (base: Base, model: AllParentTypes): WorkspacePrivateData | ParentPrivateData => {
-    const manager = data.get(base).manager;
-
-    if (model instanceof Workspace) {
-        return manager.getWorkspaceData(model);
-    }
-
-    return data.get(base).manager.getParentData(model as SubParentTypes);
-};
-
-export class Base {
-    public frameId: string;
-    public workspaceId: string;
-    public positionIndex: number;
-
-    constructor(dataManager: PrivateDataManager) {
-        data.set(this, { manager: dataManager });
-    }
-
-    public getId(model: AllParentTypes): string {
-        return getData(this, model).id;
-    }
-
-    public getPositionIndex(model: AllParentTypes): number {
-        return getData(this, model).config.positionIndex;
-    }
-
-    public getWorkspaceId(model: AllParentTypes): string {
-        const privateData = getData(this, model) as ParentPrivateData;
-        return privateData.config.workspaceId || privateData.workspace.id;
-    }
-
-    public getFrameId(model: AllParentTypes): string {
-        return getData(this, model).frame.id;
-    }
-
-    public getAllChildren(model: AllParentTypes, predicate?: (child: Child) => boolean): Child[] {
-        checkThrowCallback(predicate, true);
-        const children = getData(this, model).children;
-
-        if (typeof predicate === "undefined") {
-            return children;
-        }
-
-        return children.filter(predicate);
-    }
-
-    public getMyParent(model: AllParentTypes): AllParentTypes {
-        if (model instanceof Workspace) {
-            return model;
-        }
-        return (getData(this, model) as ParentPrivateData).parent;
-    }
-
-    public getMyFrame(model: AllParentTypes): IOConnectWorkspaces.Frame {
-        return getData(this, model).frame;
-    }
-
-    public getMyWorkspace(model: AllParentTypes): Workspace {
-        if (model instanceof Workspace) {
-            return model;
-        }
-        return (getData(this, model) as ParentPrivateData).workspace;
-    }
-
-    public async addWindow(model: AllParentTypes, definition: IOConnectWorkspaces.WorkspaceWindowDefinition, parentType: AllParent): Promise<IOConnectWorkspaces.WorkspaceWindow> {
-        if (!definition.appName && !definition.windowId) {
-            throw new Error("The window definition should contain either an appName or a windowId");
-        }
-
-        const validatedDefinition = swimlaneWindowDefinitionDecoder.runWithException(definition);
-        const controller = getData(this, model).controller;
-
-        const operationResult = await controller.add("window", getData(this, model).id, parentType, validatedDefinition);
-
-        if (model instanceof Workspace) {
-            await model.refreshReference();
-            return model.getWindow(w => w.elementId === operationResult.itemId);
-        }
-
-        const myWorkspace = this.getMyWorkspace(model);
-        await myWorkspace.refreshReference();
-
-        return myWorkspace.getWindow(w => w.elementId === operationResult.itemId);
-    }
-
-    public async addParent<T>(model: AllParentTypes, typeToAdd: SubParent, parentType: AllParent, definition?: IOConnectWorkspaces.BoxDefinition | ParentBuilder): Promise<T> {
-        const parentDefinition = this.transformDefinition(typeToAdd, definition);
-        const controller = getData(this, model).controller;
-
-        const newParentId = (await controller.add("container", getData(this, model).id, parentType, parentDefinition)).itemId;
-
-        if (model instanceof Workspace) {
-            await model.refreshReference();
-            return model.getBox((parent) => parent.id === newParentId) as unknown as T;
-        }
-
-        const myWorkspace = this.getMyWorkspace(model);
-        await myWorkspace.refreshReference();
-
-        return myWorkspace.getBox((parent) => parent.id === newParentId) as unknown as T;
-    }
-
-    public async removeChild(model: AllParentTypes, predicate: (child: Child) => boolean): Promise<void> {
-        checkThrowCallback(predicate);
-        const child = this.getAllChildren(model).find(predicate);
-        if (!child) {
-            return;
-        }
-
-        await child.close();
-
-        if (model instanceof Workspace) {
-
-            await model.refreshReference();
-            return;
-        }
-
-        await this.getMyWorkspace(model).refreshReference();
-    }
-
-    public async maximize(model: SubParentTypes): Promise<void> {
-        const { controller, id } = getData(this, model);
-
-        await controller.maximizeItem(id);
-
-        await this.getMyWorkspace(model.parent).refreshReference();
-    }
-
-    public async restore(model: SubParentTypes): Promise<void> {
-        const { controller, id } = getData(this, model);
-
-        await controller.restoreItem(id);
-
-        await this.getMyWorkspace(model.parent).refreshReference();
-    }
-
-    public async close(model: SubParentTypes): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-
-        const controller = getData(this, model).controller;
-
-        await controller.closeItem(modelData.id);
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public async lockContainer(model: SubParentTypes, config?: ContainerLockConfig): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-
-        const controller = getData(this, model).controller;
-
-        await controller.lockContainer(modelData.id, model.type, config);
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public getAllowDrop(model: SubParentTypes): boolean {
-        return getData(this, model).config.allowDrop;
-    }
-
-    public getAllowDropLeft(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Property allowDropLeft is available only for groups and not on ${model.type} ${model.id}`);
-        }
-        return privateData.config.allowDropLeft;
-    }
-
-    public getAllowDropRight(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Property allowDropRight is available only for groups and not on ${model.type} ${model.id}`);
-        }
-        return privateData.config.allowDropRight;
-    }
-
-    public getAllowDropTop(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Property allowDropTop is available only for groups and not on ${model.type} ${model.id}`);
-        }
-        return privateData.config.allowDropTop;
-    }
-
-    public getAllowDropBottom(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Property allowDropBottom is available only for groups and not on ${model.type} ${model.id}`);
-        }
-        return privateData.config.allowDropBottom;
-    }
-
-    public getAllowDropHeader(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Property allowDropHeader is available only for groups and not on ${model.type} ${model.id}`);
-        }
-        return privateData.config.allowDropHeader;
-    }
-
-    public getAllowSplitters(model: Row | Column): boolean {
-        const privateData = getData(this, model);
-
-        if (privateData.type === "group") {
-            throw new Error(`Cannot get allow splitters from private data ${privateData.type}`);
-        }
-
-        return privateData.config.allowSplitters;
-    }
-
-    public getAllowExtract(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Cannot get allow extract from private data ${privateData.type} with config ${privateData.type !== "workspace" ? privateData.config.type : ""}`);
-        }
-        return privateData.config.allowExtract;
-    }
-
-    public getAllowReorder(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Cannot get allow extract from private data ${privateData.type} with config ${privateData.type !== "workspace" ? privateData.config.type : ""}`);
-        }
-        return privateData.config.allowReorder;
-    }
-
-    public getShowMaximizeButton(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Cannot get show maximize button from private data${privateData.type} with config ${privateData.type !== "workspace" ? privateData.config.type : ""}`);
-        }
-        return privateData.config.showMaximizeButton;
-    }
-
-    public getShowEjectButton(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Cannot get show eject button from private data${privateData.type} with config ${privateData.type !== "workspace" ? privateData.config.type : ""}`);
-        }
-        return privateData.config.showEjectButton;
-    }
-
-    public getShowAddWindowButton(model: Group): boolean {
-        const privateData = getData(this, model);
-        if (privateData.type !== "group") {
-            throw new Error(`Cannot get add window button from private data${privateData.type} with config ${privateData.type !== "workspace" ? privateData.config.type : ""}`);
-        }
-        return privateData.config.showAddWindowButton;
-    }
-
-    public getMinWidth(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.minWidth;
-    }
-
-    public getMaxWidth(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.maxWidth;
-    }
-
-    public getMinHeight(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.minHeight;
-    }
-
-    public getMaxHeight(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.maxHeight;
-    }
-
-    public getWidthInPx(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.widthInPx;
-    }
-
-    public getHeightInPx(model: SubParentTypes): number {
-        const privateData = getData(this, model);
-
-        return privateData.config.heightInPx;
-    }
-
-    public getIsPinned(model: Column | Row): boolean {
-        const privateData = getData(this, model);
-
-        return (privateData.config as RowSnapshotConfig | ColumnSnapshotConfig).isPinned;
-    }
-
-    public getIsMaximized(model: Column | Row | Group): boolean {
-        const privateData = getData(this, model);
-
-        return (privateData.config as RowSnapshotConfig | ColumnSnapshotConfig | GroupSnapshotConfig).isMaximized;
-    }
-
-    public getMaximizationBoundary(model: Column | Row): boolean {
-        const privateData = getData(this, model);
-
-        return (privateData.config as RowSnapshotConfig | ColumnSnapshotConfig).maximizationBoundary;
-    }
-
-    public async setHeight(model: Row, height: number): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-        const { controller, id } = modelData;
-
-        await controller.resizeItem(id, {
-            height
-        });
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public async setWidth(model: Column, width: number): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-        const { controller, id } = modelData;
-
-        await controller.resizeItem(id, {
-            width
-        });
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public async setSize(model: Group, width?: number, height?: number): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-        const { controller, id } = modelData;
-
-        await controller.resizeItem(id, {
-            width,
-            height
-        });
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public async setMaximizationBoundary(model: Row | Column, config: IOConnectWorkspaces.SetMaximizationBoundaryConfig): Promise<void> {
-        const modelData = getData(this, model) as ParentPrivateData;
-        const { controller, id } = modelData;
-
-        await controller.setMaximizationBoundary(id, config);
-
-        await this.getMyWorkspace(modelData.parent).refreshReference();
-    }
-
-    public async bundleTo(model: Group, type: "row" | "column") {
-        const modelData = getData(this, model) as ParentPrivateData;
-        const { controller, id } = modelData;
-
-        await controller.bundleItemTo(type, id);
-    }
-
-    public async processLocalSubscription(model: SubParentTypes, subscriptionConfig: SubscriptionConfig): Promise<IOConnectWorkspaces.Unsubscribe> {
-        return getData(this, model).controller.processLocalSubscription(subscriptionConfig, this.getId(model))
-    }
-
-    private transformDefinition(type: "group" | "row" | "column", definition?: IOConnectWorkspaces.BoxDefinition | ParentBuilder): IOConnectWorkspaces.BoxDefinition {
-        let parentDefinition: IOConnectWorkspaces.BoxDefinition;
-
-        if (typeof definition === "undefined") {
-            parentDefinition = { type, children: [] };
-        } else if (definition instanceof ParentBuilder) {
-            parentDefinition = definition.serialize();
-        } else {
-            if (typeof definition.type === "undefined") {
-                definition.type = type;
-            }
-            parentDefinition = strictParentDefinitionDecoder.runWithException(definition);
-            parentDefinition.children = parentDefinition.children || [];
-        }
-
-        return parentDefinition;
-    }
-}

package/src/models/column.ts

@@ -1,187 +0,0 @@
-import { Base } from "./base/base";
-import { IOConnectWorkspaces } from "../../workspaces.d";
-import { checkThrowCallback, columnLockConfigDecoder, nonNegativeNumberDecoder, setMaximizationBoundaryAPIConfigDecoder } from "../shared/decoders";
-import { SubscriptionConfig } from "../types/subscription";
-
-interface PrivateData {
-    base: Base;
-}
-
-const privateData = new WeakMap<Column, PrivateData>();
-
-const getBase = (model: Column): Base => {
-    return privateData.get(model).base;
-};
-
-export class Column implements IOConnectWorkspaces.Column {
-
-    constructor(base: Base) {
-        privateData.set(this, { base });
-    }
-
-    public get type(): "column" {
-        return "column";
-    }
-
-    public get id(): string {
-        return getBase(this).getId(this);
-    }
-
-    public get frameId(): string {
-        return getBase(this).getFrameId(this);
-    }
-
-    public get workspaceId(): string {
-        return getBase(this).getWorkspaceId(this);
-    }
-
-    public get positionIndex(): number {
-        return getBase(this).getPositionIndex(this);
-    }
-
-    public get children(): IOConnectWorkspaces.WorkspaceElement[] {
-        return getBase(this).getAllChildren(this);
-    }
-
-    public get parent(): IOConnectWorkspaces.Workspace | IOConnectWorkspaces.WorkspaceBox {
-        return getBase(this).getMyParent(this);
-    }
-
-    public get frame(): IOConnectWorkspaces.Frame {
-        return getBase(this).getMyFrame(this);
-    }
-
-    public get workspace(): IOConnectWorkspaces.Workspace {
-        return getBase(this).getMyWorkspace(this);
-    }
-
-    public get allowDrop(): boolean {
-        return getBase(this).getAllowDrop(this);
-    }
-
-    public get allowSplitters(): boolean {
-        return getBase(this).getAllowSplitters(this);
-    }
-
-    public get minWidth(): number {
-        return getBase(this).getMinWidth(this);
-    }
-
-    public get minHeight(): number {
-        return getBase(this).getMinHeight(this);
-    }
-
-    public get maxWidth(): number {
-        return getBase(this).getMaxWidth(this);
-    }
-
-    public get maxHeight(): number {
-        return getBase(this).getMaxHeight(this);
-    }
-
-    public get width(): number {
-        return getBase(this).getWidthInPx(this);
-    }
-
-    public get height(): number {
-        return getBase(this).getHeightInPx(this);
-    }
-
-    public get isPinned(): boolean {
-        return getBase(this).getIsPinned(this);
-    }
-
-    public get isMaximized(): boolean {
-        return getBase(this).getIsMaximized(this);
-    }
-
-    public get maximizationBoundary(): boolean {
-        return getBase(this).getMaximizationBoundary(this);
-    }
-
-    public addWindow(definition: IOConnectWorkspaces.WorkspaceWindowDefinition): Promise<IOConnectWorkspaces.WorkspaceWindow> {
-        return getBase(this).addWindow(this, definition, "column");
-    }
-
-    public async addGroup(definition?: IOConnectWorkspaces.BoxDefinition): Promise<IOConnectWorkspaces.Group> {
-        if (definition?.type && definition.type !== "group") {
-            throw new Error(`Expected a group definition, but received ${definition.type}`);
-        }
-        return getBase(this).addParent<IOConnectWorkspaces.Group>(this, "group", "column", definition);
-    }
-
-    public async addColumn(): Promise<Column> {
-        throw new Error("Adding columns as column children is not supported");
-    }
-
-    public async addRow(definition?: IOConnectWorkspaces.BoxDefinition): Promise<IOConnectWorkspaces.Row> {
-        if (definition?.type && definition.type !== "row") {
-            throw new Error(`Expected a row definition, but received ${definition.type}`);
-        }
-        return getBase(this).addParent<IOConnectWorkspaces.Row>(this, "row", "column", definition);
-    }
-
-    public removeChild(predicate: (child: IOConnectWorkspaces.WorkspaceElement) => boolean): Promise<void> {
-        return getBase(this).removeChild(this, predicate);
-    }
-
-    public maximize(): Promise<void> {
-        return getBase(this).maximize(this);
-    }
-
-    public restore(): Promise<void> {
-        return getBase(this).restore(this);
-    }
-
-    public close(): Promise<void> {
-        return getBase(this).close(this);
-    }
-
-    public lock(config?: IOConnectWorkspaces.ColumnLockConfig | ((config: IOConnectWorkspaces.ColumnLockConfig) => IOConnectWorkspaces.ColumnLockConfig)): Promise<void> {
-        let lockConfigResult = undefined;
-
-        if (typeof config === "function") {
-            const currentLockConfig = {
-                allowDrop: this.allowDrop,
-                allowSplitters: this.allowSplitters
-            };
-
-            lockConfigResult = config(currentLockConfig);
-
-        } else {
-            lockConfigResult = config;
-        }
-        const verifiedConfig = lockConfigResult === undefined ? undefined : columnLockConfigDecoder.runWithException(lockConfigResult);
-        return getBase(this).lockContainer(this, verifiedConfig);
-    }
-
-    public async setWidth(width: number): Promise<void> {
-        nonNegativeNumberDecoder.runWithException(width);
-        return getBase(this).setWidth(this, width);
-    }
-
-
-    public async onLockConfigurationChanged(callback: (config: IOConnectWorkspaces.ColumnLockConfig) => void): Promise<IOConnectWorkspaces.Unsubscribe> {
-        checkThrowCallback(callback);
-        const wrappedCallback = async (): Promise<void> => {
-            await this.workspace.refreshReference();
-            callback({
-                allowDrop: this.allowDrop,
-                allowSplitters: this.allowSplitters
-            });
-        };
-        const config: SubscriptionConfig = {
-            callback: wrappedCallback,
-            action: "lock-configuration-changed",
-            eventType: "container",
-            scope: "container"
-        };
-        const unsubscribe = await getBase(this).processLocalSubscription(this, config);
-        return unsubscribe;
-    }
-    public async setMaximizationBoundary(config: IOConnectWorkspaces.SetMaximizationBoundaryConfig): Promise<void> {
-        const validatedConfig = setMaximizationBoundaryAPIConfigDecoder.runWithException(config);
-        return getBase(this).setMaximizationBoundary(this, validatedConfig);
-
-    }
-}