lucid-extension-sdk 0.0.3 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.3",
+    "version": "0.0.6",
     "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';
@@ -9,7 +11,10 @@ export declare const enum CommandName {
     AddMenuItem = "ami",
     AddShapeData = "asd",
     AnimateViewport = "av",
+    Bootstrap = "b",
     CreateBlock = "cb",
+    CreateCollection = "cc",
+    CreateDataSource = "cds",
     CreateLine = "cl",
     CreatePage = "cp",
     DeleteItem = "di",
@@ -20,10 +25,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,18 +45,22 @@ 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"
+    ShowModal = "sm",
+    SleepForTestCase = "sleep"
 }
 export declare type CommandArgs = {
     [CommandName.AnimateViewport]: {
@@ -64,10 +75,22 @@ export declare type CommandArgs = {
         query: AddShapeDataQuery;
         result: AddShapeDataResult;
     };
+    [CommandName.Bootstrap]: {
+        query: BootstrapQuery;
+        result: BootstrapResult;
+    };
     [CommandName.CreateBlock]: {
         query: CreateBlockQuery;
         result: CreateBlockResult;
     };
+    [CommandName.CreateCollection]: {
+        query: CreateCollectionQuery;
+        result: CreateCollectionResult;
+    };
+    [CommandName.CreateDataSource]: {
+        query: CreateDataSourceQuery;
+        result: CreateDataSourceResult;
+    };
     [CommandName.CreateLine]: {
         query: CreateLineQuery;
         result: CreateLineResult;
@@ -108,6 +131,10 @@ export declare type CommandArgs = {
         query: GetCurrentPageQuery;
         result: GetCurrentPageResult;
     };
+    [CommandName.GetCustomShape]: {
+        query: GetCustomShapeQuery;
+        result: GetCustomShapeResult;
+    };
     [CommandName.GetDataItemField]: {
         query: GetDataItemFieldQuery;
         result: GetDataItemFieldResult;
@@ -124,6 +151,10 @@ export declare type CommandArgs = {
         query: GetPropertyQuery;
         result: GetPropertyResult;
     };
+    [CommandName.GetReferenceKey]: {
+        query: GetReferenceKeyQuery;
+        result: GetReferenceKeyResult;
+    };
     [CommandName.GetRelativeLinePosition]: {
         query: GetRelativeLinePositionQuery;
         result: GetRelativeLinePositionResult;
@@ -180,6 +211,10 @@ export declare type CommandArgs = {
         query: ListPropertiesQuery;
         result: ListPropertiesResult;
     };
+    [CommandName.ListReferenceKeys]: {
+        query: ListReferenceKeysQuery;
+        result: ListReferenceKeysResult;
+    };
     [CommandName.ListShapeData]: {
         query: ListShapeDataQuery;
         result: ListShapeDataResult;
@@ -200,6 +235,10 @@ export declare type CommandArgs = {
         query: OffsetItemsQuery;
         result: OffsetItemsResult;
     };
+    [CommandName.PatchDataItems]: {
+        query: PatchDataItemsQuery;
+        result: PatchDataItemsResult;
+    };
     [CommandName.ReloadExtension]: {
         query: ReloadExtensionQuery;
         result: ReloadExtensionResult;
@@ -220,6 +259,10 @@ export declare type CommandArgs = {
         query: SetPropertyQuery;
         result: SetPropertyResult;
     };
+    [CommandName.SetReferenceKey]: {
+        query: SetReferenceKeyQuery;
+        result: SetReferenceKeyResult;
+    };
     [CommandName.SetShapeData]: {
         query: SetShapeDataQuery;
         result: SetShapeDataResult;
@@ -228,6 +271,10 @@ export declare type CommandArgs = {
         query: ShowModalQuery;
         result: ShowModalResult;
     };
+    [CommandName.SleepForTestCase]: {
+        query: SleepForTestCaseQuery;
+        result: SleepForTestCaseResult;
+    };
 };
 export declare type UnionToIntersection<T> = (T extends any ? (x: T) => unknown : never) extends (x: infer R) => unknown ? R : never;
 export declare type AddMenuItemQuery = {
@@ -246,11 +293,38 @@ export declare type AddShapeDataQuery = {
     'v'?: SerializedFieldType;
 };
 export declare type AddShapeDataResult = undefined;
+export declare type BootstrapQuery = {
+    /**
+     * Named action that accepts the bootstrap data, and which may return a Promise or void. After awaiting\
+     * the result of the callback, the bootstrap data is cleared.
+     */
+    'c': string;
+};
+export declare type BootstrapResult = Promise<void>;
 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 +369,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 +386,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 +437,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 +460,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 +509,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;
@@ -424,3 +529,5 @@ export declare type ShowModalQuery = {
     'c': string;
 };
 export declare type ShowModalResult = undefined;
+export declare type SleepForTestCaseQuery = number;
+export declare type SleepForTestCaseResult = Promise<void>;

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;