lucid-extension-sdk 0.0.26 → 0.0.29

package/package.json

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

package/sdk/commandtypes.d.ts

@@ -17,6 +17,7 @@ import { PanelLocation } from './ui/panel';
  * To use these directly, use [EditorClient.sendCommand](#classes_editorclient-EditorClient_sendcommand).
  */
 export declare const enum CommandName {
+    AddCardIntegration = "aci",
     AddLineTextArea = "alta",
     AddMenuItem = "ami",
     AddShapeData = "asd",
@@ -97,6 +98,10 @@ export declare const commandTitles: Map<CommandName, string>;
  * which command name you pass in as the first parameter.
  */
 export declare type CommandArgs = {
+    [CommandName.AddCardIntegration]: {
+        query: AddCardIntegrationQuery;
+        result: AddCardIntegrationResult;
+    };
     [CommandName.AddLineTextArea]: {
         query: AddLineTextAreaQuery;
         result: AddLineTextAreaResult;
@@ -382,6 +387,17 @@ export declare type CommandArgs = {
         result: UnhookTextEditResult;
     };
 };
+export declare type AddCardIntegrationQuery = {
+    /** Title/name */
+    'n': string;
+    /** Icon url */
+    'u': string;
+    /** Callback to get field definitions for a given imported collection */
+    'gf': string;
+    /** Show intro if user has not yet authorized this integration */
+    'i'?: string;
+};
+export declare type AddCardIntegrationResult = undefined;
 export declare type AddLineTextAreaQuery = {
     /** Which line */
     'id': string;

package/sdk/commandtypes.js

@@ -4,6 +4,7 @@ exports.isRawSendXHRResponse = exports.commandTitles = void 0;
 const checks_1 = require("./core/checks");
 /** @ignore */
 exports.commandTitles = new Map([
+    ["aci" /* AddCardIntegration */, 'AddCardIntegration'],
     ["alta" /* AddLineTextArea */, 'AddLineTextArea'],
     ["ami" /* AddMenuItem */, 'AddMenuItem'],
     ["asd" /* AddShapeData */, 'AddShapeData'],

package/sdk/core/data/fieldtypedefinition/fieldtypearray.d.ts

@@ -1,16 +1,17 @@
+import { CollectionEnumFieldType, SerializedCollectionEnumFieldType } from './collectionenumfieldtype';
 import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
 import { ScalarFieldTypeEnum } from './scalarfieldtype';
 export declare class FieldTypeArray {
-    readonly validTypesArray: (ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
-    constructor(validTypesArray: (ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[]);
-    getInnerTypes(): (ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
-    getInnerNonArrayTypes(): (ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
+    readonly validTypesArray: (ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray)[];
+    constructor(validTypesArray: (ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray)[]);
+    getInnerTypes(): (CollectionEnumFieldType | ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
+    getInnerNonArrayTypes(): (CollectionEnumFieldType | ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
     serialize(): SerializedFieldTypeArray;
 }
-export declare function isValidTypeForFieldTypeArray(fieldType: any): fieldType is ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray;
+export declare function isValidTypeForFieldTypeArray(fieldType: any): fieldType is ScalarFieldTypeEnum | LiteralFieldType | CollectionEnumFieldType | FieldTypeArray;
 export declare type SerializedFieldTypeArray = {
     'ND': false;
-    'validTypes': (ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray)[];
+    'validTypes': (ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedCollectionEnumFieldType)[];
 };
 export declare function isSerializedFieldTypeArray(fieldType: any, validateTypeCheck: (t: unknown) => boolean): fieldType is SerializedFieldTypeArray;
 export declare function deserializeFieldTypeArray(serializedFieldTypeArray: SerializedFieldTypeArray): FieldTypeArray;

package/sdk/core/data/fieldtypedefinition/fieldtypearray.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deserializeFieldTypeArray = exports.isSerializedFieldTypeArray = exports.isValidTypeForFieldTypeArray = exports.FieldTypeArray = void 0;
 const checks_1 = require("../../checks");
+const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
 const literalfieldtype_1 = require("./literalfieldtype");
 const scalarfieldtype_1 = require("./scalarfieldtype");
 class FieldTypeArray {
@@ -23,7 +24,10 @@ class FieldTypeArray {
 }
 exports.FieldTypeArray = FieldTypeArray;
 function isValidTypeForFieldTypeArray(fieldType) {
-    return (0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) || (0, literalfieldtype_1.isLiteralFieldType)(fieldType) || fieldType instanceof FieldTypeArray;
+    return ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) ||
+        (0, literalfieldtype_1.isLiteralFieldType)(fieldType) ||
+        (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType) ||
+        fieldType instanceof FieldTypeArray);
 }
 exports.isValidTypeForFieldTypeArray = isValidTypeForFieldTypeArray;
 function isSerializedFieldTypeArray(fieldType, validateTypeCheck) {
@@ -41,6 +45,9 @@ function deserializeFieldTypeArray(serializedFieldTypeArray) {
         if ((0, literalfieldtype_1.isSerializedLiteralFieldType)(t)) {
             return (0, literalfieldtype_1.deserializeLiteralFieldType)(t);
         }
+        else if ((0, collectionenumfieldtype_1.isSerializedCollectionEnumFieldType)(t)) {
+            return (0, collectionenumfieldtype_1.deserializeCollectionEnumFieldType)(t);
+        }
         else if ((0, checks_1.isObject)(t)) {
             return deserializeFieldTypeArray(t);
         }

package/sdk/core/properties/cardintegration.d.ts

@@ -0,0 +1,85 @@
+import { CollectionProxy } from '../../data/collectionproxy';
+/**
+ * When this field is displayed on a card shape, how should it be displayed?
+ */
+export declare enum CardFieldDisplayType {
+    Text = 1,
+    TextBadge = 2,
+    ImageBadge = 3
+}
+export declare enum CardFieldDataType {
+    Text = 1,
+    Number = 2,
+    /** An enumerated list of options, stored as a string */
+    Option = 3,
+    Checkbox = 4
+}
+/** For fields with Option or ApiOption type, the label and value for each available option */
+export interface ExtensionCardFieldOption {
+    label: string;
+    value: string;
+}
+export interface ExtensionCardFieldDefinition {
+    /** Data identifier */
+    fieldName: string;
+    /** The text to display on the menu item */
+    label: string;
+    /** Additional information we can provide to users */
+    description?: string;
+    /** How a field is displayed */
+    displayType: CardFieldDisplayType;
+    /** Data type backing the field */
+    dataType: CardFieldDataType;
+    /** If dataType is Option, the list of options available to choose from */
+    options?: ExtensionCardFieldOption[];
+}
+/** @ignore */
+export declare type SerializedCardFieldOption = {
+    'l': string;
+    'v': string;
+};
+/** @ignore */
+export declare function serializeCardFieldOption(option: ExtensionCardFieldOption): SerializedCardFieldOption;
+/** @ignore */
+export declare type SerializedExtensionCardFieldDefinition = {
+    'n': string;
+    't': string;
+    'd'?: string;
+    'diT': number;
+    'daT': number;
+    'op'?: SerializedCardFieldOption[];
+};
+/** @ignore */
+export declare function serializeCardFieldDefinition(field: ExtensionCardFieldDefinition): SerializedExtensionCardFieldDefinition;
+/** @ignore */
+export declare function serializeCardFieldArrayDefinition(fields: ExtensionCardFieldDefinition[]): SerializedExtensionCardFieldDefinition[];
+/** @ignore */
+export declare function deseializeFieldOption(option: SerializedCardFieldOption): ExtensionCardFieldOption;
+/** @ignore */
+export declare function deserializeCardFieldDefinition(field: SerializedExtensionCardFieldDefinition): ExtensionCardFieldDefinition;
+/** @ignore */
+export declare function deserializeCardFieldArrayDefinition(fields: SerializedExtensionCardFieldDefinition[]): ExtensionCardFieldDefinition[];
+export interface CardIntegration {
+    /**
+     * Label used to identify the integration, e.g. "Jira", which will be used in menu items, etc.
+     * Should be unique within any given extension.
+     */
+    label: string;
+    /**
+     * URL for an icon to display in toolbars, etc. Should be at least 24x24.
+     */
+    iconUrl: string;
+    /**
+     * Callback to provide a list of field definitions for the given collection, if that collection
+     * was imported as part of this card integration.
+     *
+     * Any fields on the schema of the collection that you don't provide a ExtensionCardFieldDefinition
+     * for will have a default definition generated based on the type specified in the schema.
+     */
+    getAllFields: (collection: CollectionProxy) => Promise<ExtensionCardFieldDefinition[]>;
+    /**
+     * If specified, and the user hasn't yet authorized the data connector for this extension,
+     * this should show the user an intro dialog or take some other action.
+     */
+    showIntro?: () => void;
+}

package/sdk/core/properties/cardintegration.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.deseializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = exports.CardFieldDataType = exports.CardFieldDisplayType = void 0;
+/**
+ * When this field is displayed on a card shape, how should it be displayed?
+ */
+var CardFieldDisplayType;
+(function (CardFieldDisplayType) {
+    CardFieldDisplayType[CardFieldDisplayType["Text"] = 1] = "Text";
+    CardFieldDisplayType[CardFieldDisplayType["TextBadge"] = 2] = "TextBadge";
+    CardFieldDisplayType[CardFieldDisplayType["ImageBadge"] = 3] = "ImageBadge";
+})(CardFieldDisplayType = exports.CardFieldDisplayType || (exports.CardFieldDisplayType = {}));
+var CardFieldDataType;
+(function (CardFieldDataType) {
+    CardFieldDataType[CardFieldDataType["Text"] = 1] = "Text";
+    CardFieldDataType[CardFieldDataType["Number"] = 2] = "Number";
+    /** An enumerated list of options, stored as a string */
+    CardFieldDataType[CardFieldDataType["Option"] = 3] = "Option";
+    CardFieldDataType[CardFieldDataType["Checkbox"] = 4] = "Checkbox";
+})(CardFieldDataType = exports.CardFieldDataType || (exports.CardFieldDataType = {}));
+/** @ignore */
+function serializeCardFieldOption(option) {
+    return {
+        'l': option.label,
+        'v': option.value,
+    };
+}
+exports.serializeCardFieldOption = serializeCardFieldOption;
+/** @ignore */
+function serializeCardFieldDefinition(field) {
+    var _a;
+    return {
+        'n': field.fieldName,
+        't': field.label,
+        'd': field.description,
+        'diT': field.displayType,
+        'daT': field.dataType,
+        'op': (_a = field.options) === null || _a === void 0 ? void 0 : _a.map(serializeCardFieldOption),
+    };
+}
+exports.serializeCardFieldDefinition = serializeCardFieldDefinition;
+/** @ignore */
+function serializeCardFieldArrayDefinition(fields) {
+    return fields.map(serializeCardFieldDefinition);
+}
+exports.serializeCardFieldArrayDefinition = serializeCardFieldArrayDefinition;
+/** @ignore */
+function deseializeFieldOption(option) {
+    return {
+        label: option['l'],
+        value: option['v'],
+    };
+}
+exports.deseializeFieldOption = deseializeFieldOption;
+/** @ignore */
+function deserializeCardFieldDefinition(field) {
+    var _a;
+    return {
+        fieldName: field['n'],
+        label: field['t'],
+        description: field['d'],
+        displayType: field['diT'],
+        dataType: field['daT'],
+        options: (_a = field['op']) === null || _a === void 0 ? void 0 : _a.map(deseializeFieldOption),
+    };
+}
+exports.deserializeCardFieldDefinition = deserializeCardFieldDefinition;
+/** @ignore */
+function deserializeCardFieldArrayDefinition(fields) {
+    return fields.map(deserializeCardFieldDefinition);
+}
+exports.deserializeCardFieldArrayDefinition = deserializeCardFieldArrayDefinition;

package/sdk/document/taskmanagementcardintegration.d.ts

@@ -0,0 +1,13 @@
+import { CardIntegration } from '../core/properties/cardintegration';
+import { EditorClient } from '../editorclient';
+export declare class TaskManagementCardIntegration {
+    private readonly client;
+    constructor(client: EditorClient);
+    private static nextHookId;
+    private static nextHookName;
+    /**
+     * Register a new card integration.
+     * @param card The definition of the new card integration
+     */
+    addCardIntegration(card: CardIntegration): void;
+}

package/sdk/document/taskmanagementcardintegration.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManagementCardIntegration = void 0;
+const cardintegration_1 = require("../core/properties/cardintegration");
+const collectionproxy_1 = require("../data/collectionproxy");
+class TaskManagementCardIntegration {
+    constructor(client) {
+        this.client = client;
+    }
+    static nextHookName() {
+        return '__taskmanagementcard__hook' + TaskManagementCardIntegration.nextHookId++;
+    }
+    /**
+     * Register a new card integration.
+     * @param card The definition of the new card integration
+     */
+    addCardIntegration(card) {
+        const getFieldsActionName = TaskManagementCardIntegration.nextHookName();
+        this.client.registerAction(getFieldsActionName, async (param) => {
+            const collection = new collectionproxy_1.CollectionProxy(param['c'], this.client);
+            const fields = await card.getAllFields(collection);
+            const serializedFields = (0, cardintegration_1.serializeCardFieldArrayDefinition)(fields);
+            return serializedFields;
+        });
+        let showIntroActionName = undefined;
+        if (card.showIntro) {
+            showIntroActionName = TaskManagementCardIntegration.nextHookName();
+            this.client.registerAction(showIntroActionName, card.showIntro);
+        }
+        this.client.sendCommand("aci" /* AddCardIntegration */, {
+            'n': card.label,
+            'u': card.iconUrl,
+            'gf': getFieldsActionName,
+            'i': showIntroActionName,
+        });
+    }
+}
+exports.TaskManagementCardIntegration = TaskManagementCardIntegration;
+TaskManagementCardIntegration.nextHookId = 0;

package/sdk/ui/panel.d.ts

@@ -5,7 +5,9 @@ import { IframeUI } from './iframeui';
  */
 export declare enum PanelLocation {
     /** In Lucidchart, create a sibling to the Contextual Panel */
-    RightDock = 1
+    RightDock = 1,
+    /** In Lucidchart, create a sibling to the shape toolbox */
+    ContentDock = 2
 }
 export interface PanelConfig {
     /** Title to display at the top of the panel */

package/sdk/ui/panel.js

@@ -9,6 +9,8 @@ var PanelLocation;
 (function (PanelLocation) {
     /** In Lucidchart, create a sibling to the Contextual Panel */
     PanelLocation[PanelLocation["RightDock"] = 1] = "RightDock";
+    /** In Lucidchart, create a sibling to the shape toolbox */
+    PanelLocation[PanelLocation["ContentDock"] = 2] = "ContentDock";
 })(PanelLocation = exports.PanelLocation || (exports.PanelLocation = {}));
 /**
  * Extend this class to show a custom panel to the user, whose contents are displayed in a sandboxed