lucid-extension-sdk 0.0.3 → 0.0.4

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

@@ -0,0 +1,17 @@
+import { ScalarFieldTypeEnum } from './scalarfieldtype';
+export declare class LiteralFieldType {
+    static literalStringPrefix: string;
+    private readonly literal;
+    private scalarFieldType;
+    constructor(literal: boolean | number | string);
+    getLiteral(): string | number | boolean;
+    getScalarFieldType(): ScalarFieldTypeEnum;
+    serialize(): SerializedLiteralFieldType;
+}
+export declare function isLiteralFieldType(fieldType: any): fieldType is LiteralFieldType;
+export declare type SerializedLiteralFieldType = string;
+export declare function isSerializedLiteralFieldType(definition: any): definition is SerializedLiteralFieldType;
+/**
+ * String literals without the literalStringPrefix will return the boolean literal false
+ */
+export declare function deserializeLiteralFieldType(serializedLiteralFieldType: SerializedLiteralFieldType): LiteralFieldType;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeLiteralFieldType = exports.isSerializedLiteralFieldType = exports.isLiteralFieldType = exports.LiteralFieldType = void 0;
+const checks_1 = require("../../checks");
+const scalarfieldtype_1 = require("./scalarfieldtype");
+class LiteralFieldType {
+    constructor(literal) {
+        this.scalarFieldType = scalarfieldtype_1.ScalarFieldTypeEnum.ANY;
+        if ((0, checks_1.isString)(literal)) {
+            this.literal = literal.substring(LiteralFieldType.literalStringPrefix.length);
+            this.scalarFieldType = scalarfieldtype_1.ScalarFieldTypeEnum.STRING;
+        }
+        else if ((0, checks_1.isBoolean)(literal)) {
+            this.literal = literal;
+            this.scalarFieldType = scalarfieldtype_1.ScalarFieldTypeEnum.BOOLEAN;
+        }
+        else {
+            this.literal = literal;
+            this.scalarFieldType = scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER;
+        }
+    }
+    getLiteral() {
+        return this.literal;
+    }
+    getScalarFieldType() {
+        return this.scalarFieldType;
+    }
+    serialize() {
+        if (this.scalarFieldType === scalarfieldtype_1.ScalarFieldTypeEnum.STRING) {
+            return LiteralFieldType.literalStringPrefix + this.literal;
+        }
+        return this.literal.toString();
+    }
+}
+exports.LiteralFieldType = LiteralFieldType;
+LiteralFieldType.literalStringPrefix = '%';
+function isLiteralFieldType(fieldType) {
+    return fieldType instanceof LiteralFieldType;
+}
+exports.isLiteralFieldType = isLiteralFieldType;
+function isSerializedLiteralFieldType(definition) {
+    return (0, checks_1.isString)(definition);
+}
+exports.isSerializedLiteralFieldType = isSerializedLiteralFieldType;
+/**
+ * String literals without the literalStringPrefix will return the boolean literal false
+ */
+function deserializeLiteralFieldType(serializedLiteralFieldType) {
+    if (serializedLiteralFieldType.startsWith(LiteralFieldType.literalStringPrefix)) {
+        return new LiteralFieldType(serializedLiteralFieldType);
+    }
+    const numberLiteral = Number(serializedLiteralFieldType);
+    if (isNaN(numberLiteral) ||
+        numberLiteral === Number.POSITIVE_INFINITY ||
+        numberLiteral === Number.NEGATIVE_INFINITY) {
+        return new LiteralFieldType(serializedLiteralFieldType === 'true');
+    }
+    return new LiteralFieldType(numberLiteral);
+}
+exports.deserializeLiteralFieldType = deserializeLiteralFieldType;

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

