lucid-extension-sdk 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "sdk/index.js",
     "types": "sdk/index.d.ts",
@@ -9,6 +9,7 @@
     "declaration": true,
     "devDependencies": {
         "@bazel/typescript": "2.0.1",
+        "@types/jasmine": "^3.10.3",
         "@types/node": "^16.11.11",
         "typedoc": "^0.22.11",
         "typescript": "4.3.5"

package/sdk/commandtypes.d.ts

@@ -1,7 +1,9 @@
-import { JsonSerializable } from './core/jsonserializable';
+import { SerializedFieldTypeDefinition } from './core/data/fieldtypedefinition/fieldtypedefinition';
+import { SerializedReferenceKeyType } from './core/data/referencekeys/serializedreferencekey';
+import { SerializedFieldType } from './core/data/serializedfield/serializedfields';
+import { JsonObject, JsonSerializable } from './core/jsonserializable';
 import { LinearOffsetType } from './core/offsettype';
 import { SerializedDataError } from './core/serializeddataerror';
-import { SerializedFieldType } from './core/serializedfields';
 import { ShapeDataInheritance } from './core/shapedatainheritance';
 import { Box, Point } from './math';
 import { MenuLocation, MenuType } from './ui/menu';
@@ -10,6 +12,8 @@ export declare const enum CommandName {
     AddShapeData = "asd",
     AnimateViewport = "av",
     CreateBlock = "cb",
+    CreateCollection = "cc",
+    CreateDataSource = "cds",
     CreateLine = "cl",
     CreatePage = "cp",
     DeleteItem = "di",
@@ -20,10 +24,12 @@ export declare const enum CommandName {
     ExecuteFormula = "ef",
     GetConnectedLines = "gcl",
     GetCurrentPage = "gcp",
+    GetCustomShape = "gcs",
     GetDataItemField = "gdif",
     GetElementType = "get",
     GetItemPageId = "gip",
     GetProperty = "gp",
+    GetReferenceKey = "grk",
     GetRelativeLinePosition = "grlp",
     GetSelection = "gs",
     GetShapeData = "gsd",
@@ -38,16 +44,19 @@ export declare const enum CommandName {
     ListLines = "ll",
     ListPages = "lp",
     ListProperties = "lpr",
+    ListReferenceKeys = "lrk",
     ListShapeData = "lsd",
     ListTextAreas = "lta",
     LoadBlockClasses = "lbc",
     LogForTestCase = "log",
     OffsetItems = "oi",
+    PatchDataItems = "pdi",
     ReloadExtension = "r",
     SendUIMessage = "suim",
     SendXHR = "xhr",
     SetCurrentPage = "scp",
     SetProperty = "sp",
+    SetReferenceKey = "srk",
     SetShapeData = "ssd",
     ShowModal = "sm"
 }
@@ -68,6 +77,14 @@ export declare type CommandArgs = {
         query: CreateBlockQuery;
         result: CreateBlockResult;
     };
+    [CommandName.CreateCollection]: {
+        query: CreateCollectionQuery;
+        result: CreateCollectionResult;
+    };
+    [CommandName.CreateDataSource]: {
+        query: CreateDataSourceQuery;
+        result: CreateDataSourceResult;
+    };
     [CommandName.CreateLine]: {
         query: CreateLineQuery;
         result: CreateLineResult;
@@ -108,6 +125,10 @@ export declare type CommandArgs = {
         query: GetCurrentPageQuery;
         result: GetCurrentPageResult;
     };
+    [CommandName.GetCustomShape]: {
+        query: GetCustomShapeQuery;
+        result: GetCustomShapeResult;
+    };
     [CommandName.GetDataItemField]: {
         query: GetDataItemFieldQuery;
         result: GetDataItemFieldResult;
@@ -124,6 +145,10 @@ export declare type CommandArgs = {
         query: GetPropertyQuery;
         result: GetPropertyResult;
     };
+    [CommandName.GetReferenceKey]: {
+        query: GetReferenceKeyQuery;
+        result: GetReferenceKeyResult;
+    };
     [CommandName.GetRelativeLinePosition]: {
         query: GetRelativeLinePositionQuery;
         result: GetRelativeLinePositionResult;
@@ -180,6 +205,10 @@ export declare type CommandArgs = {
         query: ListPropertiesQuery;
         result: ListPropertiesResult;
     };
+    [CommandName.ListReferenceKeys]: {
+        query: ListReferenceKeysQuery;
+        result: ListReferenceKeysResult;
+    };
     [CommandName.ListShapeData]: {
         query: ListShapeDataQuery;
         result: ListShapeDataResult;
@@ -200,6 +229,10 @@ export declare type CommandArgs = {
         query: OffsetItemsQuery;
         result: OffsetItemsResult;
     };
+    [CommandName.PatchDataItems]: {
+        query: PatchDataItemsQuery;
+        result: PatchDataItemsResult;
+    };
     [CommandName.ReloadExtension]: {
         query: ReloadExtensionQuery;
         result: ReloadExtensionResult;
@@ -220,6 +253,10 @@ export declare type CommandArgs = {
         query: SetPropertyQuery;
         result: SetPropertyResult;
     };
+    [CommandName.SetReferenceKey]: {
+        query: SetReferenceKeyQuery;
+        result: SetReferenceKeyResult;
+    };
     [CommandName.SetShapeData]: {
         query: SetShapeDataQuery;
         result: SetShapeDataResult;
@@ -249,8 +286,27 @@ export declare type AddShapeDataResult = undefined;
 export declare type CreateBlockQuery = {
     'p'?: string;
     'c': string;
+    's'?: JsonSerializable | undefined;
 };
 export declare type CreateBlockResult = string;
+export declare type CreateCollectionFieldDefinition = {
+    'n': string;
+    't': SerializedFieldTypeDefinition;
+};
+export declare type CreateCollectionQuery = {
+    's': string;
+    'n': string;
+    'f': CreateCollectionFieldDefinition[];
+    'p': string[];
+};
+export declare type CreateCollectionResult = string;
+export declare type CreateDataSourceQuery = {
+    'n': string;
+    's': {
+        [key: string]: JsonSerializable;
+    };
+};
+export declare type CreateDataSourceResult = string;
 export declare type CreateLineQuery = {
     'p'?: string;
 };
@@ -295,6 +351,15 @@ export declare type GetConnectedLinesQuery = string;
 export declare type GetConnectedLinesResult = string[];
 export declare type GetCurrentPageQuery = void;
 export declare type GetCurrentPageResult = string | undefined;
+export declare type GetCustomShapeQuery = {
+    'l': string;
+    's': string;
+};
+export declare type GetCustomShapeResult = Promise<{
+    's': JsonSerializable;
+    'bb': Box;
+    'p': JsonObject;
+} | undefined>;
 export declare type GetDataItemFieldQuery = {
     'c': string;
     'pk': string;
@@ -303,6 +368,11 @@ export declare type GetDataItemFieldQuery = {
 export declare type GetDataItemFieldResult = SerializedFieldType;
 export declare type GetItemPageIdQuery = string;
 export declare type GetItemPageIdResult = string;
+export declare type GetReferenceKeyQuery = {
+    'id'?: string;
+    'k': number | string;
+};
+export declare type GetReferenceKeyResult = SerializedReferenceKeyType;
 export declare type GetPropertyQuery = {
     'id'?: string | undefined;
     'p': string;
@@ -349,6 +419,10 @@ export declare type ListDataSourcesQuery = undefined;
 export declare type ListDataSourcesResult = string[];
 export declare type ListPagesQuery = void;
 export declare type ListPagesResult = string[];
+export declare type ListReferenceKeysQuery = {
+    'id'?: string | undefined;
+};
+export declare type ListReferenceKeysResult = (string | number)[];
 export declare type ListPropertiesQuery = {
     'id'?: string | undefined;
 };
@@ -368,6 +442,13 @@ export declare type OffsetItemsQuery = {
     'o': Point;
 };
 export declare type OffsetItemsResult = undefined;
+export declare type PatchDataItemsQuery = {
+    'id': string;
+    'a': Record<string, SerializedFieldType>[];
+    'c': Record<string, Record<string, SerializedFieldType>>;
+    'd': string[];
+};
+export declare type PatchDataItemsResult = undefined;
 export declare type ReloadExtensionQuery = void;
 export declare type ReloadExtensionResult = undefined;
 export declare type SendUIMessageQuery = {
@@ -410,6 +491,12 @@ export declare type SetPropertyQuery = {
     'v'?: JsonSerializable;
 };
 export declare type SetPropertyResult = undefined;
+export declare type SetReferenceKeyQuery = {
+    'id'?: string | undefined;
+    'k': string | number;
+    'v'?: SerializedReferenceKeyType;
+};
+export declare type SetReferenceKeyResult = undefined;
 export declare type SetShapeDataQuery = {
     'id'?: string | undefined;
     'n': string;

package/sdk/core/checks.d.ts

@@ -62,6 +62,14 @@ export declare function isFunction(val: unknown): val is (...unknownArgs: any[])
  * @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 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 isRecord<T>(typeGuard: (a: unknown) => a is T): (val: unknown) => val is Record<string, T>;
 /**
  * Returns true if the specified value is an array.
  *

package/sdk/core/checks.js

@@ -1,6 +1,6 @@
 "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;
+exports.isPromise = exports.isUnknown = exports.isAny = exports.isEmptyOrNullishObject = exports.isTypedArray = exports.isArray = exports.isRecord = 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.
  *
@@ -99,6 +99,19 @@ function isObject(val) {
     return (type == 'object' && val != null) || type == 'function';
 }
 exports.isObject = isObject;
+/**
+ * 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 isRecord(typeGuard) {
+    return function (val) {
+        return isObject(val) && Object.values(val).every(typeGuard);
+    };
+}
+exports.isRecord = isRecord;
 /**
  * Returns true if the specified value is an array.
  *

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

@@ -0,0 +1,13 @@
+import { CollectionEnumFieldType, SerializedCollectionEnumFieldType } from './collectionenumfieldtype';
+import { FieldTypeArray, SerializedFieldTypeArray } from './fieldtypearray';
+import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
+import { NDimensionalFieldTypeArray, SerializedNDimensionalFieldTypeArray } from './ndimensionalfieldtypearray';
+import { ScalarFieldTypeEnum } from './scalarfieldtype';
+export declare type AnyFieldTypeArrayDefinition = FieldTypeArray | NDimensionalFieldTypeArray;
+export declare function isAnyFieldTypeArray(fieldType: BaseFieldTypeDefinition): fieldType is AnyFieldTypeArrayDefinition;
+export declare type BaseFieldTypeDefinition = ScalarFieldTypeEnum | LiteralFieldType | AnyFieldTypeArrayDefinition | CollectionEnumFieldType;
+export declare type SerializedBaseFieldTypeDefinition = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedNDimensionalFieldTypeArray | SerializedCollectionEnumFieldType;
+export declare function isBaseFieldTypeDefinition(fieldType: any): fieldType is BaseFieldTypeDefinition;
+export declare function serializeBaseFieldTypeDefinition(baseFieldType: BaseFieldTypeDefinition): SerializedBaseFieldTypeDefinition;
+export declare function deserializeBaseFieldTypeDefinition(baseFieldType: SerializedBaseFieldTypeDefinition): BaseFieldTypeDefinition;
+export declare function isSerializedBaseFieldTypeDefinition(definition: any): definition is SerializedBaseFieldTypeDefinition;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedBaseFieldTypeDefinition = exports.deserializeBaseFieldTypeDefinition = exports.serializeBaseFieldTypeDefinition = exports.isBaseFieldTypeDefinition = exports.isAnyFieldTypeArray = void 0;
+const checks_1 = require("../../checks");
+const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
+const fieldtypearray_1 = require("./fieldtypearray");
+const literalfieldtype_1 = require("./literalfieldtype");
+const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
+const scalarfieldtype_1 = require("./scalarfieldtype");
+function isAnyFieldTypeArray(fieldType) {
+    return fieldType instanceof fieldtypearray_1.FieldTypeArray || fieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray;
+}
+exports.isAnyFieldTypeArray = isAnyFieldTypeArray;
+function isBaseFieldTypeDefinition(fieldType) {
+    return ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) ||
+        (0, literalfieldtype_1.isLiteralFieldType)(fieldType) ||
+        isAnyFieldTypeArray(fieldType) ||
+        (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType));
+}
+exports.isBaseFieldTypeDefinition = isBaseFieldTypeDefinition;
+function serializeBaseFieldTypeDefinition(baseFieldType) {
+    // Unfortunately there's no easy way to do goog.DEBUG checks inside lucid-extension-sdk right now.
+    // if (goog.DEBUG && !isBaseFieldTypeDefinition(baseFieldType)) {
+    //     throw new Error(`Passed non-BaseFieldTypeDefinition into serializeBaseFieldTypeDefinition()!`);
+    // }
+    if (baseFieldType instanceof literalfieldtype_1.LiteralFieldType ||
+        baseFieldType instanceof fieldtypearray_1.FieldTypeArray ||
+        baseFieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray ||
+        baseFieldType instanceof collectionenumfieldtype_1.CollectionEnumFieldType) {
+        return baseFieldType.serialize();
+    }
+    return baseFieldType;
+}
+exports.serializeBaseFieldTypeDefinition = serializeBaseFieldTypeDefinition;
+function deserializeBaseFieldTypeDefinition(baseFieldType) {
+    if ((0, literalfieldtype_1.isSerializedLiteralFieldType)(baseFieldType)) {
+        return (0, literalfieldtype_1.deserializeLiteralFieldType)(baseFieldType);
+    }
+    if ((0, collectionenumfieldtype_1.isSerializedCollectionEnumFieldType)(baseFieldType)) {
+        return (0, collectionenumfieldtype_1.deserializeCollectionEnumFieldType)(baseFieldType);
+    }
+    if ((0, fieldtypearray_1.isSerializedFieldTypeArray)(baseFieldType, isSerializedBaseFieldTypeDefinition)) {
+        return (0, fieldtypearray_1.deserializeFieldTypeArray)(baseFieldType);
+    }
+    if ((0, ndimensionalfieldtypearray_1.isSerializedNDimensionalFieldTypeArray)(baseFieldType)) {
+        return (0, ndimensionalfieldtypearray_1.deserializeNDimensionalFieldTypeArray)(baseFieldType);
+    }
+    return baseFieldType;
+}
+exports.deserializeBaseFieldTypeDefinition = deserializeBaseFieldTypeDefinition;
+function isSerializedBaseFieldTypeDefinition(definition) {
+    return ((0, checks_1.isDefAndNotNull)(scalarfieldtype_1.ScalarFieldTypeEnum[definition]) ||
+        (0, literalfieldtype_1.isSerializedLiteralFieldType)(definition) ||
+        (0, collectionenumfieldtype_1.isSerializedCollectionEnumFieldType)(definition) ||
+        (0, fieldtypearray_1.isSerializedFieldTypeArray)(definition, isSerializedBaseFieldTypeDefinition) ||
+        (0, ndimensionalfieldtypearray_1.isSerializedNDimensionalFieldTypeArray)(definition));
+}
+exports.isSerializedBaseFieldTypeDefinition = isSerializedBaseFieldTypeDefinition;

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

@@ -0,0 +1,30 @@
+export declare const CollectionEnumFieldTypeKey = "COLLECTION_ENUM";
+/**
+ * Contains the field names of all valid fields for a groovy metadata collection.
+ *
+ * This should be kept in sync with GroovyFieldNames in FieldType.scala
+ */
+export declare enum CollectionEnumFieldNames {
+    Name = "name",
+    Id = "id",
+    Description = "description",
+    Color = "color",
+    IconUrl = "iconUrl"
+}
+export declare class CollectionEnumFieldType {
+    readonly collectionId: string;
+    /**
+     * Specifies which groovy field name is used as the primary key.
+     *
+     * This should be kept in sync with GroovyFieldNames in FieldType.scala
+     */
+    static readonly PRIMARY_KEY = CollectionEnumFieldNames.Id;
+    constructor(collectionId: string);
+    serialize(): SerializedCollectionEnumFieldType;
+}
+export declare const isCollectionEnumFieldType: (fieldType: any) => fieldType is CollectionEnumFieldType;
+export declare type SerializedCollectionEnumFieldType = {
+    [CollectionEnumFieldTypeKey]: string;
+};
+export declare function deserializeCollectionEnumFieldType(serializedCollectionEnumFieldType: SerializedCollectionEnumFieldType): CollectionEnumFieldType;
+export declare function isSerializedCollectionEnumFieldType(fieldType: any): fieldType is SerializedCollectionEnumFieldType;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedCollectionEnumFieldType = exports.deserializeCollectionEnumFieldType = exports.isCollectionEnumFieldType = exports.CollectionEnumFieldType = exports.CollectionEnumFieldNames = exports.CollectionEnumFieldTypeKey = void 0;
+const checks_1 = require("../../checks");
+exports.CollectionEnumFieldTypeKey = 'COLLECTION_ENUM';
+/**
+ * Contains the field names of all valid fields for a groovy metadata collection.
+ *
+ * This should be kept in sync with GroovyFieldNames in FieldType.scala
+ */
+var CollectionEnumFieldNames;
+(function (CollectionEnumFieldNames) {
+    CollectionEnumFieldNames["Name"] = "name";
+    CollectionEnumFieldNames["Id"] = "id";
+    CollectionEnumFieldNames["Description"] = "description";
+    CollectionEnumFieldNames["Color"] = "color";
+    CollectionEnumFieldNames["IconUrl"] = "iconUrl";
+})(CollectionEnumFieldNames = exports.CollectionEnumFieldNames || (exports.CollectionEnumFieldNames = {}));
+class CollectionEnumFieldType {
+    constructor(collectionId) {
+        this.collectionId = collectionId;
+    }
+    serialize() {
+        return { [exports.CollectionEnumFieldTypeKey]: this.collectionId };
+    }
+}
+exports.CollectionEnumFieldType = CollectionEnumFieldType;
+/**
+ * Specifies which groovy field name is used as the primary key.
+ *
+ * This should be kept in sync with GroovyFieldNames in FieldType.scala
+ */
+CollectionEnumFieldType.PRIMARY_KEY = CollectionEnumFieldNames.Id;
+const isCollectionEnumFieldType = (fieldType) => {
+    return fieldType instanceof CollectionEnumFieldType;
+};
+exports.isCollectionEnumFieldType = isCollectionEnumFieldType;
+function deserializeCollectionEnumFieldType(serializedCollectionEnumFieldType) {
+    return new CollectionEnumFieldType(serializedCollectionEnumFieldType[exports.CollectionEnumFieldTypeKey]);
+}
+exports.deserializeCollectionEnumFieldType = deserializeCollectionEnumFieldType;
+function isSerializedCollectionEnumFieldType(fieldType) {
+    return (0, checks_1.isObject)(fieldType) && (0, checks_1.isString)(fieldType[exports.CollectionEnumFieldTypeKey]);
+}
+exports.isSerializedCollectionEnumFieldType = isSerializedCollectionEnumFieldType;

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

@@ -0,0 +1,16 @@
+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)[];
+    serialize(): SerializedFieldTypeArray;
+}
+export declare function isValidTypeForFieldTypeArray(fieldType: any): fieldType is ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray;
+export declare type SerializedFieldTypeArray = {
+    'ND': false;
+    'validTypes': (ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray)[];
+};
+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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeFieldTypeArray = exports.isSerializedFieldTypeArray = exports.isValidTypeForFieldTypeArray = exports.FieldTypeArray = void 0;
+const checks_1 = require("../../checks");
+const literalfieldtype_1 = require("./literalfieldtype");
+const scalarfieldtype_1 = require("./scalarfieldtype");
+class FieldTypeArray {
+    constructor(validTypesArray) {
+        this.validTypesArray = validTypesArray;
+    }
+    getInnerTypes() {
+        return this.validTypesArray;
+    }
+    getInnerNonArrayTypes() {
+        return this.validTypesArray.filter((innerType) => (0, scalarfieldtype_1.isScalarFieldTypeEnum)(innerType) || (0, literalfieldtype_1.isLiteralFieldType)(innerType));
+    }
+    serialize() {
+        return {
+            'ND': false,
+            'validTypes': this.validTypesArray.map((t) => ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(t) ? t : t.serialize())),
+        };
+    }
+}
+exports.FieldTypeArray = FieldTypeArray;
+function isValidTypeForFieldTypeArray(fieldType) {
+    return (0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) || (0, literalfieldtype_1.isLiteralFieldType)(fieldType) || fieldType instanceof FieldTypeArray;
+}
+exports.isValidTypeForFieldTypeArray = isValidTypeForFieldTypeArray;
+function isSerializedFieldTypeArray(fieldType, validateTypeCheck) {
+    return ((0, checks_1.isObject)(fieldType) &&
+        (0, checks_1.isBoolean)(fieldType['ND']) &&
+        fieldType['ND'] === false &&
+        (0, checks_1.isArray)(fieldType['validTypes']) &&
+        fieldType['validTypes'].every((validType) => {
+            return validateTypeCheck(validType);
+        }));
+}
+exports.isSerializedFieldTypeArray = isSerializedFieldTypeArray;
+function deserializeFieldTypeArray(serializedFieldTypeArray) {
+    return new FieldTypeArray(serializedFieldTypeArray['validTypes'].map((t) => {
+        if ((0, literalfieldtype_1.isSerializedLiteralFieldType)(t)) {
+            return (0, literalfieldtype_1.deserializeLiteralFieldType)(t);
+        }
+        else if ((0, checks_1.isObject)(t)) {
+            return deserializeFieldTypeArray(t);
+        }
+        return t;
+    }));
+}
+exports.deserializeFieldTypeArray = deserializeFieldTypeArray;

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

@@ -0,0 +1,13 @@
+import { BaseFieldTypeDefinition, SerializedBaseFieldTypeDefinition } from './basefieldtypedefinition';
+import { NDimensionalFieldTypeArray } from './ndimensionalfieldtypearray';
+import { ScalarFieldTypeEnum } from './scalarfieldtype';
+export declare type FieldTypeDefinition = BaseFieldTypeDefinition | BaseFieldTypeDefinition[];
+export declare function fieldTypesEqual(a: FieldTypeDefinition, b: FieldTypeDefinition, checkEnumCollectionId?: boolean): boolean;
+export declare function isSubtypeOfFieldType(subType: FieldTypeDefinition, superTypes: FieldTypeDefinition): boolean;
+export declare const AnyFieldType: (ScalarFieldTypeEnum | NDimensionalFieldTypeArray)[];
+export declare function isAnyFieldType(type: FieldTypeDefinition): boolean;
+export declare const serializeFieldTypeDefinition: (fieldType: FieldTypeDefinition) => SerializedFieldTypeDefinition;
+export declare const deserializeFieldTypeDefinition: (serializedFieldType: SerializedFieldTypeDefinition) => FieldTypeDefinition;
+export declare const SerializedAnyFieldType: SerializedFieldTypeDefinition;
+export declare type SerializedFieldTypeDefinition = SerializedBaseFieldTypeDefinition | SerializedBaseFieldTypeDefinition[];
+export declare function isSerializedFieldTypeDefinition(definition: any): definition is SerializedFieldTypeDefinition;

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedFieldTypeDefinition = exports.SerializedAnyFieldType = exports.deserializeFieldTypeDefinition = exports.serializeFieldTypeDefinition = exports.isAnyFieldType = exports.AnyFieldType = exports.isSubtypeOfFieldType = exports.fieldTypesEqual = void 0;
+const checks_1 = require("../../checks");
+const basefieldtypedefinition_1 = require("./basefieldtypedefinition");
+const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
+const fieldtypearray_1 = require("./fieldtypearray");
+const literalfieldtype_1 = require("./literalfieldtype");
+const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
+const scalarfieldtype_1 = require("./scalarfieldtype");
+function fieldTypesEqual(a, b, checkEnumCollectionId = true) {
+    if (a === b) {
+        return true;
+    }
+    if ((0, literalfieldtype_1.isLiteralFieldType)(a) && (0, literalfieldtype_1.isLiteralFieldType)(b)) {
+        return a.getLiteral() === b.getLiteral();
+    }
+    if ((0, collectionenumfieldtype_1.isCollectionEnumFieldType)(a) && (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(b)) {
+        return checkEnumCollectionId ? a.collectionId === b.collectionId : true;
+    }
+    a = (0, checks_1.isArray)(a) ? a : [a];
+    b = (0, checks_1.isArray)(b) ? b : [b];
+    const setA = new Set(a);
+    const setB = new Set(b);
+    if (setA.size !== setB.size) {
+        return false;
+    }
+    for (const bItem of setB) {
+        if (setA.has(bItem)) {
+            continue;
+        }
+        if ((0, literalfieldtype_1.isLiteralFieldType)(bItem)) {
+            const found = a.some((aItem) => (0, literalfieldtype_1.isLiteralFieldType)(aItem) && fieldTypesEqual(aItem, bItem));
+            if (!found) {
+                return false;
+            }
+        }
+        else if (bItem instanceof fieldtypearray_1.FieldTypeArray) {
+            const found = a.some((aItem) => aItem instanceof fieldtypearray_1.FieldTypeArray && fieldTypesEqual(aItem.validTypesArray, bItem.validTypesArray));
+            if (!found) {
+                return false;
+            }
+        }
+        else if ((0, ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray)(bItem)) {
+            const aItem = a.find(ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray);
+            if (!aItem || !fieldTypesEqual(aItem.validTypesArray, bItem.validTypesArray)) {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+exports.fieldTypesEqual = fieldTypesEqual;
+function isSubtypeOfFieldType(subType, superTypes) {
+    if (!(0, checks_1.isArray)(superTypes)) {
+        superTypes = [superTypes];
+    }
+    if ((0, checks_1.isArray)(subType)) {
+        return subType.every((one) => isSubtypeOfFieldType(one, superTypes));
+    }
+    if (superTypes.includes(scalarfieldtype_1.ScalarFieldTypeEnum.ANY)) {
+        return true;
+    }
+    if ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(subType)) {
+        return superTypes.includes(subType);
+    }
+    if ((0, literalfieldtype_1.isLiteralFieldType)(subType)) {
+        if (superTypes.includes(subType.getScalarFieldType())) {
+            return true;
+        }
+        const superLiteralTypes = superTypes.filter(literalfieldtype_1.isLiteralFieldType);
+        if (superLiteralTypes.find((superLiteralType) => subType.getLiteral() === superLiteralType.getLiteral())) {
+            return true;
+        }
+        const superArrayTypes = superTypes.filter(basefieldtypedefinition_1.isAnyFieldTypeArray);
+        for (const superArrayType of superArrayTypes) {
+            if (isSubtypeOfFieldType(subType, superArrayType.getInnerTypes())) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if ((0, collectionenumfieldtype_1.isCollectionEnumFieldType)(subType)) {
+        return superTypes.filter(collectionenumfieldtype_1.isCollectionEnumFieldType).some((ce) => ce.collectionId === subType.collectionId);
+    }
+    if ((0, ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray)(subType)) {
+        const superNArrayTypes = superTypes.filter(ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray);
+        return !!superNArrayTypes.find((superNArrayType) => isSubtypeOfFieldType(subType.validTypesArray, superNArrayType.validTypesArray));
+    }
+    const subTypeArrayInnerTypes = subType.getInnerTypes();
+    const superArrayTypes = superTypes.filter(basefieldtypedefinition_1.isAnyFieldTypeArray);
+    for (const superArrayType of superArrayTypes) {
+        if (isSubtypeOfFieldType(subTypeArrayInnerTypes, superArrayType.getInnerTypes())) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isSubtypeOfFieldType = isSubtypeOfFieldType;
+exports.AnyFieldType = [...scalarfieldtype_1.AnyScalarFieldType, new ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray(scalarfieldtype_1.AnyScalarFieldType)];
+function isAnyFieldType(type) {
+    let nArray;
+    if (type === scalarfieldtype_1.ScalarFieldTypeEnum.ANY ||
+        type === exports.AnyFieldType ||
+        ((0, checks_1.isArray)(type) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.STRING) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.BOOLEAN) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.COLOR) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DATE) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NULL) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DICTIONARY) &&
+            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.CURRENCY) &&
+            !type.some(literalfieldtype_1.isLiteralFieldType) &&
+            (nArray = type.find(ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray)) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.STRING) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.BOOLEAN) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.COLOR) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DATE) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DICTIONARY) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NULL) &&
+            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.CURRENCY) &&
+            !nArray.validTypesArray.some(literalfieldtype_1.isLiteralFieldType))) {
+        return true;
+    }
+    return false;
+}
+exports.isAnyFieldType = isAnyFieldType;
+const serializeFieldTypeDefinition = (fieldType) => {
+    if ((0, checks_1.isArray)(fieldType)) {
+        return fieldType.map(basefieldtypedefinition_1.serializeBaseFieldTypeDefinition);
+    }
+    else {
+        return (0, basefieldtypedefinition_1.serializeBaseFieldTypeDefinition)(fieldType);
+    }
+};
+exports.serializeFieldTypeDefinition = serializeFieldTypeDefinition;
+const deserializeFieldTypeDefinition = (serializedFieldType) => {
+    if ((0, checks_1.isArray)(serializedFieldType)) {
+        return serializedFieldType.map(basefieldtypedefinition_1.deserializeBaseFieldTypeDefinition);
+    }
+    return (0, basefieldtypedefinition_1.deserializeBaseFieldTypeDefinition)(serializedFieldType);
+};
+exports.deserializeFieldTypeDefinition = deserializeFieldTypeDefinition;
+exports.SerializedAnyFieldType = (0, exports.serializeFieldTypeDefinition)(exports.AnyFieldType);
+function isSerializedFieldTypeDefinition(definition) {
+    if ((0, checks_1.isArray)(definition)) {
+        return definition.every(basefieldtypedefinition_1.isSerializedBaseFieldTypeDefinition);
+    }
+    return (0, basefieldtypedefinition_1.isSerializedBaseFieldTypeDefinition)(definition);
+}
+exports.isSerializedFieldTypeDefinition = isSerializedFieldTypeDefinition;