@interopio/workspaces-api 3.2.1 → 3.2.3

package/rollup.config.js

@@ -1,54 +0,0 @@
-const typescript = require('rollup-plugin-typescript2');
-const terser = require('@rollup/plugin-terser');
-const commonjs = require('@rollup/plugin-commonjs');
-const resolve = require('@rollup/plugin-node-resolve');
-const json = require('@rollup/plugin-json');
-const pkg = require('./package.json');
-const del = require('rollup-plugin-delete');
-
-module.exports = {
-    input: 'src/index.ts',
-    output: [
-        {
-            file: pkg.main,
-            name: 'workspaces',
-            format: 'umd',
-            sourcemap: true
-        },
-        {
-            file: './dist/workspaces.umd.min.js',
-            name: 'workspaces.min',
-            format: 'umd',
-            plugins: [terser()]
-        },
-        {
-            file: pkg.module,
-            format: 'es',
-            sourcemap: true
-        },
-    ],
-    external: [
-        //...Object.keys(pkg.dependencies || {}),
-        ...Object.keys(pkg.peerDependencies || {}),
-    ],
-
-    plugins: [
-        del({ targets: 'dist/*' }),
-        typescript({
-            typescript: require('typescript')
-        }),
-        // Allow json resolution
-        json(),
-        // // Allow bundling cjs modules (unlike webpack, rollup doesn't understand cjs)
-        commonjs(),
-        // // Allow node_modules resolution, so you can use 'external' to control
-        // // which external modules to include in the bundle
-        // // https://github.com/rollup/rollup-plugin-node-resolve#usage
-        resolve({
-            mainFields: ['module', 'main', 'browser']
-        }),
-
-        // // Resolve source maps to the original source
-        // sourceMaps(),
-    ],
-};

package/src/builders/baseBuilder.ts

@@ -1,50 +0,0 @@
-import { ParentBuilder } from "./parentBuilder";
-import { ChildDefinition, ChildBuilder } from "../types/builders";
-import { parentDefinitionDecoder, swimlaneWindowDefinitionDecoder } from "../shared/decoders";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { WorkspaceBuilder } from "./workspaceBuilder";
-
-export class BaseBuilder {
-
-    constructor(
-        private readonly getBuilder: (config: IOConnectWorkspaces.BuilderConfig) => ParentBuilder | WorkspaceBuilder,
-    ) { }
-
-    public wrapChildren(children: ChildDefinition[]): ChildBuilder[] {
-        return children.map((child) => {
-            if (child.type === "window") {
-                return child;
-            }
-
-            return this.getBuilder({ type: child.type, definition: child }) as ParentBuilder;
-        });
-    }
-
-    public add(type: "row" | "column" | "group", children: ChildBuilder[], definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const validatedDefinition = parentDefinitionDecoder.runWithException(definition);
-
-        const childBuilder = this.getBuilder({ type, definition: validatedDefinition }) as ParentBuilder;
-
-        children.push(childBuilder);
-
-        return childBuilder;
-    }
-
-    public addWindow(children: ChildBuilder[], definition: IOConnectWorkspaces.WorkspaceWindowDefinition): void {
-        const validatedDefinition = swimlaneWindowDefinitionDecoder.runWithException(definition);
-
-        validatedDefinition.type = "window";
-
-        children.push(validatedDefinition);
-    }
-
-    public serializeChildren(children: ChildBuilder[]): ChildDefinition[] {
-        return children.map((child) => {
-            if (child instanceof ParentBuilder) {
-                return child.serialize();
-            } else {
-                return child as IOConnectWorkspaces.WorkspaceWindowDefinition;
-            }
-        });
-    }
-}

package/src/builders/parentBuilder.ts

