lucid-extension-sdk 0.0.9 → 0.0.13

package/interop.d.ts

@@ -2,6 +2,8 @@
 declare namespace lucid {
     export function executeCommand(name: string, params: any): any;
     export function listen(msg: any): void;
+    export function getPackageId(): string;
+    export function getVersion(): string;
 }
 
 /** @ignore */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.9",
+    "version": "0.0.13",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "sdk/index.js",
     "types": "sdk/index.d.ts",

package/sdk/commandtypes.d.ts

@@ -5,6 +5,7 @@ import { JsonObject, JsonSerializable } from './core/jsonserializable';
 import { LinearOffsetType } from './core/offsettype';
 import { SerializedDataError } from './core/serializeddataerror';
 import { ShapeDataInheritance } from './core/shapedatainheritance';
+import { SerializedLineTextAreaPositioning } from './document/linetextareapositioning';
 import { Box, Point } from './math';
 import { MenuLocation, MenuType } from './ui/menu';
 import { PanelLocation } from './ui/panel';
@@ -16,6 +17,7 @@ import { PanelLocation } from './ui/panel';
  * To use these directly, use [EditorClient.sendCommand](#classes_editorclient-EditorClient_sendcommand).
  */
 export declare const enum CommandName {
+    AddLineTextArea = "alta",
     AddMenuItem = "ami",
     AddShapeData = "asd",
     AnimateViewport = "av",
@@ -44,6 +46,9 @@ export declare const enum CommandName {
     GetShapeData = "gsd",
     HideModal = "hm",
     HidePanel = "hp",
+    HookCreateItems = "hci",
+    HookSelection = "hs",
+    HookTextEdit = "hte",
     KillExtension = "k",
     ListBlocks = "lb",
     ListCollectionFields = "lcf",
@@ -72,7 +77,10 @@ export declare const enum CommandName {
     SetShapeData = "ssd",
     ShowModal = "sm",
     ShowPanel = "spn",
-    SleepForTestCase = "sleep"
+    SleepForTestCase = "sleep",
+    UnhookCreateItems = "uci",
+    UnhookSelection = "us",
+    UnhookTextEdit = "ute"
 }
 /**
  * This is a type declaration whose purpose is to allow TypeScript to enforce the correct parameter and
@@ -80,9 +88,9 @@ export declare const enum CommandName {
  * which command name you pass in as the first parameter.
  */
 export declare type CommandArgs = {
-    [CommandName.AnimateViewport]: {
-        query: AnimateViewportQuery;
-        result: AnimateViewportResult;
+    [CommandName.AddLineTextArea]: {
+        query: AddLineTextAreaQuery;
+        result: AddLineTextAreaResult;
     };
     [CommandName.AddMenuItem]: {
         query: AddMenuItemQuery;
@@ -92,6 +100,10 @@ export declare type CommandArgs = {
         query: AddShapeDataQuery;
         result: AddShapeDataResult;
     };
+    [CommandName.AnimateViewport]: {
+        query: AnimateViewportQuery;
+        result: AnimateViewportResult;
+    };
     [CommandName.Bootstrap]: {
         query: BootstrapQuery;
         result: BootstrapResult;
@@ -192,6 +204,18 @@ export declare type CommandArgs = {
         query: HidePanelQuery;
         result: HidePanelResult;
     };
+    [CommandName.HookCreateItems]: {
+        query: HookCreateItemsQuery;
+        result: HookCreateItemsResult;
+    };
+    [CommandName.HookSelection]: {
+        query: HookSelectionQuery;
+        result: HookSelectionResult;
+    };
+    [CommandName.HookTextEdit]: {
+        query: HookTextEditQuery;
+        result: HookTextEditResult;
+    };
     [CommandName.KillExtension]: {
         query: KillExtensionQuery;
         result: KillExtensionResult;
@@ -308,7 +332,29 @@ export declare type CommandArgs = {
         query: SleepForTestCaseQuery;
         result: SleepForTestCaseResult;
     };
+    [CommandName.UnhookCreateItems]: {
+        query: UnhookCreateItemsQuery;
+        result: UnhookCreateItemsResult;
+    };
+    [CommandName.UnhookSelection]: {
+        query: UnhookSelectionQuery;
+        result: UnhookSelectionResult;
+    };
+    [CommandName.UnhookTextEdit]: {
+        query: UnhookTextEditQuery;
+        result: UnhookTextEditResult;
+    };
+};
+export declare type AddLineTextAreaQuery = {
+    /** Which line */
+    'id': string;
+    /** Where to place the text along the line */
+    'p': SerializedLineTextAreaPositioning;
+    /** Plain text to put at this location (will be styled with document theme) */
+    't': string;
 };
+/** The name of the created text area */
+export declare type AddLineTextAreaResult = string;
 /** @ignore */
 export declare type UnionToIntersection<T> = (T extends any ? (x: T) => unknown : never) extends (x: infer R) => unknown ? R : never;
 export declare type AddMenuItemQuery = {
@@ -509,6 +555,21 @@ export declare type HidePanelQuery = {
     'n': string;
 };
 export declare type HidePanelResult = undefined;
+export declare type HookCreateItemsQuery = {
+    /** Name of the action for receiving events. Will be called with an array of strings of all recently created item IDs. */
+    'n': string;
+};
+export declare type HookCreateItemsResult = undefined;
+export declare type HookSelectionQuery = {
+    /** Name of the action for receiving events. Will be called with an array of strings of all selected item IDs. */
+    'n': string;
+};
+export declare type HookSelectionResult = undefined;
+export declare type HookTextEditQuery = {
+    /** Name of the action for receiving these events */
+    'n': string;
+};
+export declare type HookTextEditResult = undefined;
 export declare type KillExtensionQuery = void;
 export declare type KillExtensionResult = undefined;
 export declare type ListChildrenQuery = {
@@ -641,6 +702,7 @@ export declare type RawSendXHRResponse = {
     'to'?: boolean;
 };
 export declare type SendXHRResponse = Promise<RawSendXHRResponse>;
+export declare function isRawSendXHRResponse(val: any): val is RawSendXHRResponse;
 export declare type SetCurrentPageQuery = string;
 export declare type SetCurrentPageResult = Promise<void>;
 export declare type SetPropertyQuery = {
@@ -690,3 +752,18 @@ export declare type ShowPanelQuery = {
 export declare type ShowPanelResult = undefined;
 export declare type SleepForTestCaseQuery = number;
 export declare type SleepForTestCaseResult = Promise<void>;
+export declare type UnhookCreateItemsQuery = {
+    /** Name of the action passed to HookCreateItems */
+    'n': string;
+};
+export declare type UnhookCreateItemsResult = undefined;
+export declare type UnhookSelectionQuery = {
+    /** Name of the action for receiving these events */
+    'n': string;
+};
+export declare type UnhookSelectionResult = undefined;
+export declare type UnhookTextEditQuery = {
+    /** Name of the action for receiving these events */
+    'n': string;
+};
+export declare type UnhookTextEditResult = undefined;

package/sdk/commandtypes.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRawSendXHRResponse = void 0;
+const checks_1 = require("./core/checks");
+function isRawSendXHRResponse(val) {
+    return (0, checks_1.isString)(val['url']) && (0, checks_1.isString)(val['t']) && (0, checks_1.isNumber)(val['s']) && (0, checks_1.isObject)(val['h']);
+}
+exports.isRawSendXHRResponse = isRawSendXHRResponse;

package/sdk/core/data/referencekeys/serializedreferencekey.d.ts

@@ -22,3 +22,9 @@ export declare type UnTypedSerializedFlattenedReference = {
 };
 export declare type SerializedFlattenedReference = TypedSerializedFlattenedReference | UnTypedSerializedFlattenedReference;
 export declare type SerializedReferenceKeyType = SerializedReferenceKey | SerializedFlattenedReference;
+/** @ignore */
+export declare function isTypedSerializedFlattenedReference(data: unknown): data is TypedSerializedFlattenedReference;
+/** @ignore */
+export declare function isUnTypedSerializedFlattenedReference(data: unknown): data is UnTypedSerializedFlattenedReference;
+/** @ignore */
+export declare function isSerializedFlattenedReference(data: unknown): data is SerializedFlattenedReference;

package/sdk/core/data/referencekeys/serializedreferencekey.js

@@ -1,5 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlattenedReferenceKeyName = exports.FlattenedReferenceKeyId = void 0;
+exports.isSerializedFlattenedReference = exports.isUnTypedSerializedFlattenedReference = exports.isTypedSerializedFlattenedReference = exports.FlattenedReferenceKeyName = exports.FlattenedReferenceKeyId = void 0;
+const checks_1 = require("../../checks");
 exports.FlattenedReferenceKeyId = '192d0e9f-2f5a-4032-9f03-59bbf1ea5891';
 exports.FlattenedReferenceKeyName = '192d0e9f-2f5a-4032-9f03-59bbf1ea5891_n';
+/** @ignore */
+function isTypedSerializedFlattenedReference(data) {
+    return (0, checks_1.isObject)(data) && (0, checks_1.isObject)(data['sc']) && (0, checks_1.isObject)(data['d']);
+}
+exports.isTypedSerializedFlattenedReference = isTypedSerializedFlattenedReference;
+/** @ignore */
+function isUnTypedSerializedFlattenedReference(data) {
+    return (0, checks_1.isObject)(data) && data[exports.FlattenedReferenceKeyId] === true;
+}
+exports.isUnTypedSerializedFlattenedReference = isUnTypedSerializedFlattenedReference;
+/** @ignore */
+function isSerializedFlattenedReference(data) {
+    return isUnTypedSerializedFlattenedReference(data) || isTypedSerializedFlattenedReference(data);
+}
+exports.isSerializedFlattenedReference = isSerializedFlattenedReference;

package/sdk/data/referencekeydefinition.d.ts

@@ -30,7 +30,7 @@ export interface CollectionReferenceKeyDefinition {
  */
 export interface FlattenedReferenceDefinition {
     /** Name to display to the user for the reference key (what would normally be the collection name) */
-    name: string;
+    name?: string;
     /** Schema of the data stored at this key */
     schema: SchemaDefinition;
     /** Field values available at this reference key */
@@ -41,3 +41,5 @@ export declare type ReferenceKeyDefinition = CollectionReferenceKeyDefinition |
 export declare function isCollectionReferenceKeyDefinition(def: ReferenceKeyDefinition): def is CollectionReferenceKeyDefinition;
 /** @ignore */
 export declare function serializeReferenceKeyDefinition(def: ReferenceKeyDefinition): SerializedReferenceKeyType;
+/** @ignore */
+export declare function parseReferenceKeyDefinition(def: SerializedReferenceKeyType): ReferenceKeyDefinition;

package/sdk/data/referencekeydefinition.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeReferenceKeyDefinition = exports.isCollectionReferenceKeyDefinition = void 0;
+exports.parseReferenceKeyDefinition = exports.serializeReferenceKeyDefinition = exports.isCollectionReferenceKeyDefinition = void 0;
 const checks_1 = require("../core/checks");
+const serializedreferencekey_1 = require("../core/data/referencekeys/serializedreferencekey");
 const schemadefinition_1 = require("./schemadefinition");
 /** @ignore */
 function isCollectionReferenceKeyDefinition(def) {
@@ -27,3 +28,25 @@ function serializeReferenceKeyDefinition(def) {
     }
 }
 exports.serializeReferenceKeyDefinition = serializeReferenceKeyDefinition;
+/** @ignore */
+function parseReferenceKeyDefinition(def) {
+    if ((0, serializedreferencekey_1.isTypedSerializedFlattenedReference)(def)) {
+        return {
+            schema: (0, schemadefinition_1.parseSchemaDefinition)(def['sc']),
+            name: def['n'],
+            data: def['d'],
+        };
+    }
+    else if ((0, serializedreferencekey_1.isUnTypedSerializedFlattenedReference)(def)) {
+        throw new Error('Untyped serialized flattened references not implemented');
+    }
+    else {
+        return {
+            collectionId: def['cid'],
+            primaryKey: def['pk'],
+            fieldWhitelist: def['wl'],
+            readonly: def['ro'],
+        };
+    }
+}
+exports.parseReferenceKeyDefinition = parseReferenceKeyDefinition;

package/sdk/data/referencekeyproxy.d.ts

@@ -6,4 +6,8 @@ export declare class ReferenceKeyProxy {
     private readonly client;
     private readonly settings;
     constructor(elementId: string | undefined, key: string | number, client: EditorClient, settings: SerializedReferenceKeyType);
+    get collectionId(): string | undefined;
+    get primaryKey(): string | undefined;
+    get definition(): import("./referencekeydefinition").ReferenceKeyDefinition;
+    getItem(): import("./dataitemproxy").DataItemProxy;
 }

package/sdk/data/referencekeyproxy.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferenceKeyProxy = void 0;
+const serializedreferencekey_1 = require("../core/data/referencekeys/serializedreferencekey");
+const collectionproxy_1 = require("./collectionproxy");
+const referencekeydefinition_1 = require("./referencekeydefinition");
 class ReferenceKeyProxy {
     constructor(elementId, key, client, settings) {
         this.elementId = elementId;
@@ -8,5 +11,27 @@ class ReferenceKeyProxy {
         this.client = client;
         this.settings = settings;
     }
+    get collectionId() {
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings)) {
+            return undefined;
+        }
+        return this.settings['cid'];
+    }
+    get primaryKey() {
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings)) {
+            return undefined;
+        }
+        return this.settings['pk'];
+    }
+    get definition() {
+        return (0, referencekeydefinition_1.parseReferenceKeyDefinition)(this.settings);
+    }
+    getItem() {
+        const collectionId = this.collectionId;
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings) || !collectionId) {
+            throw new Error('Not implemented for flattened references');
+        }
+        return new collectionproxy_1.CollectionProxy(collectionId, this.client).items.get(this.settings['pk']);
+    }
 }
 exports.ReferenceKeyProxy = ReferenceKeyProxy;

package/sdk/data/schemadefinition.d.ts

@@ -20,3 +20,5 @@ export interface SchemaDefinition {
 }
 /** @ignore */
 export declare function serializeSchemaDefinition(def: SchemaDefinition): SerializedSchema;
+/** @ignore */
+export declare function parseSchemaDefinition(def: SerializedSchema): SchemaDefinition;

package/sdk/data/schemadefinition.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeSchemaDefinition = void 0;
+exports.parseSchemaDefinition = exports.serializeSchemaDefinition = void 0;
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 /** @ignore */
 function serializeSchemaDefinition(def) {
@@ -13,3 +13,14 @@ function serializeSchemaDefinition(def) {
     };
 }
 exports.serializeSchemaDefinition = serializeSchemaDefinition;
+/** @ignore */
+function parseSchemaDefinition(def) {
+    return {
+        fields: def['Fields'].map((field) => ({
+            name: field['Name'],
+            type: (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(field['Type']),
+        })),
+        primaryKey: def['PrimaryKey'],
+    };
+}
+exports.parseSchemaDefinition = parseSchemaDefinition;

package/sdk/document/blockclasses/blockproxyregistry.js

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

package/sdk/document/blockclasses/customblockproxy.d.ts

@@ -0,0 +1,6 @@
+import { BlockProxy } from '../blockproxy';
+export declare class CustomBlockProxy extends BlockProxy {
+    static classNameRegex: RegExp;
+    isFromStencil(library: string, shape: string): boolean;
+    getStencilTextAreaName(stencilTextAreaName: string): string | undefined;
+}

package/sdk/document/blockclasses/customblockproxy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomBlockProxy = void 0;
+const checks_1 = require("../../core/checks");
+const blockproxy_1 = require("../blockproxy");
+class CustomBlockProxy extends blockproxy_1.BlockProxy {
+    isFromStencil(library, shape) {
+        const stencil = this.properties.get('Stencil');
+        if ((0, checks_1.isObject)(stencil)) {
+            const sourceStencil = this.client.sendCommand("gp" /* GetProperty */, { 'p': 'Stencil-' + stencil['id'] });
+            if ((0, checks_1.isObject)(sourceStencil) && (0, checks_1.isObject)(sourceStencil['sourcePackage'])) {
+                return (sourceStencil['sourcePackage']['packageId'] === lucid.getPackageId() &&
+                    sourceStencil['sourcePackage']['library'] === library &&
+                    sourceStencil['sourcePackage']['shape'] === shape);
+            }
+        }
+        return false;
+    }
+    getStencilTextAreaName(stencilTextAreaName) {
+        return this.textAreas.keys().find((name) => name.endsWith('_' + stencilTextAreaName));
+    }
+}
+exports.CustomBlockProxy = CustomBlockProxy;
+CustomBlockProxy.classNameRegex = /^CustomBlock$/;

package/sdk/document/blockproxy.d.ts

@@ -19,4 +19,16 @@ export declare class BlockProxy extends ItemProxy {
      * @returns An array of lines that have one or both endpoints connected to this block.
      */
     getConnectedLines(): import("./lineproxy").LineProxy[];
+    /**
+     * Link a text area to a data field, so that editing the text area will also update the
+     * associated data, and vice versa.
+     *
+     * To use this, first establish a reference key on this block with
+     * [setReferenceKey](/extension-sdk/#classes_document_blockproxy-BlockProxy_setreferencekey).
+     *
+     * @param textAreaKey
+     * @param referenceKey
+     * @param field
+     */
+    linkText(textAreaKey: string, referenceKey: string | number, field: string): void;
 }

package/sdk/document/blockproxy.js

@@ -29,5 +29,28 @@ class BlockProxy extends itemproxy_1.ItemProxy {
         const ids = this.client.sendCommand("gcl" /* GetConnectedLines */, this.id);
         return ids.map((id) => this.client.getLineProxy(id));
     }
+    /**
+     * Link a text area to a data field, so that editing the text area will also update the
+     * associated data, and vice versa.
+     *
+     * To use this, first establish a reference key on this block with
+     * [setReferenceKey](/extension-sdk/#classes_document_blockproxy-BlockProxy_setreferencekey).
+     *
+     * @param textAreaKey
+     * @param referenceKey
+     * @param field
+     */
+    linkText(textAreaKey, referenceKey, field) {
+        if (!this.textAreas.keys().includes(textAreaKey)) {
+            throw new Error('Invalid text area key');
+        }
+        if (!this.referenceKeys.keys().includes(referenceKey)) {
+            throw new Error('Invalid reference key');
+        }
+        this.properties.set(textAreaKey + '_Link', {
+            'ref': referenceKey,
+            'f': field,
+        });
+    }
 }
 exports.BlockProxy = BlockProxy;

package/sdk/document/documentproxy.d.ts

@@ -1,5 +1,6 @@
 import { EditorClient } from '../editorclient';
 import { ElementProxy } from './elementproxy';
+import { ItemProxy } from './itemproxy';
 import { MapProxy } from './mapproxy';
 import { PageDefinition } from './pagedefinition';
 import { PageProxy } from './pageproxy';
@@ -7,6 +8,8 @@ import { PageProxy } from './pageproxy';
  * The currently-open Lucid document
  */
 export declare class DocumentProxy extends ElementProxy {
+    private static nextHookId;
+    private static getNextHookName;
     /**
      * The set of pages on this document, organized by ID
      */
@@ -27,4 +30,21 @@ export declare class DocumentProxy extends ElementProxy {
      * @returns The title of this document
      */
     getTitle(): string;
+    /**
+     * Watch for new blocks, lines, or groups added to this document. The callback will
+     * be called with new items created by the current user, but will not be called with items
+     * created
+     *
+     *  - As part of a generated diagram, e.g. org chart
+     *  - As a result of undo or redo
+     *  - By another user on the same document
+     *
+     * @param callback
+     * @returns A handle that can be passed to `unhookCreateItems`
+     */
+    hookCreateItems(callback: (items: ItemProxy[]) => void): string;
+    /**
+     * @param handle Return value from `hookCreateItems`
+     */
+    unhookCreateItems(handle: string): void;
 }

package/sdk/document/documentproxy.js

@@ -15,6 +15,9 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
          */
         this.pages = new mapproxy_1.MapProxy(() => this.client.sendCommand("lp" /* ListPages */, undefined), (pageId) => new pageproxy_1.PageProxy(pageId, this.client));
     }
+    static getNextHookName() {
+        return '__documentproxy__hook' + DocumentProxy.nextHookId++;
+    }
     /**
      * Add a new page to the current document
      * @param def Definition of the page to add
@@ -39,5 +42,33 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
     getTitle() {
         return this.properties.get('Title');
     }
+    /**
+     * Watch for new blocks, lines, or groups added to this document. The callback will
+     * be called with new items created by the current user, but will not be called with items
+     * created
+     *
+     *  - As part of a generated diagram, e.g. org chart
+     *  - As a result of undo or redo
+     *  - By another user on the same document
+     *
+     * @param callback
+     * @returns A handle that can be passed to `unhookCreateItems`
+     */
+    hookCreateItems(callback) {
+        const actionName = DocumentProxy.getNextHookName();
+        this.client.registerAction(actionName, (msg) => {
+            callback(msg['ids'].map((id) => this.client.getItemProxy(id)));
+        });
+        this.client.sendCommand("hci" /* HookCreateItems */, { 'n': actionName });
+        return actionName;
+    }
+    /**
+     * @param handle Return value from `hookCreateItems`
+     */
+    unhookCreateItems(handle) {
+        this.client.deleteAction(handle);
+        this.client.sendCommand("uci" /* UnhookCreateItems */, { 'n': handle });
+    }
 }
 exports.DocumentProxy = DocumentProxy;
+DocumentProxy.nextHookId = 0;

package/sdk/document/lineproxy.d.ts

@@ -2,6 +2,7 @@ import { Point } from '../math';
 import { BlockProxy } from './blockproxy';
 import { ItemProxy } from './itemproxy';
 import { EndpointDefinition } from './linedefinition';
+import { LineTextAreaPositioning } from './linetextareapositioning';
 /**
  * A line on the current Lucid document
  */
@@ -52,4 +53,29 @@ export declare class LineProxy extends ItemProxy {
      * @returns The coordinate of that relative position, relative to the containing page
      */
     getRelativePosition(relative: number): Point;
+    /**
+     *
+     * @param name
+     * @returns The position of the given text area on this line, if it exists, or undefined if it does not exist.
+     */
+    getTextAreaPosition(name: string): LineTextAreaPositioning | undefined;
+    /**
+     * Updates the position of the given text area, if it exists. If not, an error is thrown.
+     * @param name
+     * @param position
+     */
+    setTextAreaPosition(name: string, position: LineTextAreaPositioning): void;
+    /**
+     * Adds a new text area to this line at the given location with the given initial plain text.
+     * The text will be styled with the document theme, if any.
+     * @param text
+     * @param position
+     * @returns The name of the text area added
+     */
+    addTextArea(text: string, position: LineTextAreaPositioning): string;
+    /**
+     * Deletes the given text area from the line, if it exists.
+     * @param name
+     */
+    deleteTextArea(name: string): void;
 }

package/sdk/document/lineproxy.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineProxy = void 0;
+const checks_1 = require("../core/checks");
 const blockproxy_1 = require("./blockproxy");
 const itemproxy_1 = require("./itemproxy");
+const linetextareapositioning_1 = require("./linetextareapositioning");
 /**
  * A line on the current Lucid document
  */
@@ -136,5 +138,49 @@ class LineProxy extends itemproxy_1.ItemProxy {
     getRelativePosition(relative) {
         return this.client.sendCommand("grlp" /* GetRelativeLinePosition */, { 'id': this.id, 'p': relative });
     }
+    /**
+     *
+     * @param name
+     * @returns The position of the given text area on this line, if it exists, or undefined if it does not exist.
+     */
+    getTextAreaPosition(name) {
+        const serializedTextAreas = this.properties.get('TextAreas');
+        if ((0, checks_1.isObject)(serializedTextAreas)) {
+            const rawEntry = serializedTextAreas[name];
+            if ((0, linetextareapositioning_1.isSerializedLineTextAreaPositioning)(rawEntry)) {
+                return (0, linetextareapositioning_1.deserializeLineTextAreaPositioning)(rawEntry);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Updates the position of the given text area, if it exists. If not, an error is thrown.
+     * @param name
+     * @param position
+     */
+    setTextAreaPosition(name, position) {
+        this.properties.set('TextAreas', { [name]: (0, linetextareapositioning_1.serializeLineTextAreaPositioning)(position) });
+    }
+    /**
+     * Adds a new text area to this line at the given location with the given initial plain text.
+     * The text will be styled with the document theme, if any.
+     * @param text
+     * @param position
+     * @returns The name of the text area added
+     */
+    addTextArea(text, position) {
+        return this.client.sendCommand("alta" /* AddLineTextArea */, {
+            'id': this.id,
+            'p': (0, linetextareapositioning_1.serializeLineTextAreaPositioning)(position),
+            't': text,
+        });
+    }
+    /**
+     * Deletes the given text area from the line, if it exists.
+     * @param name
+     */
+    deleteTextArea(name) {
+        this.properties.set('TextAreas', { [name]: null });
+    }
 }
 exports.LineProxy = LineProxy;

package/sdk/document/linetextareapositioning.d.ts

@@ -0,0 +1,31 @@
+export interface LineTextAreaPositioning {
+    /**
+     * A number between 0 and 1 representing how far this text lies along the line, where 0 puts the text
+     * at the same location as the first endpoint, and 1 puts the text at the same location as the second
+     * endpoint.
+     */
+    location: number;
+    /**
+     * Which side of the line the text is displayed on. If zero, the text is on top of the line. If -1,
+     * the text is to the left of the line as you travel from the first to second endpoints. If 1, the
+     * text is to the right of the line as you travel from the first to second endpoints.
+     */
+    side: -1 | 0 | 1;
+    /**
+     * Normally text on a line is not allowed to overlap a block that is connected to either end of the
+     * line. If `allowOverBlock` is true, then the text is allowed to overlap an attached block.
+     */
+    allowOverBlock?: boolean;
+}
+/** @ignore */
+export declare type SerializedLineTextAreaPositioning = {
+    'Location': number;
+    'Side': -1 | 0 | 1;
+    'AllowOverBlock'?: boolean;
+};
+/** @ignore */
+export declare function isSerializedLineTextAreaPositioning(raw: unknown): raw is SerializedLineTextAreaPositioning;
+/** @ignore */
+export declare function deserializeLineTextAreaPositioning(raw: SerializedLineTextAreaPositioning): LineTextAreaPositioning;
+/** @ignore */
+export declare function serializeLineTextAreaPositioning(data: LineTextAreaPositioning): SerializedLineTextAreaPositioning;

package/sdk/document/linetextareapositioning.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeLineTextAreaPositioning = exports.deserializeLineTextAreaPositioning = exports.isSerializedLineTextAreaPositioning = void 0;
+const checks_1 = require("../core/checks");
+/** @ignore */
+function isSerializedLineTextAreaPositioning(raw) {
+    return ((0, checks_1.isObject)(raw) &&
+        (0, checks_1.isNumber)(raw['Location']) &&
+        (0, checks_1.isNumber)(raw['Side']) &&
+        ((0, checks_1.isBoolean)(raw['AllowOverBlock']) || (0, checks_1.isUndefined)(raw['AllowOverBlock'])));
+}
+exports.isSerializedLineTextAreaPositioning = isSerializedLineTextAreaPositioning;
+/** @ignore */
+function deserializeLineTextAreaPositioning(raw) {
+    return {
+        location: raw['Location'],
+        side: raw['Side'],
+        allowOverBlock: raw['AllowOverBlock'],
+    };
+}
+exports.deserializeLineTextAreaPositioning = deserializeLineTextAreaPositioning;
+/** @ignore */
+function serializeLineTextAreaPositioning(data) {
+    return {
+        'Location': data.location,
+        'Side': data.side,
+        'AllowOverBlock': data.allowOverBlock,
+    };
+}
+exports.serializeLineTextAreaPositioning = serializeLineTextAreaPositioning;

package/sdk/document/mapproxy.d.ts

@@ -8,8 +8,9 @@ export declare class MapProxy<KEY, VALUE> {
     constructor(getKeys: () => KEY[], getItem: (key: KEY) => VALUE);
     /** @ignore */
     [Symbol.iterator](): Iterator<[KEY, VALUE]>;
-    values(): Iterator<VALUE>;
+    values(): Generator<VALUE, void, unknown>;
     keys(): KEY[];
+    get size(): number;
     get(key: KEY): VALUE;
     first(): VALUE | undefined;
 }

package/sdk/document/mapproxy.js

@@ -30,6 +30,9 @@ class MapProxy {
     keys() {
         return this.getKeys();
     }
+    get size() {
+        return this.keys().length;
+    }
     get(key) {
         return this.getItem(key);
     }

package/sdk/editorclient.d.ts

@@ -3,6 +3,7 @@ import { JsonSerializable } from './core/jsonserializable';
 import { BlockDefinition } from './document/blockdefinition';
 import { BlockProxy } from './document/blockproxy';
 import { ElementProxy } from './document/elementproxy';
+import { GroupProxy } from './document/groupproxy';
 import { LineProxy } from './document/lineproxy';
 import { PageProxy } from './document/pageproxy';
 export interface XHRRequest {
@@ -164,6 +165,11 @@ export declare class EditorClient {
      * @returns the given page
      */
     getPageProxy(id: string): PageProxy;
+    /**
+     * @param id ID of the item to create a proxy for
+     * @returns the given item
+     */
+    getItemProxy(id: string): BlockProxy | LineProxy | GroupProxy;
     /**
      * @param id ID of the element to create a proxy for
      * @returns the given element

package/sdk/editorclient.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EditorClient = void 0;
-const checks_1 = require("./core/checks");
+const commandtypes_1 = require("./commandtypes");
 const blockproxyregistry_1 = require("./document/blockclasses/blockproxyregistry");
 const blockproxy_1 = require("./document/blockproxy");
 const documentproxy_1 = require("./document/documentproxy");
@@ -71,13 +71,14 @@ class EditorClient {
                 timeout: raw['to'],
             };
         })
-            .catch((raw) => {
+            .catch((error) => {
+            const raw = (0, commandtypes_1.isRawSendXHRResponse)(error) ? error : undefined;
             throw {
-                url: raw['url'],
-                responseText: raw['t'],
-                status: raw['s'],
-                headers: raw['h'],
-                timeout: raw['to'],
+                url: raw ? raw['url'] : '',
+                responseText: raw ? raw['t'] : 'An unknown error occurred',
+                status: raw ? raw['s'] : 0,
+                headers: raw ? raw['h'] : {},
+                timeout: raw ? raw['to'] : undefined,
             };
         });
     }
@@ -99,7 +100,8 @@ class EditorClient {
                 timeout: raw['to'],
             };
         })
-            .catch((raw) => {
+            .catch((error) => {
+            const raw = (0, commandtypes_1.isRawSendXHRResponse)(error) ? error : error;
             throw {
                 url: raw['url'],
                 responseText: raw['t'],
@@ -261,6 +263,23 @@ class EditorClient {
     getPageProxy(id) {
         return new pageproxy_1.PageProxy(id, this);
     }
+    /**
+     * @param id ID of the item to create a proxy for
+     * @returns the given item
+     */
+    getItemProxy(id) {
+        const type = this.sendCommand("get" /* GetElementType */, { 'id': id });
+        switch (type) {
+            case 'block':
+                return this.getBlockProxy(id);
+            case 'line':
+                return this.getLineProxy(id);
+            case 'group':
+                return new groupproxy_1.GroupProxy(id, this);
+            default:
+                throw new Error('Element ' + id + ' is not an Item; type found is ' + type);
+        }
+    }
     /**
      * @param id ID of the element to create a proxy for
      * @returns the given element
@@ -288,11 +307,7 @@ class EditorClient {
     listenToEditor() {
         lucid.listen((msg) => {
             var _a;
-            const value = (_a = this.callbacks.get(msg['id'])) === null || _a === void 0 ? void 0 : _a(msg);
-            if ((0, checks_1.isPromise)(value)) {
-                return undefined;
-            }
-            return value;
+            return (_a = this.callbacks.get(msg['id'])) === null || _a === void 0 ? void 0 : _a(msg);
         });
     }
 }

package/sdk/ui/viewport.d.ts

@@ -1,9 +1,20 @@
 import { ItemProxy } from '../document/itemproxy';
 import { PageProxy } from '../document/pageproxy';
 import { EditorClient } from '../editorclient';
+/**
+ * A text editing hook provided to [Viewport.hookTextEdit](/extension-sdk/#classes_ui_viewport-Viewport_hooktextedit)
+ * may return a TextEditCompletionCallback to specify what behavior should happen when the user finishes editing text.
+ *
+ * If this callback returns false, the edit is reverted.
+ *
+ * If this callback returns a string, the typed value is replaced with that string.
+ */
+export declare type TextEditCompletionCallback = (newValue: string) => boolean | string | Promise<boolean | string>;
 export declare class Viewport {
     private readonly client;
+    private static nextHookId;
     constructor(client: EditorClient);
+    private static nextHookName;
     /**
      * @param deep If true, and groups are selected, include the contents of those groups in the array
      * @returns An array of currently-selected items on the currently-visible page
@@ -24,4 +35,38 @@ export declare class Viewport {
      * @param items The items the camera should zoom to
      */
     focusCameraOnItems(items: ItemProxy[]): void;
+    /**
+     * If `callback` returns false, text editing is prevented.
+     * If `callback` returns true, text editing continues as normal.
+     *
+     * If `callback` returns a [TextEditCompletionCallback](/extension-sdk/#modules_ui_viewport_texteditcompletioncallback), then text editing
+     * is allowed, but that completion callback is called
+     * when the user finishes editing that text. That completion callback may return true or false to allow or deny the edit, or
+     * also may return a replacement string to use instead of the text the user actually typed. If replacement text is provided,
+     * it will be styled as close to the original as possible, but styles that apply to only parts of the original text will be
+     * discarded.
+     *
+     * @param callback Called just before the user starts editing text.
+     *
+     * @returns A handle representing this hook, which can be passed to unhookTextEdit to remove this hook.
+     */
+    hookTextEdit(callback: (item: ItemProxy, textAreaKey: string) => boolean | TextEditCompletionCallback | Promise<boolean | TextEditCompletionCallback>): string;
+    /**
+     * Remove a hook set by hookTextEdit.
+     *
+     * @param handle The return value of hookTextEdit.
+     */
+    unhookTextEdit(handle: string): void;
+    /**
+     * @param callback Called when the user changes their selection of items
+     *
+     * @returns A handle representing this hook, which can be passed to unhookSelection to remove this hook.
+     */
+    hookSelection(callback: (items: ItemProxy[]) => void): string;
+    /**
+     * Remove a hook set by hookSelection.
+     *
+     * @param handle The return value of hookSelection.
+     */
+    unhookSelection(handle: string): void;
 }

package/sdk/ui/viewport.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Viewport = void 0;
+const checks_1 = require("../core/checks");
 const itemproxy_1 = require("../document/itemproxy");
 const pageproxy_1 = require("../document/pageproxy");
 const math_1 = require("../math");
@@ -8,6 +9,9 @@ class Viewport {
     constructor(client) {
         this.client = client;
     }
+    static nextHookName() {
+        return '__viewport__hook' + Viewport.nextHookId++;
+    }
     /**
      * @param deep If true, and groups are selected, include the contents of those groups in the array
      * @returns An array of currently-selected items on the currently-visible page
@@ -47,5 +51,81 @@ class Viewport {
             });
         }
     }
+    /**
+     * If `callback` returns false, text editing is prevented.
+     * If `callback` returns true, text editing continues as normal.
+     *
+     * If `callback` returns a [TextEditCompletionCallback](/extension-sdk/#modules_ui_viewport_texteditcompletioncallback), then text editing
+     * is allowed, but that completion callback is called
+     * when the user finishes editing that text. That completion callback may return true or false to allow or deny the edit, or
+     * also may return a replacement string to use instead of the text the user actually typed. If replacement text is provided,
+     * it will be styled as close to the original as possible, but styles that apply to only parts of the original text will be
+     * discarded.
+     *
+     * @param callback Called just before the user starts editing text.
+     *
+     * @returns A handle representing this hook, which can be passed to unhookTextEdit to remove this hook.
+     */
+    hookTextEdit(callback) {
+        const actionName = Viewport.nextHookName();
+        this.client.registerAction(actionName, async (textHookParam) => {
+            const element = this.client.getElementProxy(textHookParam['i']);
+            if (element instanceof itemproxy_1.ItemProxy) {
+                const result = await callback(element, textHookParam['t']);
+                if ((0, checks_1.isBoolean)(result)) {
+                    return result;
+                }
+                else {
+                    const completeName = Viewport.nextHookName();
+                    this.client.registerAction(completeName, (textCompleteParam) => {
+                        this.client.deleteAction(completeName);
+                        return result(textCompleteParam['v']);
+                    });
+                    return completeName;
+                }
+            }
+            else {
+                //Shouldn't be possible, but just in case allow text editing as normal
+                return true;
+            }
+        });
+        this.client.sendCommand("hte" /* HookTextEdit */, { 'n': actionName });
+        return actionName;
+    }
+    /**
+     * Remove a hook set by hookTextEdit.
+     *
+     * @param handle The return value of hookTextEdit.
+     */
+    unhookTextEdit(handle) {
+        this.client.deleteAction(handle);
+        this.client.sendCommand("ute" /* UnhookTextEdit */, { 'n': handle });
+    }
+    /**
+     * @param callback Called when the user changes their selection of items
+     *
+     * @returns A handle representing this hook, which can be passed to unhookSelection to remove this hook.
+     */
+    hookSelection(callback) {
+        const actionName = Viewport.nextHookName();
+        this.client.registerAction(actionName, async (param) => {
+            const elements = param['ids']
+                .map((id) => this.client.getElementProxy(id))
+                .filter((element) => element instanceof itemproxy_1.ItemProxy);
+            callback(elements);
+        });
+        this.client.sendCommand("hs" /* HookSelection */, { 'n': actionName });
+        return actionName;
+    }
+    /**
+     * Remove a hook set by hookSelection.
+     *
+     * @param handle The return value of hookSelection.
+     */
+    unhookSelection(handle) {
+        this.client.deleteAction(handle);
+        this.client.sendCommand("us" /* UnhookSelection */, { 'n': handle });
+    }
 }
 exports.Viewport = Viewport;
+Viewport.nextHookId = 0;