@@ -0,0 +1,17 @@
+import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
+import { ScalarFieldTypeEnum } from './scalarfieldtype';
+export declare class NDimensionalFieldTypeArray {
+    readonly validTypesArray: (ScalarFieldTypeEnum | LiteralFieldType)[];
+    constructor(validTypesArray: (ScalarFieldTypeEnum | LiteralFieldType)[]);
+    getInnerTypes(): (ScalarFieldTypeEnum | LiteralFieldType | this)[];
+    getInnerNonArrayTypes(): (ScalarFieldTypeEnum | LiteralFieldType)[];
+    serialize(): SerializedNDimensionalFieldTypeArray;
+}
+export declare function isValidTypeForNDimensionalFieldTypeArray(fieldType: any): fieldType is ScalarFieldTypeEnum | LiteralFieldType;
+export declare function isNDimensionalFieldTypeArray(fieldType: any): fieldType is NDimensionalFieldTypeArray;
+export declare type SerializedNDimensionalFieldTypeArray = {
+    'ND': true;
+    'validTypes': (ScalarFieldTypeEnum | SerializedLiteralFieldType)[];
+};
+export declare function isSerializedNDimensionalFieldTypeArray(fieldType: any): fieldType is SerializedNDimensionalFieldTypeArray;
+export declare function deserializeNDimensionalFieldTypeArray(serializedNDimensionalFieldTypeArray: SerializedNDimensionalFieldTypeArray): NDimensionalFieldTypeArray;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeNDimensionalFieldTypeArray = exports.isSerializedNDimensionalFieldTypeArray = exports.isNDimensionalFieldTypeArray = exports.isValidTypeForNDimensionalFieldTypeArray = exports.NDimensionalFieldTypeArray = void 0;
+const checks_1 = require("../../checks");
+const literalfieldtype_1 = require("./literalfieldtype");
+const scalarfieldtype_1 = require("./scalarfieldtype");
+class NDimensionalFieldTypeArray {
+    constructor(validTypesArray) {
+        this.validTypesArray = validTypesArray;
+    }
+    getInnerTypes() {
+        return [...this.validTypesArray, this];
+    }
+    getInnerNonArrayTypes() {
+        return this.validTypesArray.filter((innerType) => (0, scalarfieldtype_1.isScalarFieldTypeEnum)(innerType) || (0, literalfieldtype_1.isLiteralFieldType)(innerType));
+    }
+    serialize() {
+        return {
+            'ND': true,
+            'validTypes': this.validTypesArray.map((t) => ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(t) ? t : t.serialize())),
+        };
+    }
+}
+exports.NDimensionalFieldTypeArray = NDimensionalFieldTypeArray;
+function isValidTypeForNDimensionalFieldTypeArray(fieldType) {
+    return (0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) || (0, literalfieldtype_1.isLiteralFieldType)(fieldType);
+}
+exports.isValidTypeForNDimensionalFieldTypeArray = isValidTypeForNDimensionalFieldTypeArray;
+function isNDimensionalFieldTypeArray(fieldType) {
+    return fieldType instanceof NDimensionalFieldTypeArray;
+}
+exports.isNDimensionalFieldTypeArray = isNDimensionalFieldTypeArray;
+function isSerializedNDimensionalFieldTypeArray(fieldType) {
+    return ((0, checks_1.isObject)(fieldType) &&
+        (0, checks_1.isBoolean)(fieldType['ND']) &&
+        fieldType['ND'] === true &&
+        (0, checks_1.isTypedArray)(checks_1.isAny)(fieldType['validTypes']) &&
+        fieldType['validTypes'].every((validType) => {
+            return (0, checks_1.isDefAndNotNull)(scalarfieldtype_1.ScalarFieldTypeEnum[validType]) || (0, literalfieldtype_1.isSerializedLiteralFieldType)(validType);
+        }));
+}
+exports.isSerializedNDimensionalFieldTypeArray = isSerializedNDimensionalFieldTypeArray;
+function deserializeNDimensionalFieldTypeArray(serializedNDimensionalFieldTypeArray) {
+    return new NDimensionalFieldTypeArray(serializedNDimensionalFieldTypeArray['validTypes'].map((t) => {
+        if ((0, literalfieldtype_1.isSerializedLiteralFieldType)(t)) {
+            return (0, literalfieldtype_1.deserializeLiteralFieldType)(t);
+        }
+        return t;
+    }));
+}
+exports.deserializeNDimensionalFieldTypeArray = deserializeNDimensionalFieldTypeArray;

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

