lucid-extension-sdk 0.0.0

package/out/core/checks.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Returns true if the specified value is not undefined.
+ *
+ * @param val Variable to test.
+ * @return Whether variable is defined.
+ */
+export declare function isDef<F>(val: F | undefined): val is F;
+/**
+ * Returns true if the specified value is null.
+ * @param val Variable to test.
+ * @return Whether variable is null.
+ */
+export declare function isNull(val: unknown): val is null;
+/**
+ * Returns true if the specified value is undefined.
+ * @param val Variable to test.
+ * @return Whether variable is undefined.
+ */
+export declare function isUndefined(val: unknown): val is undefined;
+/**
+ * Returns true if the specified value is defined and not null.
+ * @param val Variable to test.
+ * @return Whether variable is defined and not null.
+ */
+export declare function isDefAndNotNull<F>(val: F | null | undefined): val is F;
+/**
+ * Returns true if the specified value is null or undefined.
+ * @param val Variable to test
+ * @return Whether the variable is null or undefined.
+ */
+export declare function isNullish(val: unknown): val is null | undefined;
+/**
+ * Returns true if the specified value is a string.
+ * @param val Variable to test.
+ * @return Whether variable is a string.
+ */
+export declare function isString(val: unknown): val is string;
+/**
+ * Returns true if the specified value is a boolean.
+ * @param val Variable to test.
+ * @return Whether variable is boolean.
+ */
+export declare function isBoolean(val: unknown): val is boolean;
+/**
+ * Returns true if the specified value is a number.
+ * @param val Variable to test.
+ * @return Whether variable is a number.
+ */
+export declare function isNumber(val: unknown): val is number;
+/**
+ * Returns true if the specified value is an integer.
+ * @param val Variable to test.
+ * @return Whether variable is an integer.
+ */
+export declare function isInt(val: unknown): val is number;
+export declare function isFunction(val: unknown): val is (...unknownArgs: any[]) => unknown;
+/**
+ * Returns true if the specified value is an object (i.e. it's safe to do property accesses on it).
+ *
+ * This is safer than using goog.isObject directly (this is its code inlined) because it doesn't introduce an `any`.
+ * @param val Variable to test.
+ * @return Whether variable is an object.
+ */
+export declare function isObject(val: unknown): val is Record<string, unknown>;
+/**
+ * Returns true if the specified value is an array.
+ *
+ * This is safer than using Array.isArray directly because it doesn't introduce an `any` type.
+ * @param val Variable to test.
+ * @return Whether variable is an array.
+ */
+export declare function isArray(val: unknown): val is unknown[];
+/**
+ * Returns true if the specified value is an array and every element passes the type guard function.
+ *
+ * @param val Variable to test.
+ * @param typeGuard the type guard function to test every element in the array.
+ * @return Whether variable is an array of the given type.
+ */
+export declare function isTypedArray<T>(typeGuard: (a: unknown) => a is T): (val: unknown) => val is T[];
+/**
+ * Returns true if the specified object is either empty or all existing keys map to a nullish value
+ *
+ * @param val Variable to test
+ * @return Whether variable is empty or maps exclusively to nullish values
+ */
+export declare function isEmptyOrNullishObject(val: unknown): val is {};
+/**
+ * @deprecated Prefer isUnknown
+ */
+export declare function isAny(val: unknown): val is any;
+export declare function isUnknown(val: unknown): val is unknown;
+export declare function isPromise(val: unknown): val is Promise<unknown>;

