lucid-extension-sdk 1.0.0

package/bin/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const enum OffsetType {
+    NW = 0,
+    NE = 1,
+    SE = 2,
+    SW = 3,
+    MOVE = 4,
+    ROTATE = 5,
+    SCALE = 6,
+    CUSTOM = 7,
+    N = 8,
+    E = 9,
+    S = 10,
+    W = 11
+}

package/bin/constants.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/document/blockclasses/blockproxyregistry.d.ts

@@ -0,0 +1,5 @@
+import { BlockProxy } from '../blockproxy';
+export declare type BlockProxyConstructor = typeof BlockProxy & {
+    classNameRegex: RegExp;
+};
+export declare function findProxyClass(className: string): BlockProxyConstructor | undefined;

package/bin/document/blockclasses/blockproxyregistry.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const erdblockproxy_1 = require("./erdblockproxy");
+const allProxyClasses = [erdblockproxy_1.ERDBlockProxy];
+function findProxyClass(className) {
+    return allProxyClasses.find((proxy) => proxy.classNameRegex.test(className));
+}
+exports.findProxyClass = findProxyClass;

package/bin/document/blockclasses/erdblockproxy.d.ts

@@ -0,0 +1,15 @@
+import { BlockProxy } from '../blockproxy';
+export declare class ERDFieldProxy {
+    private readonly block;
+    private readonly index;
+    constructor(block: ERDBlockProxy, index: number);
+    getName(): string;
+    getType(): string;
+    getKey(): string;
+}
+export declare class ERDBlockProxy extends BlockProxy {
+    static classNameRegex: RegExp;
+    getName(): string;
+    getFieldCount(): number;
+    getFields(): ERDFieldProxy[];
+}

package/bin/document/blockclasses/erdblockproxy.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const blockproxy_1 = require("../blockproxy");
+class ERDFieldProxy {
+    constructor(block, index) {
+        this.block = block;
+        this.index = index;
+    }
+    getName() {
+        return this.block.properties.get('Field' + this.index);
+    }
+    getType() {
+        var _a;
+        return (_a = this.block.properties.get('Type' + this.index)) !== null && _a !== void 0 ? _a : '';
+    }
+    getKey() {
+        var _a;
+        return (_a = this.block.properties.get('Key' + this.index)) !== null && _a !== void 0 ? _a : '';
+    }
+}
+exports.ERDFieldProxy = ERDFieldProxy;
+class ERDBlockProxy extends blockproxy_1.BlockProxy {
+    getName() {
+        return this.properties.get('Name');
+    }
+    getFieldCount() {
+        return this.properties.get('Fields');
+    }
+    getFields() {
+        const fields = [];
+        const fieldCount = this.getFieldCount();
+        for (let i = 1; i <= fieldCount; i++) {
+            //These are 1-indexed in the property store
+            fields.push(new ERDFieldProxy(this, i));
+        }
+        return fields;
+    }
+}
+exports.ERDBlockProxy = ERDBlockProxy;
+ERDBlockProxy.classNameRegex = /^ERDEntityBlock(2|3|4)?$/;

package/bin/document/blockdefinition.d.ts

@@ -0,0 +1,5 @@
+import { Box } from '../math';
+export declare type BlockDefinition = {
+    className: string;
+    boundingBox: Box;
+};

package/bin/document/blockdefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/document/blockproxy.d.ts

@@ -0,0 +1,7 @@
+import { ItemProxy } from './itemproxy';
+import { LineProxy } from './lineproxy';
+export declare class BlockProxy extends ItemProxy {
+    getClassName(): string;
+    getRotation(): number;
+    getConnectedLines(): LineProxy[];
+}

package/bin/document/blockproxy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const itemproxy_1 = require("./itemproxy");
+const lineproxy_1 = require("./lineproxy");
+class BlockProxy extends itemproxy_1.ItemProxy {
+    getClassName() {
+        return this.properties.get('ClassName');
+    }
+    getRotation() {
+        return this.properties.get('Rotation');
+    }
+    getConnectedLines() {
+        const ids = this.client.sendCommand('gcl', this.id);
+        return ids.map((id) => new lineproxy_1.LineProxy(id, this.client));
+    }
+}
+exports.BlockProxy = BlockProxy;