@@ -1,62 +0,0 @@
-import { BaseBuilder } from "./baseBuilder";
-import { ChildBuilder } from "../types/builders";
-import { IOConnectWorkspaces } from "../../workspaces";
-
-interface PrivateData {
-    definition: IOConnectWorkspaces.BoxDefinition;
-    base: BaseBuilder;
-    children: ChildBuilder[];
-}
-
-const privateData = new WeakMap<ParentBuilder, PrivateData>();
-
-export class ParentBuilder implements ParentBuilder {
-
-    constructor(
-        definition: IOConnectWorkspaces.BoxDefinition,
-        base: BaseBuilder
-    ) {
-        const children = base.wrapChildren(definition.children);
-
-        delete definition.children;
-
-        privateData.set(this, { base, children, definition });
-    }
-
-    public get type(): "column" | "row" | "group" {
-        return privateData.get(this).definition.type;
-    }
-
-    public addColumn(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("column", privateData.get(this).children, definition);
-    }
-
-    public addRow(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("row", privateData.get(this).children, definition);
-    }
-
-    public addGroup(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("group", privateData.get(this).children, definition);
-    }
-
-    public addWindow(definition: IOConnectWorkspaces.WorkspaceWindowDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        base.addWindow(privateData.get(this).children, definition);
-
-        return this;
-    }
-
-    public serialize(): IOConnectWorkspaces.BoxDefinition {
-        const definition = privateData.get(this).definition;
-        definition.children = privateData.get(this).base.serializeChildren(privateData.get(this).children);
-        return definition;
-    }
-
-}

package/src/builders/workspaceBuilder.ts