package/out/core/checks.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = exports.isUnknown = exports.isAny = exports.isEmptyOrNullishObject = exports.isTypedArray = exports.isArray = exports.isObject = exports.isFunction = exports.isInt = exports.isNumber = exports.isBoolean = exports.isString = exports.isNullish = exports.isDefAndNotNull = exports.isUndefined = exports.isNull = exports.isDef = void 0;
+/**
+ * Returns true if the specified value is not undefined.
+ *
+ * @param val Variable to test.
+ * @return Whether variable is defined.
+ */
+function isDef(val) {
+    return val !== undefined;
+}
+exports.isDef = isDef;
+/**
+ * Returns true if the specified value is null.
+ * @param val Variable to test.
+ * @return Whether variable is null.
+ */
+function isNull(val) {
+    return val === null;
+}
+exports.isNull = isNull;
+/**
+ * Returns true if the specified value is undefined.
+ * @param val Variable to test.
+ * @return Whether variable is undefined.
+ */
+function isUndefined(val) {
+    return val === undefined;
+}
+exports.isUndefined = isUndefined;
+/**
+ * Returns true if the specified value is defined and not null.
+ * @param val Variable to test.
+ * @return Whether variable is defined and not null.
+ */
+function isDefAndNotNull(val) {
+    return val != null;
+}
+exports.isDefAndNotNull = isDefAndNotNull;
+/**
+ * Returns true if the specified value is null or undefined.
+ * @param val Variable to test
+ * @return Whether the variable is null or undefined.
+ */
+function isNullish(val) {
+    return val == null;
+}
+exports.isNullish = isNullish;
+/**
+ * Returns true if the specified value is a string.
+ * @param val Variable to test.
+ * @return Whether variable is a string.
+ */
+function isString(val) {
+    return typeof val == 'string';
+}
+exports.isString = isString;
+/**
+ * Returns true if the specified value is a boolean.
+ * @param val Variable to test.
+ * @return Whether variable is boolean.
+ */
+function isBoolean(val) {
+    return typeof val == 'boolean';
+}
+exports.isBoolean = isBoolean;
+/**
+ * Returns true if the specified value is a number.
+ * @param val Variable to test.
+ * @return Whether variable is a number.
+ */
+function isNumber(val) {
+    return typeof val == 'number';
+}
+exports.isNumber = isNumber;
+/**
+ * Returns true if the specified value is an integer.
+ * @param val Variable to test.
+ * @return Whether variable is an integer.
+ */
+function isInt(val) {
+    return isNumber(val) && isFinite(val) && val % 1 == 0;
+}
+exports.isInt = isInt;
+function isFunction(val) {
+    return typeof val === 'function';
+}
+exports.isFunction = isFunction;
+/**
+ * Returns true if the specified value is an object (i.e. it's safe to do property accesses on it).
+ *
+ * This is safer than using goog.isObject directly (this is its code inlined) because it doesn't introduce an `any`.
+ * @param val Variable to test.
+ * @return Whether variable is an object.
+ */
+function isObject(val) {
+    const type = typeof val;
+    return (type == 'object' && val != null) || type == 'function';
+}
+exports.isObject = isObject;
+/**
+ * Returns true if the specified value is an array.
+ *
+ * This is safer than using Array.isArray directly because it doesn't introduce an `any` type.
+ * @param val Variable to test.
+ * @return Whether variable is an array.
+ */
+function isArray(val) {
+    return Array.isArray(val);
+}
+exports.isArray = isArray;
+/**
+ * Returns true if the specified value is an array and every element passes the type guard function.
+ *
+ * @param val Variable to test.
+ * @param typeGuard the type guard function to test every element in the array.
+ * @return Whether variable is an array of the given type.
+ */
+function isTypedArray(typeGuard) {
+    return function (val) {
+        return isArray(val) && val.every(typeGuard);
+    };
+}
+exports.isTypedArray = isTypedArray;
+/**
+ * Returns true if the specified object is either empty or all existing keys map to a nullish value
+ *
+ * @param val Variable to test
+ * @return Whether variable is empty or maps exclusively to nullish values
+ */
+function isEmptyOrNullishObject(val) {
+    return !(val &&
+        typeof val === 'object' &&
+        Object.keys(val).find((key) => isDefAndNotNull(val[key])));
+}
+exports.isEmptyOrNullishObject = isEmptyOrNullishObject;
+/**
+ * @deprecated Prefer isUnknown
+ */
+function isAny(val) {
+    return true;
+}
+exports.isAny = isAny;
+function isUnknown(val) {
+    return true;
+}
+exports.isUnknown = isUnknown;
+function isPromise(val) {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+}
+exports.isPromise = isPromise;