package/bin/document/documentproxy.d.ts

@@ -0,0 +1,10 @@
+import { EditorClient } from '../editorclient';
+import { ElementProxy } from './elementproxy';
+import { MapProxy } from './mapproxy';
+import { PageProxy } from './pageproxy';
+import { PageDefinition } from './pagedefinition';
+export declare class DocumentProxy extends ElementProxy {
+    readonly pages: MapProxy<string, PageProxy>;
+    constructor(client: EditorClient);
+    addPage(def: PageDefinition): PageProxy;
+}

package/bin/document/documentproxy.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elementproxy_1 = require("./elementproxy");
+const mapproxy_1 = require("./mapproxy");
+const pageproxy_1 = require("./pageproxy");
+class DocumentProxy extends elementproxy_1.ElementProxy {
+    constructor(client) {
+        super('', client);
+        this.pages = new mapproxy_1.MapProxy(this.client, 'lp', undefined, (pageId) => new pageproxy_1.PageProxy(pageId, this.client));
+    }
+    addPage(def) {
+        const id = this.client.sendCommand('cp', {
+            'Title': def.title,
+        });
+        const page = new pageproxy_1.PageProxy(id, this.client);
+        page.setTitle(def.title);
+        return page;
+    }
+}
+exports.DocumentProxy = DocumentProxy;

package/bin/document/elementproxy.d.ts

@@ -0,0 +1,10 @@
+import { EditorClient } from '../editorclient';
+import { MapProxy, WriteableMapProxy } from './mapproxy';
+export declare class ElementProxy {
+    readonly id: string;
+    protected readonly client: EditorClient;
+    readonly properties: WriteableMapProxy<string, any>;
+    readonly shapeData: MapProxy<string, any>;
+    constructor(id: string, client: EditorClient);
+    exists(): boolean;
+}

package/bin/document/elementproxy.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapproxy_1 = require("./mapproxy");
+class ElementProxy {
+    constructor(id, client) {
+        this.id = id;
+        this.client = client;
+        this.properties = new mapproxy_1.WriteableMapProxy(this.client, 'lpr', this.id, (name) => this.client.sendCommand('gp', {
+            'id': this.id,
+            'p': name,
+        }), (name, value) => {
+            if (name === 'BoundingBox') {
+                throw new Error('Do not use properties.set() to move or resize items; use setLocation() or setBoundingBox() or offset()');
+            }
+            this.client.sendCommand('sp', {
+                'id': this.id,
+                'p': name,
+                'v': value,
+            });
+        });
+        this.shapeData = new mapproxy_1.MapProxy(this.client, 'lsd', this.id, (name) => this.client.sendCommand('gsd', {
+            'id': this.id,
+            'n': name,
+        }));
+    }
+    exists() {
+        return this.client.sendCommand('ee', this.id);
+    }
+}
+exports.ElementProxy = ElementProxy;

package/bin/document/groupproxy.d.ts

@@ -0,0 +1,9 @@
+import { MapProxy } from './mapproxy';
+import { BlockProxy } from './blockproxy';
+import { LineProxy } from './lineproxy';
+import { ItemProxy } from './itemproxy';
+export declare class GroupProxy extends ItemProxy {
+    readonly blocks: MapProxy<string, BlockProxy>;
+    readonly lines: MapProxy<string, LineProxy>;
+    readonly groups: MapProxy<string, GroupProxy>;
+}

package/bin/document/groupproxy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapproxy_1 = require("./mapproxy");
+const lineproxy_1 = require("./lineproxy");
+const itemproxy_1 = require("./itemproxy");
+class GroupProxy extends itemproxy_1.ItemProxy {
+    constructor() {
+        super(...arguments);
+        this.blocks = new mapproxy_1.MapProxy(this.client, 'lb', this.id, (id) => this.client.getBlockProxy(id));
+        this.lines = new mapproxy_1.MapProxy(this.client, 'll', this.id, (id) => new lineproxy_1.LineProxy(id, this.client));
+        this.groups = new mapproxy_1.MapProxy(this.client, 'lg', this.id, (id) => new GroupProxy(id, this.client));
+    }
+}
+exports.GroupProxy = GroupProxy;