@@ -1,102 +0,0 @@
-import { BaseBuilder } from "./baseBuilder";
-import { ChildBuilder } from "../types/builders";
-import { ParentBuilder } from "./parentBuilder";
-import { workspaceBuilderCreateConfigDecoder, nonNegativeNumberDecoder } from "../shared/decoders";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { WorkspacesController } from "../types/controller";
-
-interface PrivateData {
-    definition: IOConnectWorkspaces.WorkspaceDefinition;
-    children: ChildBuilder[];
-    base: BaseBuilder;
-    controller: WorkspacesController;
-}
-
-const privateData = new WeakMap<WorkspaceBuilder, PrivateData>();
-
-export class WorkspaceBuilder implements WorkspaceBuilder {
-
-    constructor(
-        definition: IOConnectWorkspaces.WorkspaceDefinition,
-        base: BaseBuilder,
-        controller: WorkspacesController
-    ) {
-        const children = base.wrapChildren(definition.children);
-
-        delete definition.children;
-
-        privateData.set(this, { base, children, definition, controller });
-    }
-
-    public addColumn(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        const areAllColumns = children.every((child) => child instanceof ParentBuilder && child.type === "column");
-
-        if (!areAllColumns) {
-            throw new Error("Cannot add a column to this workspace, because there are already children of another type");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("column", children, definition);
-    }
-
-    public addRow(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        const areAllRows = children.every((child) => child instanceof ParentBuilder && child.type === "row");
-
-        if (!areAllRows) {
-            throw new Error("Cannot add a row to this workspace, because there are already children of another type");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("row", children, definition);
-    }
-
-    public addGroup(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        if (children.length !== 0) {
-            throw new Error("Cannot add a group to this workspace, because there are already defined children.");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("group", children, definition);
-    }
-
-    public addWindow(definition: IOConnectWorkspaces.WorkspaceWindowDefinition): WorkspaceBuilder {
-        const children = privateData.get(this).children;
-
-        if (children.length !== 0) {
-            throw new Error("Cannot add a window to this workspace, because there are already defined children.");
-        }
-
-        const base = privateData.get(this).base;
-
-        base.addWindow(children, definition);
-
-        return this;
-    }
-
-    public getChildAt(index: number): ChildBuilder {
-        nonNegativeNumberDecoder.runWithException(index);
-        const data = privateData.get(this).children;
-
-        return data[index];
-    }
-
-    public async create(config?: IOConnectWorkspaces.WorkspaceCreateConfig): Promise<IOConnectWorkspaces.Workspace> {
-        const saveConfig = workspaceBuilderCreateConfigDecoder.runWithException(config);
-
-        const definition = privateData.get(this).definition;
-        definition.children = privateData.get(this).base.serializeChildren(privateData.get(this).children);
-
-        const controller = privateData.get(this).controller;
-
-        return controller.createWorkspace(definition, saveConfig);
-    }
-}

package/src/communication/bridge.ts

@@ -1,263 +0,0 @@
-import { CallbackRegistry, UnsubscribeFunction } from "callback-registry";
-import { SubscriptionConfig, ActiveSubscription, WorkspaceEventType, WorkspaceEventAction, WorkspacePayload, WorkspaceEventScope, PendingSubscription } from "../types/subscription";
-import { ClientOperations, CLIENT_OPERATIONS, STREAMS } from "./constants";
-import { OPERATIONS } from "./constants";
-import { eventTypeDecoder, streamRequestArgumentsDecoder, workspaceEventActionDecoder } from "../shared/decoders";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { InteropTransport } from "./interop-transport";
-import { PromiseWrapper } from "../shared/promiseWrapper";
-import { Instance } from "../types/glue";
-
-export class Bridge {
-
-    private readonly activeSubscriptions: ActiveSubscription[] = [];
-    private readonly pendingSubScriptions: PendingSubscription[] = [];
-
-    constructor(
-        private readonly transport: InteropTransport,
-        private readonly registry: CallbackRegistry
-    ) { }
-
-    public async createCoreEventSubscription(): Promise<void> {
-        await this.transport.coreSubscriptionReady(this.handleCoreEvent.bind(this));
-    }
-
-    public handleCoreSubscription(config: SubscriptionConfig): UnsubscribeFunction {
-        const registryKey = `${config.eventType}-${config.action}`;
-        const scope = config.scope;
-        const scopeId = config.scopeId;
-
-        return this.registry.add(registryKey, (args) => {
-            const scopeConfig = {
-                type: scope,
-                id: scopeId
-            };
-
-            const receivedIds = {
-                frame: args.frameSummary?.id || args.windowSummary?.config.frameId,
-                workspace: args.workspaceSummary?.id || args.windowSummary?.config.workspaceId,
-                container: args.containerSummary?.itemId,
-                window: args.windowSummary?.itemId
-            };
-
-            const shouldInvokeCallback = this.checkScopeMatch(scopeConfig, receivedIds);
-
-            if (!shouldInvokeCallback) {
-                return;
-            }
-
-            config.callback(args);
-        });
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public async send<T>(operationName: string, operationArgs?: any): Promise<T> {
-
-        const operationDefinition = Object.values(OPERATIONS).find((operation) => operation.name === operationName);
-
-        if (!operationDefinition) {
-            throw new Error(`Cannot find definition for operation name: ${operationName}`);
-        }
-
-        if (operationDefinition.argsDecoder) {
-            try {
-                operationDefinition.argsDecoder.runWithException(operationArgs);
-            } catch (error) {
-                throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-            }
-        }
-
-        try {
-            const operationResult = await this.transport.transmitControl(operationDefinition.name, operationArgs);
-
-            operationDefinition.resultDecoder.runWithException(operationResult);
-
-            return operationResult;
-        } catch (error) {
-            if (error.kind) {
-                throw new Error(`Unexpected internal incoming validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-            }
-            throw new Error(error.message);
-        }
-    }
-
-    public async subscribe(config: SubscriptionConfig): Promise<IOConnectWorkspaces.Unsubscribe> {
-        const pendingSub = this.getPendingSubscription(config);
-        if (pendingSub) {
-            await pendingSub.promise;
-        }
-
-        let activeSub = this.getActiveSubscription(config);
-        const registryKey = this.getRegistryKey(config);
-
-        if (!activeSub) {
-            const pendingPromise = new PromiseWrapper<void>();
-            const pendingSubscription = {
-                streamType: config.eventType,
-                level: config.scope,
-                levelId: config.scopeId,
-                promise: pendingPromise.promise
-            };
-            this.pendingSubScriptions.push(pendingSubscription);
-            try {
-                const stream = STREAMS[config.eventType];
-                const gdSub = await this.transport.subscribe(stream.name, this.getBranchKey(config), config.eventType);
-
-                gdSub.onData((streamData) => {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const data = streamData.data as { action: string; payload: any };
-
-                    // important to decode without exception, because we do not want to throw an exception here
-                    const requestedArgumentsResult = streamRequestArgumentsDecoder.run(streamData.requestArguments);
-                    const actionResult = workspaceEventActionDecoder.run(data.action);
-
-                    if (!requestedArgumentsResult.ok || !actionResult.ok) {
-                        return;
-                    }
-
-                    const streamType = requestedArgumentsResult.result.type;
-                    const branch = requestedArgumentsResult.result.branch;
-
-                    const keyToExecute = `${streamType}-${branch}-${actionResult.result}`;
-                    const validatedPayload = STREAMS[streamType].payloadDecoder.run(data.payload);
-                    if (!validatedPayload.ok) {
-                        return;
-                    }
-
-                    this.registry.execute(keyToExecute, validatedPayload.result);
-                });
-
-                activeSub = {
-                    streamType: config.eventType,
-                    level: config.scope,
-                    levelId: config.scopeId,
-                    callbacksCount: 0,
-                    gdSub
-                };
-
-                this.activeSubscriptions.push(activeSub);
-
-                pendingPromise.resolve();
-            } catch (error) {
-                pendingPromise.reject(error);
-
-                throw error;
-            } finally {
-                this.removePendingSubscription(pendingSubscription);
-            }
-
-        }
-
-        const unsubscribe = this.registry.add(registryKey, config.callback);
-
-        ++activeSub.callbacksCount;
-
-        return (): void => {
-            unsubscribe();
-            --activeSub.callbacksCount;
-
-            if (activeSub.callbacksCount === 0) {
-                activeSub.gdSub.close();
-                this.activeSubscriptions.splice(this.activeSubscriptions.indexOf(activeSub), 1);
-            }
-        };
-    }
-
-    public onOperation(callback: (operation: ClientOperations, caller: Instance) => void) {
-
-        const wrappedCallback = (payload: ClientOperations, caller: Instance) => {
-            const operationName = payload.operation;
-            const operationArgs = payload.data;
-            const operationDefinition = Object.values(CLIENT_OPERATIONS).find((operation) => operation.name === operationName);
-
-            if (!operationDefinition) {
-                throw new Error(`Cannot find definition for operation name: ${operationName}`);
-            }
-
-            if (operationDefinition.argsDecoder) {
-                try {
-                    operationDefinition.argsDecoder.runWithException(operationArgs);
-                } catch (error) {
-                    throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-                }
-            }
-
-            callback(payload, caller);
-        };
-
-        return this.transport.onInternalMethodInvoked("control", wrappedCallback);
-    }
-
-    private checkScopeMatch(scope: { type: WorkspaceEventScope; id?: string }, receivedIds: { frame: string; workspace: string; container: string; window: string }): boolean {
-
-        if (scope.type === "global") {
-            return true;
-        }
-
-        if (scope.type === "frame" && scope.id === receivedIds.frame) {
-            return true;
-        }
-
-        if (scope.type === "workspace" && scope.id === receivedIds.workspace) {
-            return true;
-        }
-
-        if (scope.type === "container" && scope.id === receivedIds.container) {
-            return true;
-        }
-
-        if (scope.type === "window" && scope.id === receivedIds.window) {
-            return true;
-        }
-
-        return false;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    private handleCoreEvent(args: any): void {
-        const data = args.data;
-        try {
-            const verifiedAction: WorkspaceEventAction = workspaceEventActionDecoder.runWithException(data.action);
-            const verifiedType: WorkspaceEventType = eventTypeDecoder.runWithException(data.type);
-            const verifiedPayload: WorkspacePayload = STREAMS[verifiedType].payloadDecoder.runWithException(data.payload);
-
-            const registryKey = `${verifiedType}-${verifiedAction}`;
-
-            this.registry.execute(registryKey, verifiedPayload);
-        } catch (error) {
-            console.warn(`Cannot handle event with data ${JSON.stringify(data)}, because of validation error: ${error.message}`);
-        }
-    }
-
-    private getBranchKey(config: SubscriptionConfig): string {
-        return config.scope === "global" ? config.scope : `${config.scope}_${config.scopeId}`;
-    }
-
-    private getRegistryKey(config: SubscriptionConfig): string {
-        return `${config.eventType}-${this.getBranchKey(config)}-${config.action}`;
-    }
-
-    private getActiveSubscription(config: SubscriptionConfig): ActiveSubscription {
-        return this.activeSubscriptions
-            .find((activeSub) => activeSub.streamType === config.eventType &&
-                activeSub.level === config.scope &&
-                activeSub.levelId === config.scopeId
-            );
-    }
-
-    private getPendingSubscription(config: SubscriptionConfig): PendingSubscription {
-        return this.pendingSubScriptions
-            .find((activeSub) => activeSub.streamType === config.eventType &&
-                activeSub.level === config.scope &&
-                activeSub.levelId === config.scopeId
-            );
-    }
-
-    private removePendingSubscription(pendingSubscription: PendingSubscription): void {
-        const index = this.pendingSubScriptions.indexOf(pendingSubscription);
-
-        if (index >= 0) {
-            this.pendingSubScriptions.splice(index, 1);
-        }
-    }
-}