@@ -0,0 +1,14 @@
+export declare enum ScalarFieldTypeEnum {
+    ANY = 0,
+    NUMBER = 1,
+    BOOLEAN = 2,
+    STRING = 3,
+    COLOR = 4,
+    DATE = 5,
+    NULL = 6,
+    DICTIONARY = 7,
+    CURRENCY = 8,
+    DATEONLY = 9
+}
+export declare const AnyScalarFieldType: ScalarFieldTypeEnum[];
+export declare const isScalarFieldTypeEnum: (fieldType: any) => fieldType is ScalarFieldTypeEnum;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScalarFieldTypeEnum = exports.AnyScalarFieldType = exports.ScalarFieldTypeEnum = void 0;
+var ScalarFieldTypeEnum;
+(function (ScalarFieldTypeEnum) {
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["ANY"] = 0] = "ANY";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["NUMBER"] = 1] = "NUMBER";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["BOOLEAN"] = 2] = "BOOLEAN";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["STRING"] = 3] = "STRING";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["COLOR"] = 4] = "COLOR";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["DATE"] = 5] = "DATE";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["NULL"] = 6] = "NULL";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["DICTIONARY"] = 7] = "DICTIONARY";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["CURRENCY"] = 8] = "CURRENCY";
+    ScalarFieldTypeEnum[ScalarFieldTypeEnum["DATEONLY"] = 9] = "DATEONLY";
+})(ScalarFieldTypeEnum = exports.ScalarFieldTypeEnum || (exports.ScalarFieldTypeEnum = {}));
+exports.AnyScalarFieldType = [
+    ScalarFieldTypeEnum.ANY,
+    ScalarFieldTypeEnum.NUMBER,
+    ScalarFieldTypeEnum.STRING,
+    ScalarFieldTypeEnum.BOOLEAN,
+    ScalarFieldTypeEnum.COLOR,
+    ScalarFieldTypeEnum.DATE,
+    ScalarFieldTypeEnum.DATEONLY,
+    ScalarFieldTypeEnum.NULL,
+    ScalarFieldTypeEnum.DICTIONARY,
+    ScalarFieldTypeEnum.CURRENCY,
+];
+const AnyScalarFieldTypeSet = new Set(exports.AnyScalarFieldType);
+const isScalarFieldTypeEnum = (fieldType) => {
+    return AnyScalarFieldTypeSet.has(fieldType);
+};
+exports.isScalarFieldTypeEnum = isScalarFieldTypeEnum;

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

@@ -0,0 +1,24 @@
+import { SerializedFieldType } from '../serializedfield/serializedfields';
+import { SerializedSchema } from '../serializedfield/serializedschema';
+export declare const FlattenedReferenceKeyId = "192d0e9f-2f5a-4032-9f03-59bbf1ea5891";
+export declare const FlattenedReferenceKeyName = "192d0e9f-2f5a-4032-9f03-59bbf1ea5891_n";
+export interface SerializedReferenceKey {
+    'cid': string;
+    'pk': string;
+    'wl'?: string[];
+    'ro'?: boolean;
+}
+export declare type TypedSerializedFlattenedReference = {
+    'sc': SerializedSchema;
+    'n'?: string;
+    'd': {
+        [index: string]: SerializedFieldType;
+    };
+};
+export declare type UnTypedSerializedFlattenedReference = {
+    [FlattenedReferenceKeyId]: true;
+    [FlattenedReferenceKeyName]?: string;
+    [index: string]: SerializedFieldType;
+};
+export declare type SerializedFlattenedReference = TypedSerializedFlattenedReference | UnTypedSerializedFlattenedReference;
+export declare type SerializedReferenceKeyType = SerializedReferenceKey | SerializedFlattenedReference;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlattenedReferenceKeyName = exports.FlattenedReferenceKeyId = void 0;
+exports.FlattenedReferenceKeyId = '192d0e9f-2f5a-4032-9f03-59bbf1ea5891';
+exports.FlattenedReferenceKeyName = '192d0e9f-2f5a-4032-9f03-59bbf1ea5891_n';

package/sdk/core/data/serializedfield/serializeddataitems.d.ts

@@ -0,0 +1,5 @@
+import { SerializedFields } from './serializedfields';
+export interface SerializedDataItems {
+    [primaryKey: string]: SerializedFields;
+}
+export declare function isSerializedDataItems(x: unknown): x is SerializedDataItems;