package/bin/document/itemproxy.d.ts

@@ -0,0 +1,16 @@
+import { ElementProxy } from './elementproxy';
+import { MapProxy } from './mapproxy';
+import { OffsetType } from '../constants';
+import { Box, Point } from '../math';
+export declare class ItemProxy extends ElementProxy {
+    readonly textAreas: MapProxy<string, string>;
+    getBoundingBox(): Box;
+    setBoundingBox(bb: Box): void;
+    getLocation(): {
+        x: number;
+        y: number;
+    };
+    setLocation(location: Point): void;
+    offset(type: OffsetType, offset: Point): void;
+    delete(): void;
+}

package/bin/document/itemproxy.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elementproxy_1 = require("./elementproxy");
+const mapproxy_1 = require("./mapproxy");
+class ItemProxy extends elementproxy_1.ElementProxy {
+    constructor() {
+        super(...arguments);
+        this.textAreas = new mapproxy_1.MapProxy(this.client, 'lta', this.id, (name) => this.client.sendCommand('gp', {
+            'id': this.id,
+            'p': name,
+        }));
+    }
+    getBoundingBox() {
+        return this.properties.get('BoundingBox');
+    }
+    setBoundingBox(bb) {
+        const current = this.getBoundingBox();
+        if (current.w === bb.w && current.h === bb.h) {
+            //Move it into place
+            if (current.x !== bb.x || current.y !== bb.y) {
+                this.offset(4 /* MOVE */, { x: bb.x - current.x, y: bb.y - current.y });
+            }
+        }
+        else {
+            //Stretch it to size
+            if (current.x !== bb.x || current.y !== bb.y) {
+                this.offset(0 /* NW */, { x: bb.x - current.x, y: bb.y - current.y });
+            }
+            if (current.x + current.w !== bb.x + bb.w || current.y + current.h !== bb.y + bb.h) {
+                this.offset(2 /* SE */, {
+                    x: bb.x + bb.w - (current.x + current.w),
+                    y: bb.y + bb.h - (current.y + current.h),
+                });
+            }
+        }
+    }
+    getLocation() {
+        const bb = this.getBoundingBox();
+        return { x: bb.x, y: bb.y };
+    }
+    setLocation(location) {
+        const current = this.getBoundingBox();
+        if (current.x !== location.x || current.y !== location.y) {
+            this.offset(4 /* MOVE */, { x: location.x - current.x, y: location.y - current.y });
+        }
+    }
+    offset(type, offset) {
+        this.client.sendCommand('oi', { 'ids': [this.id], 't': type, 'o': offset });
+    }
+    delete() {
+        this.client.sendCommand('di', this.id);
+    }
+}
+exports.ItemProxy = ItemProxy;

package/bin/document/linedefinition.d.ts

@@ -0,0 +1,29 @@
+import { BlockProxy } from './blockproxy';
+import { LineProxy } from './lineproxy';
+export interface EndpointStyle {
+    style?: string;
+}
+export interface BlockEndpointDefinition extends EndpointStyle {
+    connection: BlockProxy;
+    linkX: number;
+    linkY: number;
+    inside?: boolean;
+    autoLink?: boolean;
+    padding?: number;
+}
+export interface LineEndpointDefinition extends EndpointStyle {
+    connection: LineProxy;
+    position: number;
+}
+export interface PositionEndpointDefinition extends EndpointStyle {
+    connection: void;
+    x: number;
+    y: number;
+}
+export declare type EndpointDefinition = BlockEndpointDefinition | LineEndpointDefinition | PositionEndpointDefinition;
+export declare function isBlockEndpointDefinition(ep: EndpointDefinition): ep is BlockEndpointDefinition;
+export declare function isLineEndpointDefinition(ep: EndpointDefinition): ep is LineEndpointDefinition;
+export declare type LineDefinition = {
+    endpoint1: EndpointDefinition;
+    endpoint2: EndpointDefinition;
+};

