lucid-extension-sdk 0.0.0

package/out/document/blockclasses/erdblockproxy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERDBlockProxy = exports.ERDFieldProxy = void 0;
+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/out/document/blockdefinition.d.ts

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

package/out/document/blockdefinition.js

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

package/out/document/blockproxy.d.ts

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

package/out/document/blockproxy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProxy = void 0;
+const itemproxy_1 = require("./itemproxy");
+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" /* GetConnectedLines */, this.id);
+        return ids.map((id) => this.client.getLineProxy(id));
+    }
+}
+exports.BlockProxy = BlockProxy;

package/out/document/documentproxy.d.ts

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

package/out/document/documentproxy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentProxy = void 0;
+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.sendCommand("lp" /* ListPages */, undefined), (pageId) => new pageproxy_1.PageProxy(pageId, this.client));
+    }
+    addPage(def) {
+        const id = this.client.sendCommand("cp" /* CreatePage */, undefined);
+        const page = new pageproxy_1.PageProxy(id, this.client);
+        page.setTitle(def.title);
+        return page;
+    }
+}
+exports.DocumentProxy = DocumentProxy;

package/out/document/elementproxy.d.ts

@@ -0,0 +1,13 @@
+import { EditorClient } from '../editorclient';
+import { MapProxy, WriteableMapProxy } from './mapproxy';
+import { ShapeDataProxy } from './shapedataproxy';
+export declare class ElementProxy {
+    readonly id: string | undefined;
+    protected readonly client: EditorClient;
+    readonly properties: WriteableMapProxy<string, import("../core/jsonserializable").JsonSerializable>;
+    readonly shapeData: ShapeDataProxy;
+    readonly allShapeData: MapProxy<string, import("../core/serializedfields").SerializedFieldType | import("../data/dataerror").DataError>;
+    constructor(id: string | undefined, client: EditorClient);
+    exists(): boolean;
+    executeFormula(formula: string): import("../core/serializedfields").SerializedFieldType | import("../data/dataerror").DataError;
+}

package/out/document/elementproxy.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementProxy = void 0;
+const mapproxy_1 = require("./mapproxy");
+const shapedataproxy_1 = require("./shapedataproxy");
+class ElementProxy {
+    constructor(id, client) {
+        this.id = id;
+        this.client = client;
+        this.properties = new mapproxy_1.WriteableMapProxy(() => this.client.sendCommand("lpr" /* ListProperties */, { 'id': this.id }), (name) => this.client.sendCommand("gp" /* GetProperty */, {
+            '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" /* SetProperty */, {
+                'id': this.id,
+                'p': name,
+                'v': value,
+            });
+        });
+        this.shapeData = new shapedataproxy_1.ShapeDataProxy(this.id, this.client);
+        this.allShapeData = new mapproxy_1.MapProxy(() => this.client.sendCommand("lsd" /* ListShapeData */, { 'id': this.id, 'i': true }), (name) => shapedataproxy_1.ShapeDataProxy.parseData(this.client.sendCommand("gsd" /* GetShapeData */, {
+            'id': this.id,
+            'n': name,
+        })));
+    }
+    exists() {
+        return this.client.sendCommand("ee" /* ElementExists */, { 'id': this.id });
+    }
+    executeFormula(formula) {
+        return shapedataproxy_1.ShapeDataProxy.parseData(this.client.sendCommand("ef" /* ExecuteFormula */, { 'id': this.id || '', 'f': formula }));
+    }
+}
+exports.ElementProxy = ElementProxy;

package/out/document/groupproxy.d.ts

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

package/out/document/groupproxy.js

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

package/out/document/itemproxy.d.ts

@@ -0,0 +1,21 @@
+import { LinearOffsetType } from '../core/offsettype';
+import { EditorClient } from '../editorclient';
+import { Box, Point } from '../math';
+import { ElementProxy } from './elementproxy';
+import { MapProxy } from './mapproxy';
+export declare class ItemProxy extends ElementProxy {
+    readonly id: string;
+    constructor(id: string, client: EditorClient);
+    readonly textAreas: MapProxy<string, string>;
+    getBoundingBox(): Box;
+    setBoundingBox(bb: Box): void;
+    getPageId(): string;
+    getLocation(): {
+        x: number;
+        y: number;
+    };
+    setLocation(location: Point): void;
+    offset(type: LinearOffsetType, offset: Point): void;
+    delete(): void;
+    getContainers(): import("./blockproxy").BlockProxy[];
+}