package/sdk/core/data/serializedfield/serializeddataitems.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedDataItems = void 0;
+const checks_1 = require("../../checks");
+const serializedfields_1 = require("./serializedfields");
+function isSerializedDataItems(x) {
+    return (0, checks_1.isObject)(x) && Object.values(x).every(serializedfields_1.isSerializedFields);
+}
+exports.isSerializedDataItems = isSerializedDataItems;

package/sdk/core/data/serializedfield/serializedfielddefinition.d.ts

@@ -0,0 +1,19 @@
+import { JsonSerializable } from '../../jsonserializable';
+import { SerializedFieldTypeDefinition } from '../fieldtypedefinition/fieldtypedefinition';
+export declare type SerializedFieldDefinition = {
+    'Name': string;
+    'Type': SerializedFieldTypeDefinition;
+    'Constraints'?: SerializedFieldConstraint[];
+    'SyncSchema'?: string;
+};
+export declare enum FieldConstraintType {
+    REQUIRED = "required",
+    LOCKED = "locked",
+    MIN_VALUE = "minValue",
+    MAX_VALUE = "maxValue",
+    SINGLE_LINE_ONLY = "singleLineOnly"
+}
+export declare type SerializedFieldConstraint = {
+    'Type': FieldConstraintType;
+    'Details'?: JsonSerializable;
+};

package/sdk/core/data/serializedfield/serializedfielddefinition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldConstraintType = void 0;
+// The options here must match com.lucidchart.data.model.fielddefinition.FieldConstraintType on the backend
+var FieldConstraintType;
+(function (FieldConstraintType) {
+    FieldConstraintType["REQUIRED"] = "required";
+    FieldConstraintType["LOCKED"] = "locked";
+    FieldConstraintType["MIN_VALUE"] = "minValue";
+    FieldConstraintType["MAX_VALUE"] = "maxValue";
+    FieldConstraintType["SINGLE_LINE_ONLY"] = "singleLineOnly";
+})(FieldConstraintType = exports.FieldConstraintType || (exports.FieldConstraintType = {}));