package/bin/document/linedefinition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const blockproxy_1 = require("./blockproxy");
+const lineproxy_1 = require("./lineproxy");
+function isBlockEndpointDefinition(ep) {
+    return ep.connection instanceof blockproxy_1.BlockProxy;
+}
+exports.isBlockEndpointDefinition = isBlockEndpointDefinition;
+function isLineEndpointDefinition(ep) {
+    return ep.connection instanceof lineproxy_1.LineProxy;
+}
+exports.isLineEndpointDefinition = isLineEndpointDefinition;

package/bin/document/lineproxy.d.ts

@@ -0,0 +1,10 @@
+import { Point } from '../math';
+import { ElementProxy } from './elementproxy';
+import { ItemProxy } from './itemproxy';
+export declare class LineProxy extends ItemProxy {
+    private getConnection;
+    getUpstreamConnection(): Promise<ElementProxy | undefined>;
+    getDownstreamConnection(): Promise<ElementProxy | undefined>;
+    getConnectedLines(): LineProxy[];
+    getRelativePosition(relative: number): Point;
+}

package/bin/document/lineproxy.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const itemproxy_1 = require("./itemproxy");
+class LineProxy extends itemproxy_1.ItemProxy {
+    async getConnection(ep) {
+        let proxy;
+        if (ep['Block']) {
+            proxy = this.client.getBlockProxy(ep['Block']);
+        }
+        if (ep['Line']) {
+            proxy = new LineProxy(ep['Line'], this.client);
+        }
+        if (proxy && !proxy.exists()) {
+            return undefined;
+        }
+        return proxy;
+    }
+    async getUpstreamConnection() {
+        const ep = this.properties.get('Endpoint1');
+        if (!(typeof ep === 'object')) {
+            return undefined;
+        }
+        return this.getConnection(ep);
+    }
+    async getDownstreamConnection() {
+        const ep = this.properties.get('Endpoint2');
+        if (!(typeof ep === 'object')) {
+            return undefined;
+        }
+        return this.getConnection(ep);
+    }
+    getConnectedLines() {
+        const ids = this.client.sendCommand('gcl', this.id);
+        return ids.map((id) => new LineProxy(id, this.client));
+    }
+    getRelativePosition(relative) {
+        return this.client.sendCommand('grlp', { 'id': this.id, 'p': relative });
+    }
+}
+exports.LineProxy = LineProxy;

package/bin/document/mapproxy.d.ts

@@ -0,0 +1,16 @@
+import { EditorClient } from '../editorclient';
+export declare class MapProxy<KEY, VALUE> {
+    protected readonly client: EditorClient;
+    private readonly keyCommand;
+    private readonly keyParams;
+    private readonly getter;
+    constructor(client: EditorClient, keyCommand: string, keyParams: any, getter: (key: KEY) => VALUE);
+    [Symbol.iterator](): Iterator<[KEY, VALUE]>;
+    keys(): KEY[];
+    get(key: KEY): VALUE;
+}
+export declare class WriteableMapProxy<KEY, VALUE> extends MapProxy<KEY, VALUE> {
+    private readonly setter;
+    constructor(client: EditorClient, keyCommand: string, keyParams: any, getter: (key: KEY) => VALUE, setter: (key: KEY, val: VALUE) => void);
+    set(key: KEY, value: VALUE): void;
+}

package/bin/document/mapproxy.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MapProxy {
+    constructor(client, keyCommand, keyParams, getter) {
+        this.client = client;
+        this.keyCommand = keyCommand;
+        this.keyParams = keyParams;
+        this.getter = getter;
+    }
+    *[Symbol.iterator]() {
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                yield [key, value];
+            }
+        }
+    }
+    keys() {
+        return this.client.sendCommand(this.keyCommand, this.keyParams);
+    }
+    get(key) {
+        return this.getter(key);
+    }
+}
+exports.MapProxy = MapProxy;
+class WriteableMapProxy extends MapProxy {
+    constructor(client, keyCommand, keyParams, getter, setter) {
+        super(client, keyCommand, keyParams, getter);
+        this.setter = setter;
+    }
+    set(key, value) {
+        this.setter(key, value);
+    }
+}
+exports.WriteableMapProxy = WriteableMapProxy;

package/bin/document/pagedefinition.d.ts

@@ -0,0 +1,3 @@
+export declare type PageDefinition = {
+    title: string;
+};