package/out/document/itemproxy.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemProxy = void 0;
+const offsettype_1 = require("../core/offsettype");
+const elementproxy_1 = require("./elementproxy");
+const mapproxy_1 = require("./mapproxy");
+class ItemProxy extends elementproxy_1.ElementProxy {
+    constructor(id, client) {
+        super(id, client);
+        this.id = id;
+        this.textAreas = new mapproxy_1.MapProxy(() => this.client.sendCommand("lta" /* ListTextAreas */, this.id), (name) => this.client.sendCommand("gp" /* GetProperty */, {
+            'id': this.id,
+            'p': name,
+        }));
+    }
+    getBoundingBox() {
+        return this.properties.get('BoundingBox');
+    }
+    setBoundingBox(bb) {
+        const current = this.getBoundingBox();
+        if (current.x !== bb.x || current.y !== bb.y) {
+            this.offset(offsettype_1.OffsetType.MOVE, { x: bb.x - current.x, y: bb.y - current.y });
+        }
+        if (current.w !== bb.w || current.h !== bb.h) {
+            this.offset(offsettype_1.OffsetType.SE, {
+                x: bb.w - current.w,
+                y: bb.h - current.h,
+            });
+        }
+    }
+    getPageId() {
+        return this.client.sendCommand("gip" /* GetItemPageId */, this.id);
+    }
+    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(offsettype_1.OffsetType.MOVE, { x: location.x - current.x, y: location.y - current.y });
+        }
+    }
+    offset(type, offset) {
+        this.client.sendCommand("oi" /* OffsetItems */, { 'ids': [this.id], 't': type, 'o': offset });
+    }
+    delete() {
+        this.client.sendCommand("di" /* DeleteItem */, this.id);
+    }
+    getContainers() {
+        const containers = this.executeFormula('LABEL(CONTAINEDBY)');
+        return containers.map((id) => this.client.getBlockProxy(id));
+    }
+}
+exports.ItemProxy = ItemProxy;

package/out/document/linedefinition.d.ts

@@ -0,0 +1,27 @@
+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 interface LineDefinition {
+    endpoint1: EndpointDefinition;
+    endpoint2: EndpointDefinition;
+}

package/out/document/linedefinition.js

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

package/out/document/lineproxy.d.ts

@@ -0,0 +1,25 @@
+import { Point } from '../math';
+import { BlockProxy } from './blockproxy';
+import { ItemProxy } from './itemproxy';
+import { EndpointDefinition } from './linedefinition';
+export declare class LineProxy extends ItemProxy {
+    private getConnection;
+    private isBlockEndpointDefinition;
+    private isLineEndpointDefinition;
+    private parseLineEndpointDefinition;
+    private serializeLineEndpointDefinition;
+    getEndpoint1(): EndpointDefinition & {
+        x: number;
+        y: number;
+    };
+    getEndpoint2(): EndpointDefinition & {
+        x: number;
+        y: number;
+    };
+    setEndpoint1(endpoint: EndpointDefinition): void;
+    setEndpoint2(endpoint: EndpointDefinition): void;
+    getUpstreamConnection(): void | BlockProxy | LineProxy | undefined;
+    getDownstreamConnection(): void | BlockProxy | LineProxy | undefined;
+    getConnectedLines(): LineProxy[];
+    getRelativePosition(relative: number): Point;
+}