package/sdk/core/{serializedfields.js → data/serializedfield/serializedfields.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSerializedFields = exports.isSerializedFieldType = exports.isSerializedLucidDateObject = exports.isSerializedLucidCurrency = exports.isSerializedLucidDictionary = exports.isSerializedColorObjectFieldType = void 0;
-const checks_1 = require("./checks");
+const checks_1 = require("../../checks");
 function isSerializedColorObjectFieldType(value) {
     return (0, checks_1.isObject)(value) && (0, checks_1.isObject)(value['color']);
 }

package/sdk/core/data/serializedfield/serializedschema.d.ts

@@ -0,0 +1,9 @@
+import { SerializedFieldDefinition } from './serializedfielddefinition';
+export declare type SerializedLabelOverrides = {
+    [key: string]: string;
+};
+export declare type SerializedSchema = {
+    'Fields': SerializedFieldDefinition[];
+    'PrimaryKey': string[];
+    'FieldLabelOverrides'?: SerializedLabelOverrides;
+};

package/sdk/core/data/serializedfield/serializedschema.js

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

package/sdk/data/collectionproxy.d.ts

@@ -1,3 +1,4 @@
+import { SerializedFieldType } from '../core/data/serializedfield/serializedfields';
 import { ElementProxy } from '../document/elementproxy';
 import { MapProxy } from '../document/mapproxy';
 import { EditorClient } from '../editorclient';
@@ -33,6 +34,11 @@ export declare class CollectionProxy extends ElementProxy {
      * there are two data items that would have the same primary key.
      */
     readonly items: MapProxy<string, DataItemProxy>;
+    patchItems(patch: {
+        added?: Record<string, SerializedFieldType>[];
+        changed?: Map<string, Record<string, SerializedFieldType>>;
+        deleted?: string[];
+    }): void;
     /**
      * @returns an array of field names that are accessible on the items in this collection
      */

package/sdk/data/collectionproxy.js

@@ -42,6 +42,21 @@ class CollectionProxy extends elementproxy_1.ElementProxy {
         const id = this.properties.get('BranchedFrom');
         return id ? new CollectionProxy(id, this.client) : undefined;
     }
+    patchItems(patch) {
+        var _a, _b;
+        const changed = {};
+        if (patch.changed) {
+            for (const [primaryKey, record] of patch.changed) {
+                changed[primaryKey] = record;
+            }
+        }
+        this.client.sendCommand("pdi" /* PatchDataItems */, {
+            'id': this.id,
+            'a': (_a = patch.added) !== null && _a !== void 0 ? _a : [],
+            'c': changed,
+            'd': (_b = patch.deleted) !== null && _b !== void 0 ? _b : [],
+        });
+    }
     /**
      * @returns an array of field names that are accessible on the items in this collection
      */

package/sdk/data/dataproxy.d.ts

@@ -1,3 +1,4 @@
+import { JsonSerializable } from '../core/jsonserializable';
 import { MapProxy } from '../document/mapproxy';
 import { EditorClient } from '../editorclient';
 import { DataSourceProxy } from './datasourceproxy';
@@ -16,4 +17,15 @@ export declare class DataProxy {
      */
     readonly dataSources: MapProxy<string, DataSourceProxy>;
     constructor(client: EditorClient);
+    /**
+     * Creates a new empty data source, which you can then add collections of data to.
+     *
+     * @param name Human-readable name of the new data source
+     * @param sourceConfig Any configuration values that might be useful to reference later, such
+     *  as the upstream origin of this data source
+     * @returns the newly created data source
+     */
+    addDataSource(name: string, sourceConfig: {
+        [key: string]: JsonSerializable;
+    }): DataSourceProxy;
 }

package/sdk/data/dataproxy.js

@@ -19,5 +19,16 @@ class DataProxy {
          */
         this.dataSources = new mapproxy_1.MapProxy(() => this.client.sendCommand("lds" /* ListDataSources */, undefined), (dataSourceId) => new datasourceproxy_1.DataSourceProxy(dataSourceId, this.client));
     }
+    /**
+     * Creates a new empty data source, which you can then add collections of data to.
+     *
+     * @param name Human-readable name of the new data source
+     * @param sourceConfig Any configuration values that might be useful to reference later, such
+     *  as the upstream origin of this data source
+     * @returns the newly created data source
+     */
+    addDataSource(name, sourceConfig) {
+        return new datasourceproxy_1.DataSourceProxy(this.client.sendCommand("cds" /* CreateDataSource */, { 'n': name, 's': sourceConfig }), this.client);
+    }
 }
 exports.DataProxy = DataProxy;

package/sdk/data/datasourceproxy.d.ts

@@ -1,7 +1,9 @@
+import { JsonSerializable } from '../core/jsonserializable';
 import { ElementProxy } from '../document/elementproxy';
 import { MapProxy } from '../document/mapproxy';
 import { EditorClient } from '../editorclient';
 import { CollectionProxy } from './collectionproxy';
+import { SchemaDefinition } from './schemadefinition';
 /**
  * A data source represents a set of related data collections on a document. Typically one data source
  * is produced for each data import.
@@ -19,8 +21,15 @@ export declare class DataSourceProxy extends ElementProxy {
      * the collection ID on other documents if the same data is imported there.
      */
     readonly collections: MapProxy<string, CollectionProxy>;
+    addCollection(name: string, schema: SchemaDefinition): CollectionProxy;
     /**
      * @returns a human-readable name for this data source
      */
     getName(): string;
+    /**
+     * @returns The source configuration values set when this data source was created
+     */
+    getSourceConfig(): {
+        [key: string]: JsonSerializable;
+    };
 }

package/sdk/data/datasourceproxy.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataSourceProxy = void 0;
+const checks_1 = require("../core/checks");
+const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 const elementproxy_1 = require("../document/elementproxy");
 const mapproxy_1 = require("../document/mapproxy");
 const collectionproxy_1 = require("./collectionproxy");
@@ -23,11 +25,29 @@ class DataSourceProxy extends elementproxy_1.ElementProxy {
          */
         this.collections = new mapproxy_1.MapProxy(() => this.client.sendCommand("lc" /* ListCollections */, { 'id': this.id }), (id) => new collectionproxy_1.CollectionProxy(id, this.client));
     }