package/out/core/dataerrortype.d.ts

@@ -0,0 +1,8 @@
+export declare const enum DataErrorType {
+    Parse = 1,
+    Loop = 2,
+    ReferenceNotFound = 3,
+    Evaluation = 4,
+    InvalidFunction = 5,
+    InvalidParameter = 6
+}

package/out/core/dataerrortype.js

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

package/out/core/jsonserializable.d.ts

@@ -0,0 +1,8 @@
+export declare type JsonArray = Array<JsonSerializable>;
+export interface JsonObject {
+    [key: string]: JsonSerializable;
+}
+export interface JsonObjectConvertible {
+    toJsonObject(): JsonObject;
+}
+export declare type JsonSerializable = undefined | null | string | number | boolean | JsonArray | JsonObject;

package/out/core/jsonserializable.js

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

package/out/core/offsettype.d.ts

@@ -0,0 +1,16 @@
+export declare enum OffsetType {
+    NW = 0,
+    NE = 1,
+    SE = 2,
+    SW = 3,
+    MOVE = 4,
+    ROTATE = 5,
+    SCALE = 6,
+    CUSTOM = 7,
+    N = 8,
+    E = 9,
+    S = 10,
+    W = 11
+}
+export declare type LinearOffsetType = OffsetType.NW | OffsetType.NE | OffsetType.SE | OffsetType.SW | OffsetType.MOVE | OffsetType.N | OffsetType.E | OffsetType.S | OffsetType.W;
+export declare function isLinearOffsetType(offsetType: unknown): offsetType is LinearOffsetType;

package/out/core/offsettype.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLinearOffsetType = exports.OffsetType = void 0;
+var OffsetType;
+(function (OffsetType) {
+    OffsetType[OffsetType["NW"] = 0] = "NW";
+    OffsetType[OffsetType["NE"] = 1] = "NE";
+    OffsetType[OffsetType["SE"] = 2] = "SE";
+    OffsetType[OffsetType["SW"] = 3] = "SW";
+    OffsetType[OffsetType["MOVE"] = 4] = "MOVE";
+    OffsetType[OffsetType["ROTATE"] = 5] = "ROTATE";
+    OffsetType[OffsetType["SCALE"] = 6] = "SCALE";
+    OffsetType[OffsetType["CUSTOM"] = 7] = "CUSTOM";
+    OffsetType[OffsetType["N"] = 8] = "N";
+    OffsetType[OffsetType["E"] = 9] = "E";
+    OffsetType[OffsetType["S"] = 10] = "S";
+    OffsetType[OffsetType["W"] = 11] = "W";
+})(OffsetType = exports.OffsetType || (exports.OffsetType = {}));
+function isLinearOffsetType(offsetType) {
+    return (offsetType === OffsetType.NW ||
+        offsetType === OffsetType.NE ||
+        offsetType === OffsetType.SE ||
+        offsetType === OffsetType.SW ||
+        offsetType === OffsetType.MOVE ||
+        offsetType === OffsetType.N ||
+        offsetType === OffsetType.E ||
+        offsetType === OffsetType.S ||
+        offsetType === OffsetType.W);
+}
+exports.isLinearOffsetType = isLinearOffsetType;

package/out/core/serializeddataerror.d.ts

@@ -0,0 +1,6 @@
+import { DataErrorType } from './dataerrortype';
+export declare type SerializedDataError = {
+    'type': DataErrorType;
+    'error': string;
+};
+export declare function isSerializedDataError(raw: unknown): raw is SerializedDataError;

package/out/core/serializeddataerror.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedDataError = void 0;
+const checks_1 = require("./checks");
+function isSerializedDataError(raw) {
+    return (0, checks_1.isObject)(raw) && (0, checks_1.isString)(raw['error']) && (0, checks_1.isNumber)(raw['type']);
+}
+exports.isSerializedDataError = isSerializedDataError;

