lucid-extension-sdk 1.0.0

package/src/document/pageproxy.ts

@@ -0,0 +1,128 @@
+import {ElementProxy} from './elementproxy';
+import {MapProxy} from './mapproxy';
+import {BlockProxy} from './blockproxy';
+import {LineProxy} from './lineproxy';
+import {GroupProxy} from './groupproxy';
+import {BlockDefinition} from './blockdefinition';
+import {
+    EndpointDefinition,
+    LineDefinition,
+    isBlockEndpointDefinition,
+    isLineEndpointDefinition,
+} from './linedefinition';
+
+export class PageProxy extends ElementProxy {
+    public readonly blocks = new MapProxy<string, BlockProxy>(this.client, 'lb', {id: this.id}, (id) =>
+        this.client.getBlockProxy(id),
+    );
+
+    public readonly lines = new MapProxy<string, LineProxy>(
+        this.client,
+        'll',
+        {id: this.id},
+        (id) => new LineProxy(id, this.client),
+    );
+
+    public readonly groups = new MapProxy<string, GroupProxy>(
+        this.client,
+        'lg',
+        {id: this.id},
+        (id) => new GroupProxy(id, this.client),
+    );
+
+    public readonly allBlocks = new MapProxy<string, BlockProxy>(this.client, 'lb', {id: this.id, d: true}, (id) =>
+        this.client.getBlockProxy(id),
+    );
+
+    public readonly allLines = new MapProxy<string, LineProxy>(
+        this.client,
+        'll',
+        {id: this.id, d: true},
+        (id) => new LineProxy(id, this.client),
+    );
+
+    public readonly allGroups = new MapProxy<string, GroupProxy>(
+        this.client,
+        'lg',
+        {id: this.id, d: true},
+        (id) => new GroupProxy(id, this.client),
+    );
+
+    public addBlock(def: BlockDefinition): BlockProxy {
+        const properties: Record<string, any> = {};
+        properties['BoundingBox'] = def.boundingBox;
+
+        const id: string = this.client.sendCommand('cb', {
+            'p': this.id,
+            'c': def.className,
+        });
+
+        const block = this.client.getBlockProxy(id);
+
+        for (const key in properties) {
+            block.properties.set(key, properties[key]);
+        }
+
+        return block;
+    }
+
+    public addLine(def: LineDefinition): LineProxy {
+        const properties: Record<string, any> = {};
+
+        const setEndpoint = (ep: EndpointDefinition, name: string) => {
+            if (isBlockEndpointDefinition(ep)) {
+                const bb = ep.connection.getBoundingBox();
+                properties[name] = {
+                    'Style': ep.style,
+                    'x': bb.x + bb.w * ep.linkX,
+                    'y': bb.y + bb.h * ep.linkY,
+                    'Block': ep.connection.id,
+                    'LinkX': ep.linkX,
+                    'LinkY': ep.linkY,
+                    'Inside': ep.inside,
+                    'AutoLink': ep.autoLink,
+                    'Padding': ep.padding,
+                };
+            } else if (isLineEndpointDefinition(ep)) {
+                properties[name] = {
+                    'Style': ep.style,
+                    'Line': ep.connection.id,
+                    'LineP': ep.position,
+                    ...ep.connection.getRelativePosition(ep.position), //x,y
+                };
+            } else {
+                properties[name] = {
+                    'Style': ep.style,
+                    'x': ep.x,
+                    'y': ep.y,
+                };
+            }
+        };
+        setEndpoint(def.endpoint1, 'Endpoint1');
+        setEndpoint(def.endpoint2, 'Endpoint2');
+
+        const id = this.client.sendCommand('cl', {
+            'p': this.id,
+        });
+
+        const line = new LineProxy(id, this.client);
+
+        for (const key in properties) {
+            line.properties.set(key, properties[key]);
+        }
+
+        return line;
+    }
+
+    public setTitle(title: string) {
+        this.properties.set('Title', title);
+    }
+
+    public getTitle(): string {
+        return this.properties.get('Title');
+    }
+
+    public delete() {
+        this.client.sendCommand('dp', this.id);
+    }
+}

package/src/editorclient.ts