package/out/document/lineproxy.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineProxy = void 0;
+const blockproxy_1 = require("./blockproxy");
+const itemproxy_1 = require("./itemproxy");
+class LineProxy extends itemproxy_1.ItemProxy {
+    getConnection(ep) {
+        let proxy;
+        if (ep['Block']) {
+            proxy = this.client.getBlockProxy(ep['Block']);
+        }
+        if (ep['Line']) {
+            proxy = this.client.getLineProxy(ep['Line']);
+        }
+        if (proxy && !proxy.exists()) {
+            return undefined;
+        }
+        return proxy;
+    }
+    isBlockEndpointDefinition(ep) {
+        return ep.connection instanceof blockproxy_1.BlockProxy;
+    }
+    isLineEndpointDefinition(ep) {
+        return ep.connection instanceof LineProxy;
+    }
+    parseLineEndpointDefinition(raw) {
+        const connection = this.getConnection(raw);
+        if (connection instanceof LineProxy) {
+            return {
+                connection,
+                style: raw['Style'],
+                position: raw['Position'],
+                x: raw['x'],
+                y: raw['y'],
+            };
+        }
+        else if (connection) {
+            return {
+                connection,
+                style: raw['Style'],
+                linkX: raw['LinkX'],
+                linkY: raw['LinkY'],
+                inside: raw['Inside'],
+                autoLink: raw['AutoLink'],
+                padding: raw['Padding'],
+                x: raw['x'],
+                y: raw['y'],
+            };
+        }
+        else {
+            return {
+                style: raw['Style'],
+                x: raw['x'],
+                y: raw['y'],
+            };
+        }
+    }
+    serializeLineEndpointDefinition(ep) {
+        if (this.isBlockEndpointDefinition(ep)) {
+            const bb = ep.connection.getBoundingBox();
+            return {
+                '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 (this.isLineEndpointDefinition(ep)) {
+            return Object.assign({ 'Style': ep.style, 'Line': ep.connection.id, 'LineP': ep.position }, ep.connection.getRelativePosition(ep.position));
+        }
+        else {
+            return {
+                'Style': ep.style,
+                'x': ep.x,
+                'y': ep.y,
+            };
+        }
+    }
+    getEndpoint1() {
+        return this.parseLineEndpointDefinition(this.properties.get('Endpoint1'));
+    }
+    getEndpoint2() {
+        return this.parseLineEndpointDefinition(this.properties.get('Endpoint2'));
+    }
+    setEndpoint1(endpoint) {
+        this.properties.set('Endpoint1', this.serializeLineEndpointDefinition(endpoint));
+    }
+    setEndpoint2(endpoint) {
+        this.properties.set('Endpoint2', this.serializeLineEndpointDefinition(endpoint));
+    }
+    getUpstreamConnection() {
+        return this.getEndpoint1().connection;
+    }
+    getDownstreamConnection() {
+        return this.getEndpoint2().connection;
+    }
+    getConnectedLines() {
+        const ids = this.client.sendCommand("gcl" /* GetConnectedLines */, this.id);
+        return ids.map((id) => this.client.getLineProxy(id));
+    }
+    getRelativePosition(relative) {
+        return this.client.sendCommand("grlp" /* GetRelativeLinePosition */, { 'id': this.id, 'p': relative });
+    }
+}
+exports.LineProxy = LineProxy;

package/out/document/mapproxy.d.ts

@@ -0,0 +1,15 @@
+export declare class MapProxy<KEY, VALUE> {
+    private readonly getKeys;
+    private readonly getItem;
+    constructor(getKeys: () => KEY[], getItem: (key: KEY) => VALUE);
+    [Symbol.iterator](): Iterator<[KEY, VALUE]>;
+    values(): Iterator<VALUE>;
+    keys(): KEY[];
+    get(key: KEY): VALUE;
+    first(): VALUE | undefined;
+}
+export declare class WriteableMapProxy<KEY, VALUE> extends MapProxy<KEY, VALUE> {
+    private readonly setter;
+    constructor(getKeys: () => KEY[], getItem: (key: KEY) => VALUE, setter: (key: KEY, val: VALUE) => void);
+    set(key: KEY, value: VALUE): void;
+}

package/out/document/mapproxy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteableMapProxy = exports.MapProxy = void 0;
+class MapProxy {
+    constructor(getKeys, getItem) {
+        this.getKeys = getKeys;
+        this.getItem = getItem;
+    }
+    *[Symbol.iterator]() {
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                yield [key, value];
+            }
+        }
+    }
+    *values() {
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                yield value;
+            }
+        }
+    }
+    keys() {
+        return this.getKeys();
+    }
+    get(key) {
+        return this.getItem(key);
+    }
+    first() {
+        const keys = this.keys();
+        if (keys.length == 0) {
+            return undefined;
+        }
+        return this.get(keys[0]);
+    }
+}
+exports.MapProxy = MapProxy;
+class WriteableMapProxy extends MapProxy {
+    constructor(getKeys, getItem, setter) {
+        super(getKeys, getItem);
+        this.setter = setter;
+    }
+    set(key, value) {
+        this.setter(key, value);
+    }
+}
+exports.WriteableMapProxy = WriteableMapProxy;

package/out/document/pagedefinition.d.ts

@@ -0,0 +1,3 @@
+export interface PageDefinition {
+    title: string;
+}

package/out/document/pagedefinition.js

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

package/out/document/pageproxy.d.ts