+    addCollection(name, schema) {
+        return new collectionproxy_1.CollectionProxy(this.client.sendCommand("cc" /* CreateCollection */, {
+            's': this.id,
+            'n': name,
+            'f': schema.fields.map((field) => ({ 'n': field.name, 't': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.type) })),
+            'p': schema.primaryKey,
+        }), this.client);
+    }
     /**
      * @returns a human-readable name for this data source
      */
     getName() {
         return this.properties.get('Name');
     }
+    /**
+     * @returns The source configuration values set when this data source was created
+     */
+    getSourceConfig() {
+        const upstream = this.properties.get('Upstream');
+        if ((0, checks_1.isObject)(upstream)) {
+            return upstream['SourceConfig'];
+        }
+        return {};
+    }
 }
 exports.DataSourceProxy = DataSourceProxy;

package/sdk/data/referencekeydefinition.d.ts

@@ -0,0 +1,17 @@
+import { SerializedReferenceKeyType } from '../core/data/referencekeys/serializedreferencekey';
+import { SerializedFieldType } from '../core/data/serializedfield/serializedfields';
+import { SchemaDefinition } from './schemadefinition';
+export interface CollectionReferenceKeyDefinition {
+    collectionId: string;
+    primaryKey: string;
+    fieldWhitelist?: string[];
+    readonly?: boolean;
+}
+export interface FlattenedReferenceDefinition {
+    name: string;
+    schema: SchemaDefinition;
+    data: Record<string, SerializedFieldType>;
+}
+export declare type ReferenceKeyDefinition = CollectionReferenceKeyDefinition | FlattenedReferenceDefinition;
+export declare function isCollectionReferenceKeyDefinition(def: ReferenceKeyDefinition): def is CollectionReferenceKeyDefinition;
+export declare function serializeReferenceKeyDefinition(def: ReferenceKeyDefinition): SerializedReferenceKeyType;

package/sdk/data/referencekeydefinition.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeReferenceKeyDefinition = exports.isCollectionReferenceKeyDefinition = void 0;
+const checks_1 = require("../core/checks");
+const schemadefinition_1 = require("./schemadefinition");
+function isCollectionReferenceKeyDefinition(def) {
+    return (0, checks_1.isString)(def.collectionId);
+}
+exports.isCollectionReferenceKeyDefinition = isCollectionReferenceKeyDefinition;
+function serializeReferenceKeyDefinition(def) {
+    if (isCollectionReferenceKeyDefinition(def)) {
+        return {
+            'cid': def.collectionId,
+            'pk': def.primaryKey,
+            'wl': def.fieldWhitelist,
+            'ro': def.readonly,
+        };
+    }
+    else {
+        return {
+            'sc': (0, schemadefinition_1.serializeSchemaDefinition)(def.schema),
+            'n': def.name,
+            'd': def.data,
+        };
+    }
+}
+exports.serializeReferenceKeyDefinition = serializeReferenceKeyDefinition;

package/sdk/data/referencekeyproxy.d.ts

@@ -0,0 +1,9 @@
+import { SerializedReferenceKeyType } from '../core/data/referencekeys/serializedreferencekey';
+import { EditorClient } from '../editorclient';
+export declare class ReferenceKeyProxy {
+    readonly elementId: string | undefined;
+    readonly key: string | number;
+    private readonly client;
+    private readonly settings;
+    constructor(elementId: string | undefined, key: string | number, client: EditorClient, settings: SerializedReferenceKeyType);
+}

package/sdk/data/referencekeyproxy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceKeyProxy = void 0;
+class ReferenceKeyProxy {
+    constructor(elementId, key, client, settings) {
+        this.elementId = elementId;
+        this.key = key;
+        this.client = client;
+        this.settings = settings;
+    }
+}
+exports.ReferenceKeyProxy = ReferenceKeyProxy;

package/sdk/data/schemadefinition.d.ts