package/out/core/serializedfields.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Once we have full server support for complex field types,
+ * we should be able to support object/array data here
+ */
+export declare type SerializedFieldType = number | boolean | string | null | SerializedLucidDateObject | SerializedColorObjectFieldType | SerializedLucidDictionary | SerializedLucidCurrency | undefined | Array<SerializedFieldType>;
+export declare type SerializedLucidDictionary = {
+    'dict': {
+        [index: string]: SerializedFieldType;
+    };
+};
+export declare type SerializedLucidCurrency = {
+    'a': number;
+    't': string;
+};
+export declare type SerializedFields = {
+    [fieldName: string]: SerializedFieldType;
+};
+export declare type SerializedLucidDateObject = {
+    'ms': number;
+    'isDateOnly'?: boolean;
+};
+export declare type SerializedRGBColor = {
+    'r': number;
+    'g': number;
+    'b': number;
+    'a'?: number;
+    't'?: number;
+    'c'?: undefined;
+    'm'?: undefined;
+    'y'?: undefined;
+    'k'?: undefined;
+};
+export declare type SerializedCMYKColor = {
+    'c': number;
+    'm': number;
+    'y': number;
+    'k': number;
+    'a'?: number;
+    't'?: number;
+    'r'?: undefined;
+    'g'?: undefined;
+    'b'?: undefined;
+};
+export declare type SerializedCorrectedColor = {
+    'cR': number;
+    'cG': number;
+    'cB': number;
+};
+export declare type SerializedColorObject = SerializedRGBColor | SerializedCMYKColor | (SerializedCMYKColor & SerializedCorrectedColor);
+export declare type SerializedColorObjectFieldType = {
+    'color': SerializedColorObject;
+};
+export declare function isSerializedColorObjectFieldType(value: any): value is SerializedColorObjectFieldType;
+export declare function isSerializedLucidDictionary(value: any): value is SerializedLucidDictionary;
+export declare function isSerializedLucidCurrency(value: any): value is SerializedLucidCurrency;
+export declare function isSerializedLucidDateObject(value: any): value is SerializedLucidDateObject;
+export declare function isSerializedFieldType(value: any): value is SerializedFieldType;
+export declare function isSerializedFields(value: unknown): value is SerializedFields;

package/out/core/serializedfields.js

@@ -0,0 +1,37 @@
+"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");
+function isSerializedColorObjectFieldType(value) {
+    return (0, checks_1.isObject)(value) && (0, checks_1.isObject)(value['color']);
+}
+exports.isSerializedColorObjectFieldType = isSerializedColorObjectFieldType;
+function isSerializedLucidDictionary(value) {
+    return (0, checks_1.isObject)(value) && Object.values(value).every(isSerializedFieldType);
+}
+exports.isSerializedLucidDictionary = isSerializedLucidDictionary;
+function isSerializedLucidCurrency(value) {
+    return (0, checks_1.isObject)(value) && (0, checks_1.isNumber)(value['a']) && (0, checks_1.isString)(value['t']);
+}
+exports.isSerializedLucidCurrency = isSerializedLucidCurrency;
+function isSerializedLucidDateObject(value) {
+    var _a;
+    return (0, checks_1.isObject)(value) && (0, checks_1.isNumber)(value['ms']) && (0, checks_1.isBoolean)((_a = value['isDateOnly']) !== null && _a !== void 0 ? _a : true);
+}
+exports.isSerializedLucidDateObject = isSerializedLucidDateObject;
+function isSerializedFieldType(value) {
+    return (value == null ||
+        (0, checks_1.isNumber)(value) ||
+        (0, checks_1.isString)(value) ||
+        (0, checks_1.isBoolean)(value) ||
+        isSerializedLucidDictionary(value) ||
+        isSerializedLucidCurrency(value) ||
+        ((0, checks_1.isArray)(value) && value.every(isSerializedFieldType)) ||
+        isSerializedLucidDateObject(value) ||
+        isSerializedColorObjectFieldType(value));
+}
+exports.isSerializedFieldType = isSerializedFieldType;
+function isSerializedFields(value) {
+    return (0, checks_1.isObject)(value) && Object.values(value).every(isSerializedFieldType);
+}
+exports.isSerializedFields = isSerializedFields;

package/out/core/shapedatainheritance.d.ts