@@ -0,0 +1,23 @@
+import { EditorClient } from '../editorclient';
+import { BlockDefinition } from './blockdefinition';
+import { BlockProxy } from './blockproxy';
+import { ElementProxy } from './elementproxy';
+import { GroupProxy } from './groupproxy';
+import { LineDefinition } from './linedefinition';
+import { LineProxy } from './lineproxy';
+import { MapProxy } from './mapproxy';
+export declare class PageProxy extends ElementProxy {
+    readonly id: string;
+    constructor(id: string, client: EditorClient);
+    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/out/document/pageproxy.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageProxy = void 0;
+const elementproxy_1 = require("./elementproxy");
+const groupproxy_1 = require("./groupproxy");
+const lineproxy_1 = require("./lineproxy");
+const mapproxy_1 = require("./mapproxy");
+class PageProxy extends elementproxy_1.ElementProxy {
+    constructor(id, client) {
+        super(id, client);
+        this.id = id;
+        this.blocks = new mapproxy_1.MapProxy(() => this.client.sendCommand("lb" /* ListBlocks */, { id: this.id }), (id) => this.client.getBlockProxy(id));
+        this.lines = new mapproxy_1.MapProxy(() => this.client.sendCommand("ll" /* ListLines */, { id: this.id }), (id) => new lineproxy_1.LineProxy(id, this.client));
+        this.groups = new mapproxy_1.MapProxy(() => this.client.sendCommand("lg" /* ListGroups */, { id: this.id }), (id) => new groupproxy_1.GroupProxy(id, this.client));
+        this.allBlocks = new mapproxy_1.MapProxy(() => this.client.sendCommand("lb" /* ListBlocks */, { id: this.id, d: true }), (id) => this.client.getBlockProxy(id));
+        this.allLines = new mapproxy_1.MapProxy(() => this.client.sendCommand("ll" /* ListLines */, { id: this.id, d: true }), (id) => new lineproxy_1.LineProxy(id, this.client));
+        this.allGroups = new mapproxy_1.MapProxy(() => this.client.sendCommand("lg" /* ListGroups */, { id: this.id, d: true }), (id) => new groupproxy_1.GroupProxy(id, this.client));
+    }
+    addBlock(def) {
+        const id = this.client.sendCommand("cb" /* CreateBlock */, {
+            'p': this.id,
+            'c': def.className,
+        });
+        const block = this.client.getBlockProxy(id);
+        block.setBoundingBox(def.boundingBox);
+        return block;
+    }
+    addLine(def) {
+        const id = this.client.sendCommand("cl" /* CreateLine */, {
+            'p': this.id,
+        });
+        const line = new lineproxy_1.LineProxy(id, this.client);
+        line.setEndpoint1(def.endpoint1);
+        line.setEndpoint2(def.endpoint2);
+        return line;
+    }
+    setTitle(title) {
+        this.properties.set('Title', title);
+    }
+    getTitle() {
+        return this.properties.get('Title');
+    }
+    delete() {
+        this.client.sendCommand("dp" /* DeletePage */, this.id);
+    }
+}
+exports.PageProxy = PageProxy;

package/out/document/shapedataproxy.d.ts

@@ -0,0 +1,12 @@
+import { SerializedDataError } from '../core/serializeddataerror';
+import { SerializedFieldType } from '../core/serializedfields';
+import { DataError } from '../data/dataerror';
+import { EditorClient } from '../editorclient';
+import { WriteableMapProxy } from './mapproxy';
+export declare class ShapeDataProxy extends WriteableMapProxy<string, SerializedFieldType | SerializedDataError> {
+    readonly id: string | undefined;
+    protected readonly client: EditorClient;
+    constructor(id: string | undefined, client: EditorClient);
+    delete(key: string): void;
+    static parseData(raw: SerializedFieldType | SerializedDataError): SerializedFieldType | DataError;
+}

package/out/document/shapedataproxy.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeDataProxy = void 0;
+const serializeddataerror_1 = require("../core/serializeddataerror");
+const shapedatainheritance_1 = require("../core/shapedatainheritance");
+const dataerror_1 = require("../data/dataerror");
+const mapproxy_1 = require("./mapproxy");
+class ShapeDataProxy extends mapproxy_1.WriteableMapProxy {
+    constructor(id, client) {
+        super(() => this.client.sendCommand("lsd" /* ListShapeData */, { 'id': this.id }), (name) => ShapeDataProxy.parseData(this.client.sendCommand("gsd" /* GetShapeData */, {
+            'id': this.id,
+            'n': name,
+        })), (name, value) => {
+            if ((0, serializeddataerror_1.isSerializedDataError)(value)) {
+                throw new Error('Cannot store an error value');
+            }
+            if (this.keys().includes(name)) {
+                this.client.sendCommand("ssd" /* SetShapeData */, { 'id': this.id, 'n': name, 'v': value });
+            }
+            else {
+                this.client.sendCommand("asd" /* AddShapeData */, {
+                    'id': this.id,
+                    'i': shapedatainheritance_1.ShapeDataInheritance.NONE,
+                    'n': name,
+                    'v': value,
+                });
+            }
+        });
+        this.id = id;
+        this.client = client;
+    }
+    delete(key) {
+        if (this.keys().includes(key)) {
+            this.client.sendCommand("dsd" /* DeleteShapeData */, { 'id': this.id, 'n': key });
+        }
+    }
+    static parseData(raw) {
+        if ((0, serializeddataerror_1.isSerializedDataError)(raw)) {
+            return new dataerror_1.DataError(raw['error'], raw['type']);
+        }
+        //TODO, eventually: parse these
+        return raw;
+    }
+}
+exports.ShapeDataProxy = ShapeDataProxy;