@@ -0,0 +1,109 @@
+import {BlockProxy} from './document/blockproxy';
+import {DocumentProxy} from './document/documentproxy';
+import {ElementProxy} from './document/elementproxy';
+import {GroupProxy} from './document/groupproxy';
+import {LineProxy} from './document/lineproxy';
+import {PageProxy} from './document/pageproxy';
+import {findProxyClass} from './document/blockclasses/blockproxyregistry';
+
+export class EditorClient {
+    private nextId = 0;
+    private readonly oneTimeCallbacks = new Map<number, (value: any) => void>();
+    private readonly actions = new Map<string, (value: any) => void>();
+
+    public killExtension() {
+        this.sendCommand('k');
+    }
+
+    public reloadExtension() {
+        this.sendCommand('r');
+    }
+
+    public download(filename: string, data: string, mime: string, base64: boolean) {
+        this.sendCommand('d', {
+            'f': filename,
+            'd': data,
+            'm': mime,
+            'b64': base64,
+        });
+    }
+
+    public showModal(title: string, width: number, height: number, content: string) {
+        this.sendCommand('sm', {
+            't': title,
+            'w': width,
+            'h': height,
+            'c': content,
+        });
+    }
+
+    public hideModal() {
+        this.sendCommand('hm');
+    }
+
+    public registerOneTimeAction(cb: (value: any) => void): number {
+        const id = this.nextId++;
+        this.oneTimeCallbacks.set(id, cb);
+        return id;
+    }
+
+    public registerAction(name: string, cb: (value: any) => void): void {
+        this.actions.set(name, cb);
+    }
+
+    public deleteAction(name: string) {
+        this.actions.delete(name);
+    }
+
+    public actionExists(name: string) {
+        return this.actions.has(name);
+    }
+
+    public sendCommand(name: string, params?: any): any {
+        return lucid.executeCommand(name, params);
+    }
+
+    public getBlockProxy(id: string): BlockProxy {
+        const className = this.sendCommand('gp', {'id': id, 'p': 'ClassName'});
+        const proxy = findProxyClass(className);
+        if (proxy) {
+            return new proxy(id, this);
+        } else {
+            return new BlockProxy(id, this);
+        }
+    }
+
+    public loadBlockClasses(classNames: string[]): Promise<undefined> {
+        return this.sendCommand('lbc', classNames);
+    }
+
+    public getElementProxy(id: string) {
+        const type: string = this.sendCommand('get', id);
+        switch (type) {
+            case 'block':
+                return this.getBlockProxy(id);
+            case 'line':
+                return new LineProxy(id, this);
+            case 'page':
+                return new PageProxy(id, this);
+            case 'document':
+                return new DocumentProxy(this);
+            case 'group':
+                return new GroupProxy(id, this);
+            default:
+                return new ElementProxy(id, this);
+        }
+    }
+
+    constructor() {
+        lucid.listen((msg: any) => {
+            const resolver = this.oneTimeCallbacks.get(msg['id']);
+            if (resolver) {
+                resolver(msg['r']);
+                this.oneTimeCallbacks.delete(msg['id']);
+            } else {
+                this.actions.get(msg['id'])?.(msg);
+            }
+        });
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './editorclient';
+export * from './document/documentproxy';
+export * from './ui/menu';
+export * from './ui/viewport';

package/src/interop.d.ts

@@ -0,0 +1,8 @@
+declare module lucid {
+    export function executeCommand(name: string, params: any): any;
+    export function listen(msg: any): void;
+}
+
+declare module console {
+    export function log(...args: any[]): void;
+}

package/src/math.ts

@@ -0,0 +1,2 @@
+export type Point = {x: number; y: number};
+export type Box = {x: number; y: number; w: number; h: number};

package/src/ui/menu.ts

@@ -0,0 +1,43 @@
+import {EditorClient} from '../editorclient';
+export const enum MenuType {
+    Main = 0,
+    Context = 1,
+}
+
+export interface CustomMenuItem {
+    //The menu item itself
+    label: string;
+    action: string;
+
+    //Where to display it
+    menuType: MenuType;
+
+    /**
+     * The standard menu item to display this item after.
+     * Examples:
+     * ['file'] -> put at the top of the File menu
+     * ['file', 'duplicate'] -> put after Duplicate in the File menu
+     * ['file', 'export'] -> put at the top of the export submenu
+     *
+     * The path is interpreted up to the first invalid entry.
+     * If the resulting valid path is empty, a new top-level menu named Add-ons appears before Help and this is added
+     */
+    path: string[];
+}
+
+export class Menu {
+    constructor(private readonly client: EditorClient) {}
+
+    public addMenuItem(item: CustomMenuItem) {
+        if (!this.client.actionExists(item.action)) {
+            throw new Error('Unregistered action: ' + item.action);
+        }
+
+        this.client.sendCommand('ami', {
+            'l': item.label,
+            'a': item.action,
+            't': item.menuType,
+            'p': item.path,
+        });
+    }
+}

package/src/ui/viewport.ts

@@ -0,0 +1,22 @@
+import {ItemProxy} from '../document/itemproxy';
+import {PageProxy} from '../document/pageproxy';
+import {EditorClient} from '../editorclient';
+
+export class Viewport {
+    constructor(private readonly client: EditorClient) {}
+
+    public getSelectedItems(): ItemProxy[] {
+        const ids: string[] = this.client.sendCommand('gs');
+        return ids
+            .map((id) => this.client.getElementProxy(id))
+            .filter((proxy) => proxy instanceof ItemProxy) as ItemProxy[];
+    }
+
+    public getCurrentPage() {
+        return new PageProxy(this.client.sendCommand('gcp'), this.client);
+    }
+
+    public setCurrentPage(page: PageProxy) {
+        this.client.sendCommand('scp', page.id);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+    "compilerOptions": {
+        "declaration": true,
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        "forceConsistentCasingInFileNames": true,
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "newLine": "lf",
+        "noEmitHelpers": true,
+        "noEmitOnError": false,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noUnusedLocals": false,
+        "pretty": true,
+        "removeComments": false,
+        "skipLibCheck": true,
+        "sourceMap": false,
+        "strictBindCallApply": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "strictPropertyInitialization": true,
+        "target": "ES2017",
+        "types": ["node"],
+        "lib": ["dom", "es5", "es6", "ES2016.Array.Include", "ES2017.String", "ES2018.Promise"],
+        "outDir": "bin",
+    },
+    "files":[
+        "src/interop.d.ts",
+    ],
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}