@@ -0,0 +1,16 @@
+export declare enum ShapeDataInheritance {
+    NONE = 0,
+    /**
+     * Really just a UI level of inheritance, where the shape data panel should show the ability for
+     * you to enter a value under this name, and the name isn't editable. Because the default value
+     * for missing data is already empty, there's no need to actually do much down here in the model
+     * layer.
+     */
+    NAME = 1,
+    /**
+     * This is true inheritance, where the formula/value of the shape data is available on all
+     * descendant elements. i.e. if a page has a VALUE-inheritable shape data entry, that appears on
+     * every single Element on the page, including all groups and items inside those groups.
+     */
+    VALUE = 2
+}

package/out/core/shapedatainheritance.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeDataInheritance = void 0;
+var ShapeDataInheritance;
+(function (ShapeDataInheritance) {
+    ShapeDataInheritance[ShapeDataInheritance["NONE"] = 0] = "NONE";
+    /**
+     * Really just a UI level of inheritance, where the shape data panel should show the ability for
+     * you to enter a value under this name, and the name isn't editable. Because the default value
+     * for missing data is already empty, there's no need to actually do much down here in the model
+     * layer.
+     */
+    ShapeDataInheritance[ShapeDataInheritance["NAME"] = 1] = "NAME";
+    /**
+     * This is true inheritance, where the formula/value of the shape data is available on all
+     * descendant elements. i.e. if a page has a VALUE-inheritable shape data entry, that appears on
+     * every single Element on the page, including all groups and items inside those groups.
+     */
+    ShapeDataInheritance[ShapeDataInheritance["VALUE"] = 2] = "VALUE";
+})(ShapeDataInheritance = exports.ShapeDataInheritance || (exports.ShapeDataInheritance = {}));

package/out/data/collectionproxy.d.ts

@@ -0,0 +1,12 @@
+import { ElementProxy } from '../document/elementproxy';
+import { MapProxy } from '../document/mapproxy';
+import { EditorClient } from '../editorclient';
+import { DataItemProxy } from './dataitemproxy';
+export declare class CollectionProxy extends ElementProxy {
+    readonly id: string;
+    constructor(id: string, client: EditorClient);
+    getName(): string;
+    getBranchedFrom(): CollectionProxy | undefined;
+    readonly items: MapProxy<string, DataItemProxy>;
+    getFields(): import("../commandtypes").ListCollectionFieldsResult;
+}

package/out/data/collectionproxy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionProxy = void 0;
+const elementproxy_1 = require("../document/elementproxy");
+const mapproxy_1 = require("../document/mapproxy");
+const dataitemproxy_1 = require("./dataitemproxy");
+class CollectionProxy extends elementproxy_1.ElementProxy {
+    constructor(id, client) {
+        super(id, client);
+        this.id = id;
+        this.items = new mapproxy_1.MapProxy(() => this.client.sendCommand("ldi" /* ListDataItems */, { 'id': this.id }), (primaryKey) => new dataitemproxy_1.DataItemProxy(primaryKey, this, this.client));
+    }
+    getName() {
+        return this.properties.get('Name');
+    }
+    getBranchedFrom() {
+        const id = this.properties.get('BranchedFrom');
+        return id ? new CollectionProxy(id, this.client) : undefined;
+    }
+    getFields() {
+        return this.client.sendCommand("lcf" /* ListCollectionFields */, { 'id': this.id });
+    }
+}
+exports.CollectionProxy = CollectionProxy;

package/out/data/dataerror.d.ts

@@ -0,0 +1,6 @@
+import { DataErrorType } from '../core/dataerrortype';
+export declare class DataError {
+    readonly error: string;
+    readonly type: DataErrorType;
+    constructor(error: string, type: DataErrorType);
+}

package/out/data/dataerror.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataError = void 0;
+class DataError {
+    constructor(error, type) {
+        this.error = error;
+        this.type = type;
+    }
+}
+exports.DataError = DataError;

package/out/data/dataitemproxy.d.ts