@@ -0,0 +1,11 @@
+import { FieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
+import { SerializedSchema } from '../core/data/serializedfield/serializedschema';
+export interface FieldDefinition {
+    name: string;
+    type: FieldTypeDefinition;
+}
+export interface SchemaDefinition {
+    fields: FieldDefinition[];
+    primaryKey: string[];
+}
+export declare function serializeSchemaDefinition(def: SchemaDefinition): SerializedSchema;

package/sdk/data/schemadefinition.js

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

package/sdk/document/blockdefinition.d.ts

@@ -1,3 +1,4 @@
+import { JsonObject, JsonSerializable } from '../../lucid-extension-sdk';
 import { Box } from '../math';
 /**
  * The information required to create a new block on the current document
@@ -11,4 +12,13 @@ export interface BlockDefinition {
      * The initial location and size of the block on the page.
      */
     boundingBox: Box;
+    /**
+     * Additional properties to set on the block immediately after creation
+     */
+    properties: JsonObject;
+    /**
+     * If specified, the stencil to use for a custom shape. This is not typically set directly; use
+     * PageProxy.getCustomShapeDefinition().
+     */
+    stencil?: JsonSerializable;
 }

package/sdk/document/elementproxy.d.ts

@@ -1,3 +1,5 @@
+import { ReferenceKeyDefinition } from '../data/referencekeydefinition';
+import { ReferenceKeyProxy } from '../data/referencekeyproxy';
 import { EditorClient } from '../editorclient';
 import { MapProxy, WriteableMapProxy } from './mapproxy';
 import { ShapeDataProxy } from './shapedataproxy';
@@ -27,6 +29,9 @@ export declare class ElementProxy {
      * This collection is read-only.
      */
     readonly allShapeData: MapProxy<string, import("..").SerializedFieldType | import("..").DataError>;
+    readonly referenceKeys: MapProxy<string | number, ReferenceKeyProxy>;
+    setReferenceKey(key: number | string, settings: ReferenceKeyDefinition): void;
+    removeReferenceKey(key: number | string): void;
     /**
      *
      * @param id ID of this element, or undefined for the document itself

package/sdk/document/elementproxy.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElementProxy = void 0;
+const referencekeydefinition_1 = require("../data/referencekeydefinition");
+const referencekeyproxy_1 = require("../data/referencekeyproxy");
 const mapproxy_1 = require("./mapproxy");
 const shapedataproxy_1 = require("./shapedataproxy");
 /**
@@ -50,6 +52,17 @@ class ElementProxy {
             'id': this.id,
             'n': name,
         })));
+        this.referenceKeys = new mapproxy_1.MapProxy(() => this.client.sendCommand("lrk" /* ListReferenceKeys */, { 'id': this.id }), (key) => new referencekeyproxy_1.ReferenceKeyProxy(this.id, key, this.client, this.client.sendCommand("grk" /* GetReferenceKey */, { 'id': this.id, 'k': key })));
+    }
+    setReferenceKey(key, settings) {
+        this.client.sendCommand("srk" /* SetReferenceKey */, {
+            'id': this.id,
+            'k': key,
+            'v': (0, referencekeydefinition_1.serializeReferenceKeyDefinition)(settings),
+        });
+    }
+    removeReferenceKey(key) {
+        this.client.sendCommand("srk" /* SetReferenceKey */, { 'id': this.id, 'k': key });
     }
     /**
      * @returns true if this element still exists on the document, or false otherwise

package/sdk/document/pageproxy.js

@@ -55,9 +55,13 @@ class PageProxy extends elementproxy_1.ElementProxy {
         const id = this.client.sendCommand("cb" /* CreateBlock */, {
             'p': this.id,
             'c': def.className,
+            's': def.stencil,
         });
         const block = this.client.getBlockProxy(id);
         block.setBoundingBox(def.boundingBox);
+        for (const key in def.properties) {
+            block.properties.set(key, def.properties[key]);
+        }
         return block;
     }
     /**

package/sdk/document/shapedataproxy.d.ts

@@ -1,5 +1,5 @@
+import { SerializedFieldType } from '../core/data/serializedfield/serializedfields';
 import { SerializedDataError } from '../core/serializeddataerror';
-import { SerializedFieldType } from '../core/serializedfields';
 import { DataError } from '../data/dataerror';
 import { EditorClient } from '../editorclient';
 import { WriteableMapProxy } from './mapproxy';