package/bin/document/pagedefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/document/pageproxy.d.ts

@@ -0,0 +1,20 @@
+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 { LineDefinition } from './linedefinition';
+export declare class PageProxy extends ElementProxy {
+    readonly blocks: MapProxy<string, BlockProxy>;
+    readonly lines: MapProxy<string, LineProxy>;
+    readonly groups: MapProxy<string, GroupProxy>;
+    readonly allBlocks: MapProxy<string, BlockProxy>;
+    readonly allLines: MapProxy<string, LineProxy>;
+    readonly allGroups: MapProxy<string, GroupProxy>;
+    addBlock(def: BlockDefinition): BlockProxy;
+    addLine(def: LineDefinition): LineProxy;
+    setTitle(title: string): void;
+    getTitle(): string;
+    delete(): void;
+}

package/bin/document/pageproxy.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elementproxy_1 = require("./elementproxy");
+const mapproxy_1 = require("./mapproxy");
+const lineproxy_1 = require("./lineproxy");
+const groupproxy_1 = require("./groupproxy");
+const linedefinition_1 = require("./linedefinition");
+class PageProxy extends elementproxy_1.ElementProxy {
+    constructor() {
+        super(...arguments);
+        this.blocks = new mapproxy_1.MapProxy(this.client, 'lb', { id: this.id }, (id) => this.client.getBlockProxy(id));
+        this.lines = new mapproxy_1.MapProxy(this.client, 'll', { id: this.id }, (id) => new lineproxy_1.LineProxy(id, this.client));
+        this.groups = new mapproxy_1.MapProxy(this.client, 'lg', { id: this.id }, (id) => new groupproxy_1.GroupProxy(id, this.client));
+        this.allBlocks = new mapproxy_1.MapProxy(this.client, 'lb', { id: this.id, d: true }, (id) => this.client.getBlockProxy(id));
+        this.allLines = new mapproxy_1.MapProxy(this.client, 'll', { id: this.id, d: true }, (id) => new lineproxy_1.LineProxy(id, this.client));
+        this.allGroups = new mapproxy_1.MapProxy(this.client, 'lg', { id: this.id, d: true }, (id) => new groupproxy_1.GroupProxy(id, this.client));
+    }
+    addBlock(def) {
+        const properties = {};
+        properties['BoundingBox'] = def.boundingBox;
+        const id = 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;
+    }
+    addLine(def) {
+        const properties = {};
+        const setEndpoint = (ep, name) => {
+            if (linedefinition_1.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 (linedefinition_1.isLineEndpointDefinition(ep)) {
+                properties[name] = Object.assign({ 'Style': ep.style, 'Line': ep.connection.id, 'LineP': ep.position }, ep.connection.getRelativePosition(ep.position));
+            }
+            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_1.LineProxy(id, this.client);
+        for (const key in properties) {
+            line.properties.set(key, properties[key]);
+        }
+        return line;
+    }
+    setTitle(title) {
+        this.properties.set('Title', title);
+    }
+    getTitle() {
+        return this.properties.get('Title');
+    }
+    delete() {
+        this.client.sendCommand('dp', this.id);
+    }
+}
+exports.PageProxy = PageProxy;

package/bin/editorclient.d.ts

@@ -0,0 +1,21 @@
+import { BlockProxy } from './document/blockproxy';
+import { ElementProxy } from './document/elementproxy';
+export declare class EditorClient {
+    private nextId;
+    private readonly oneTimeCallbacks;
+    private readonly actions;
+    killExtension(): void;
+    reloadExtension(): void;
+    download(filename: string, data: string, mime: string, base64: boolean): void;
+    showModal(title: string, width: number, height: number, content: string): void;
+    hideModal(): void;
+    registerOneTimeAction(cb: (value: any) => void): number;
+    registerAction(name: string, cb: (value: any) => void): void;
+    deleteAction(name: string): void;
+    actionExists(name: string): boolean;
+    sendCommand(name: string, params?: any): any;
+    getBlockProxy(id: string): BlockProxy;
+    loadBlockClasses(classNames: string[]): Promise<undefined>;
+    getElementProxy(id: string): ElementProxy;
+    constructor();
+}