@@ -0,0 +1,10 @@
+import { MapProxy } from '../document/mapproxy';
+import { EditorClient } from '../editorclient';
+import { CollectionProxy } from './collectionproxy';
+export declare class DataItemProxy {
+    readonly primaryKey: string;
+    readonly collection: CollectionProxy;
+    private readonly client;
+    constructor(primaryKey: string, collection: CollectionProxy, client: EditorClient);
+    readonly fields: MapProxy<string, import("../core/serializedfields").SerializedFieldType>;
+}

package/out/data/dataitemproxy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataItemProxy = void 0;
+const mapproxy_1 = require("../document/mapproxy");
+class DataItemProxy {
+    constructor(primaryKey, collection, client) {
+        this.primaryKey = primaryKey;
+        this.collection = collection;
+        this.client = client;
+        this.fields = new mapproxy_1.MapProxy(() => this.client.sendCommand("lcf" /* ListCollectionFields */, { 'id': this.collection.id }), (name) => this.client.sendCommand("gdif" /* GetDataItemField */, {
+            'c': this.collection.id,
+            'pk': this.primaryKey,
+            'f': name,
+        }));
+    }
+}
+exports.DataItemProxy = DataItemProxy;

package/out/data/dataproxy.d.ts

@@ -0,0 +1,8 @@
+import { MapProxy } from '../document/mapproxy';
+import { EditorClient } from '../editorclient';
+import { DataSourceProxy } from './datasourceproxy';
+export declare class DataProxy {
+    private readonly client;
+    readonly dataSources: MapProxy<string, DataSourceProxy>;
+    constructor(client: EditorClient);
+}

package/out/data/dataproxy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataProxy = void 0;
+const mapproxy_1 = require("../document/mapproxy");
+const datasourceproxy_1 = require("./datasourceproxy");
+class DataProxy {
+    constructor(client) {
+        this.client = client;
+        this.dataSources = new mapproxy_1.MapProxy(() => this.client.sendCommand("lds" /* ListDataSources */, undefined), (dataSourceId) => new datasourceproxy_1.DataSourceProxy(dataSourceId, this.client));
+    }
+}
+exports.DataProxy = DataProxy;

package/out/data/datasourceproxy.d.ts

@@ -0,0 +1,10 @@
+import { ElementProxy } from '../document/elementproxy';
+import { MapProxy } from '../document/mapproxy';
+import { EditorClient } from '../editorclient';
+import { CollectionProxy } from './collectionproxy';
+export declare class DataSourceProxy extends ElementProxy {
+    readonly id: string;
+    constructor(id: string, client: EditorClient);
+    readonly collections: MapProxy<string, CollectionProxy>;
+    getName(): string;
+}

package/out/data/datasourceproxy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceProxy = void 0;
+const elementproxy_1 = require("../document/elementproxy");
+const mapproxy_1 = require("../document/mapproxy");
+const collectionproxy_1 = require("./collectionproxy");
+class DataSourceProxy extends elementproxy_1.ElementProxy {
+    constructor(id, client) {
+        super(id, client);
+        this.id = id;
+        this.collections = new mapproxy_1.MapProxy(() => this.client.sendCommand("lc" /* ListCollections */, { 'id': this.id }), (id) => new collectionproxy_1.CollectionProxy(id, this.client));
+    }
+    getName() {
+        return this.properties.get('Name');
+    }
+}
+exports.DataSourceProxy = DataSourceProxy;

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

@@ -0,0 +1,13 @@
+import { BlockProxy } from '../blockproxy';
+/**
+ * The base BlockProxy class provides no special functionality for any specific type of block.
+ *
+ * To provide direct type-safe support for specific block types, extend BlockProxy and add a
+ * classNameRegex, then include your new block proxy in the allProxyClasses list. Then, whenever
+ * we construct a proxy to represent a block on the document, we will check each available
+ * proxy class and use one of these if available.
+ */
+export declare type BlockProxyConstructor = typeof BlockProxy & {
+    classNameRegex: RegExp;
+};
+export declare function findProxyClass(className: string): BlockProxyConstructor | undefined;

package/out/document/blockclasses/blockproxyregistry.js

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

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

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