lucid-extension-sdk 0.0.317 → 0.0.320

package/commandtypes.d.ts

@@ -730,6 +730,10 @@ export type AddCardIntegrationQuery = {
         /** Field name -> callback name tuples for searching for legal field values in an enum */
         'fvsc'?: [string, string][] | undefined;
     };
+    /** If we can only search for user by their name (and not email) in the card integration. */
+    'subn'?: boolean | undefined;
+    /** Callback to search for a user in the card integration */
+    'usc'?: string | undefined;
     /** Show intro if user has not yet authorized this integration
      *  String, not function; this is the name of the client's registered action hook
      */

package/core/cardintegration/cardintegrationdefinitions.d.ts

@@ -30,6 +30,30 @@ export interface ExtensionCardFieldDefinition extends FieldDefinition {
      */
     search?: string | undefined;
 }
+export type ExtensionCardUserData = ExtensionCardFieldOption & {
+    email: string | undefined;
+};
+/** @ignore */
+export type SerializedExtensionCardUserData = SerializedCardFieldOption & {
+    'e'?: string | undefined;
+};
+/** @ignore */
+export declare function serializeCardUserData(userData: ExtensionCardUserData): SerializedExtensionCardUserData;
+/** @ignore */
+export declare function deserializeCardUserData(userData: SerializedExtensionCardUserData): ExtensionCardUserData;
+export declare const isSerializedCardUserData: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
+    e: (x: unknown) => x is string | undefined;
+    l: typeof isString;
+    v: typeof isSerializedFieldType;
+    i: (x: unknown) => x is string | undefined;
+}>;
+export declare const isSerializedCardUserDataArray: (p1: unknown) => p1 is import("../guards").DestructureGuardedTypeObj<{
+    e: (x: unknown) => x is string | undefined;
+    l: typeof isString;
+    v: typeof isSerializedFieldType;
+    i: (x: unknown) => x is string | undefined;
+}>[];
+export type ExtensionCardUserDataSearch = ((searchText: string, inputSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardUserData[]>) | undefined;
 /** @ignore */
 export type SerializedCardFieldOption = {
     'l': string;

package/core/cardintegration/cardintegrationdefinitions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.isSerializedExtensionCardFieldDefinition = exports.isSerializedFieldOptions = exports.isSerializedFieldOption = exports.deserializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = void 0;
+exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.isSerializedExtensionCardFieldDefinition = exports.isSerializedFieldOptions = exports.isSerializedFieldOption = exports.deserializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = exports.isSerializedCardUserDataArray = exports.isSerializedCardUserData = exports.deserializeCardUserData = exports.serializeCardUserData = void 0;
 const schemadefinition_1 = require("../../data/schemadefinition");
 const checks_1 = require("../checks");
 const fieldtypedefinition_1 = require("../data/fieldtypedefinition/fieldtypedefinition");
@@ -8,6 +8,23 @@ const serializedfielddefinition_1 = require("../data/serializedfield/serializedf
 const serializedfields_1 = require("../data/serializedfield/serializedfields");
 const validators_1 = require("../validators/validators");
 /** @ignore */
+function serializeCardUserData(userData) {
+    return Object.assign({ 'e': userData.email }, serializeCardFieldOption(userData));
+}
+exports.serializeCardUserData = serializeCardUserData;
+/** @ignore */
+function deserializeCardUserData(userData) {
+    return Object.assign({ email: userData['e'] }, deserializeFieldOption(userData));
+}
+exports.deserializeCardUserData = deserializeCardUserData;
+exports.isSerializedCardUserData = (0, validators_1.objectValidator)({
+    'e': (0, validators_1.option)(checks_1.isString),
+    'l': checks_1.isString,
+    'v': serializedfields_1.isSerializedFieldType,
+    'i': (0, validators_1.option)(checks_1.isString),
+});
+exports.isSerializedCardUserDataArray = (0, validators_1.arrayValidator)(exports.isSerializedCardUserData);
+/** @ignore */
 function serializeCardFieldOption(option) {
     return {
         'l': option.label,

package/core/cardintegration/lucidcardintegration.d.ts

@@ -76,6 +76,10 @@ export declare abstract class LucidCardIntegration {
          */
         lightIconUrl?: string;
     };
+    /** If we are only able to search by name and not email in the card integration (ex: for JDC) */
+    searchUserByName?: boolean;
+    /** This is used to search for users in the card integration. It returns an additional email field of the user if available.*/
+    userSearchCallback?: string;
     /**
      * @deprecated Use AuthorizationFlowHandlerRegistry.registerAuthorizationFlowHandler.
      * WARNING: Currently unused and does nothing.

package/core/cardintegration/lucidcardintegrationregistry.d.ts

@@ -1,12 +1,13 @@
 import { EditorClient } from '../../editorclient';
 import { SerializedFieldType } from '../data/serializedfield/serializedfields';
-import { ExtensionCardFieldOption } from './cardintegrationdefinitions';
+import { ExtensionCardFieldOption, ExtensionCardUserData } from './cardintegrationdefinitions';
 import { LucidCardIntegration } from './lucidcardintegration';
 export declare class LucidCardIntegrationRegistry {
     private static nextHookId;
     private static nextHookName;
     static registerFieldOptionsCallback(client: EditorClient, callback: (inputSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardFieldOption[]>): string;
     static registerFieldSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardFieldOption[]>): string;
+    static registerUserSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardUserData[]>): string;
     private static registerDependencyMapping;
     /**
      * Register a card integration.

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -26,6 +26,14 @@ class LucidCardIntegrationRegistry {
         });
         return name;
     }
+    static registerUserSearchCallback(client, callback) {
+        const name = LucidCardIntegrationRegistry.nextHookName();
+        client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText }) => {
+            const result = await callback(searchText, new Map(inputSoFar));
+            return result.map((userData) => (0, cardintegrationdefinitions_1.serializeCardUserData)(userData));
+        });
+        return name;
+    }
     static registerDependencyMapping(client, cardIntegration, serialized) {
         if (cardIntegration.showDependencyMapping) {
             serialized['sdm'] = true;
@@ -140,6 +148,8 @@ class LucidCardIntegrationRegistry {
                     ? [...cardIntegration.fieldConfiguration.fieldValueSearchCallbacks.entries()]
                     : undefined,
             },
+            'subn': cardIntegration.searchUserByName,
+            'usc': cardIntegration.userSearchCallback,
             'gdc': getDefaultConfigActionName,
             'i': showIntroActionName,
         };

package/core/data/datasource/serializeddatasourceproperties.d.ts

@@ -20,6 +20,7 @@ export declare const isSerializedDataSourceProperties: (subject: unknown) => sub
     SourceForeignKeys: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
         Id: typeof isString;
         SourceFields: (p1: unknown) => p1 is string[];
+        RelationshipType: (x: unknown) => x is string | undefined;
         OutwardLabel: typeof isString;
         InwardLabel: typeof isString;
     }>[] | null | undefined;

package/core/data/datasource/serializedimporteddatasource.d.ts

@@ -57,8 +57,10 @@ export declare const isSerializedImportedDataSource: (subject: unknown) => subje
             SourceConfig: typeof isObject;
         }> | null | undefined;
         SourceForeignKeys: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
+            /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
             Id: typeof isString;
             SourceFields: (p1: unknown) => p1 is string[];
+            RelationshipType: (x: unknown) => x is string | undefined;
             OutwardLabel: typeof isString;
             InwardLabel: typeof isString;
         }>[] | null | undefined;
@@ -95,8 +97,10 @@ export declare const isSerializedPreviewData: (subject: unknown) => subject is i
             SourceConfig: typeof isObject;
         }> | null | undefined;
         SourceForeignKeys: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
+            /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
             Id: typeof isString;
             SourceFields: (p1: unknown) => p1 is string[];
+            RelationshipType: (x: unknown) => x is string | undefined;
             OutwardLabel: typeof isString;
             InwardLabel: typeof isString;
         }>[] | null | undefined;

package/core/data/datasource/serializedsourceforeignkey.d.ts

@@ -2,6 +2,7 @@ import { isString } from '../../checks';
 export type SerializedSourceForeignKey = {
     'Id': string;
     'SourceFields': string[];
+    'RelationshipType'?: string | undefined;
     'Represents'?: string | null | undefined;
     'OutwardLabel': string;
     'InwardLabel': string;
@@ -14,6 +15,7 @@ export type SerializedSourceForeignKey = {
 export declare const isSerializedSourceForeignKey: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Id: typeof isString;
     SourceFields: (p1: unknown) => p1 is string[];
+    RelationshipType: (x: unknown) => x is string | undefined;
     OutwardLabel: typeof isString;
     InwardLabel: typeof isString;
 }>;

package/core/data/datasource/serializedsourceforeignkey.js

@@ -6,6 +6,7 @@ const validators_1 = require("../../validators/validators");
 exports.isSerializedSourceForeignKey = (0, validators_1.objectValidator)({
     'Id': checks_1.isString,
     'SourceFields': (0, validators_1.arrayValidator)(checks_1.isString),
+    'RelationshipType': (0, validators_1.option)(checks_1.isString),
     'OutwardLabel': checks_1.isString,
     'InwardLabel': checks_1.isString,
 });

package/core/data/datasource/sourceforeignkeys.d.ts

@@ -2,6 +2,7 @@ import { SerializedSourceForeignKey } from './serializedsourceforeignkey';
 export type SourceForeignKey = {
     'id': string;
     'sourceFields': string[];
+    'relationshipType'?: string | undefined;
     'represents'?: string | undefined;
     'outwardLabel': string;
     'inwardLabel': string;

package/core/data/datasource/sourceforeignkeys.js

@@ -5,6 +5,7 @@ function serializeSourceForeignKey(foreignKey) {
     return {
         'Id': foreignKey.id,
         'SourceFields': foreignKey.sourceFields,
+        'RelationshipType': foreignKey.relationshipType,
         'Represents': foreignKey.represents,
         'OutwardLabel': foreignKey.outwardLabel,
         'InwardLabel': foreignKey.inwardLabel,
@@ -16,6 +17,7 @@ function deserializeSourceForeignKey(foreignKey) {
     return {
         'id': foreignKey['Id'],
         'sourceFields': foreignKey['SourceFields'],
+        'relationshipType': foreignKey['RelationshipType'],
         'represents': foreignKey['Represents'] === null ? undefined : foreignKey['Represents'],
         'outwardLabel': foreignKey['OutwardLabel'],
         'inwardLabel': foreignKey['InwardLabel'],

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

@@ -1,11 +1,12 @@
 import { CollectionEnumFieldType, SerializedCollectionEnumFieldType } from './collectionenumfieldtype';
+import { DeserializedMapEnumFieldType, SerializedMapEnumFieldType } from './deserializedmapenumfieldtype';
 import { FieldTypeArray, SerializedFieldTypeArray } from './fieldtypearray';
 import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
 import { NDimensionalFieldTypeArray, SerializedNDimensionalFieldTypeArray } from './ndimensionalfieldtypearray';
 import { ScalarFieldTypeEnum } from './scalarfieldtype';
 export type AnyFieldTypeArrayDefinition = FieldTypeArray | NDimensionalFieldTypeArray;
-export type BaseFieldTypeDefinition = ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray<any> | NDimensionalFieldTypeArray | CollectionEnumFieldType;
-export type SerializedBaseFieldTypeDefinition = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedNDimensionalFieldTypeArray | SerializedCollectionEnumFieldType;
+export type BaseFieldTypeDefinition = ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray<any> | NDimensionalFieldTypeArray | CollectionEnumFieldType | DeserializedMapEnumFieldType;
+export type SerializedBaseFieldTypeDefinition = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedNDimensionalFieldTypeArray | SerializedCollectionEnumFieldType | SerializedMapEnumFieldType;
 export declare function isBaseFieldTypeDefinition(fieldType: any): fieldType is BaseFieldTypeDefinition;
 export declare function serializeBaseFieldTypeDefinition(baseFieldType: BaseFieldTypeDefinition): SerializedBaseFieldTypeDefinition;
 export declare function deserializeBaseFieldTypeDefinition(baseFieldType: SerializedBaseFieldTypeDefinition): BaseFieldTypeDefinition;

package/core/data/fieldtypedefinition/basefieldtypedefinition.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSerializedBaseFieldTypeDefinition = exports.deserializeBaseFieldTypeDefinition = exports.serializeBaseFieldTypeDefinition = exports.isBaseFieldTypeDefinition = void 0;
 const checks_1 = require("../../checks");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
+const deserializedmapenumfieldtype_1 = require("./deserializedmapenumfieldtype");
 const fieldtypearray_1 = require("./fieldtypearray");
 const literalfieldtype_1 = require("./literalfieldtype");
 const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
@@ -12,7 +13,8 @@ function isBaseFieldTypeDefinition(fieldType) {
         (0, literalfieldtype_1.isLiteralFieldType)(fieldType) ||
         fieldType instanceof fieldtypearray_1.FieldTypeArray ||
         fieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray ||
-        (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType));
+        (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType) ||
+        (0, deserializedmapenumfieldtype_1.isDeserializedMapEnumFieldType)(fieldType));
 }
 exports.isBaseFieldTypeDefinition = isBaseFieldTypeDefinition;
 function serializeBaseFieldTypeDefinition(baseFieldType) {
@@ -23,7 +25,8 @@ function serializeBaseFieldTypeDefinition(baseFieldType) {
     if (baseFieldType instanceof literalfieldtype_1.LiteralFieldType ||
         baseFieldType instanceof fieldtypearray_1.FieldTypeArray ||
         baseFieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray ||
-        baseFieldType instanceof collectionenumfieldtype_1.CollectionEnumFieldType) {
+        baseFieldType instanceof collectionenumfieldtype_1.CollectionEnumFieldType ||
+        baseFieldType instanceof deserializedmapenumfieldtype_1.DeserializedMapEnumFieldType) {
         return baseFieldType.toJSON();
     }
     return baseFieldType;
@@ -42,6 +45,9 @@ function deserializeBaseFieldTypeDefinition(baseFieldType) {
     if ((0, ndimensionalfieldtypearray_1.isSerializedNDimensionalFieldTypeArray)(baseFieldType)) {
         return (0, ndimensionalfieldtypearray_1.deserializeNDimensionalFieldTypeArray)(baseFieldType);
     }
+    if ((0, deserializedmapenumfieldtype_1.isSerializedMapEnumFieldType)(baseFieldType)) {
+        return deserializedmapenumfieldtype_1.DeserializedMapEnumFieldType.fromJSON(baseFieldType);
+    }
     return baseFieldType;
 }
 exports.deserializeBaseFieldTypeDefinition = deserializeBaseFieldTypeDefinition;
@@ -50,6 +56,7 @@ function isSerializedBaseFieldTypeDefinition(definition) {
         (0, literalfieldtype_1.isSerializedLiteralFieldType)(definition) ||
         (0, collectionenumfieldtype_1.isSerializedCollectionEnumFieldType)(definition) ||
         (0, fieldtypearray_1.isSerializedFieldTypeArray)(definition, isSerializedBaseFieldTypeDefinition) ||
-        (0, ndimensionalfieldtypearray_1.isSerializedNDimensionalFieldTypeArray)(definition));
+        (0, ndimensionalfieldtypearray_1.isSerializedNDimensionalFieldTypeArray)(definition) ||
+        (0, deserializedmapenumfieldtype_1.isSerializedMapEnumFieldType)(definition));
 }
 exports.isSerializedBaseFieldTypeDefinition = isSerializedBaseFieldTypeDefinition;

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

@@ -0,0 +1,28 @@
+export declare class DeserializedMapEnumFieldType {
+    readonly validEntries: ReadonlyMap<EnumKeyType, DeserializedMapEnumFieldTypeEntry>;
+    constructor(validEntries: ReadonlyMap<EnumKeyType, DeserializedMapEnumFieldTypeEntry>);
+    toJSON(): SerializedMapEnumFieldType;
+    static fromJSON(val: SerializedMapEnumFieldType): DeserializedMapEnumFieldType;
+}
+export declare function isDeserializedMapEnumFieldType(val: unknown): val is DeserializedMapEnumFieldType;
+export type SerializedMapEnumFieldType = {
+    'ValidItems': SerializedEnumEntry[];
+};
+export declare function isSerializedMapEnumFieldType(fieldType: any): fieldType is SerializedMapEnumFieldType;
+export interface DeserializedMapEnumFieldTypeEntry {
+    name?: string | null;
+    description?: string | null;
+    color?: string | null;
+    iconUrl?: string | null;
+}
+export interface SerializedEnumEntry {
+    'Id': EnumKeyType;
+    'Name'?: string | undefined | null;
+    'Description'?: string | undefined | null;
+    'Color'?: string | undefined | null;
+    'IconUrl'?: string | undefined | null;
+}
+export declare function isSerializedEnumEntry(entry: any): entry is SerializedEnumEntry;
+export declare function serializeEnumEntry(id: EnumKeyType, entry: DeserializedMapEnumFieldTypeEntry): SerializedEnumEntry;
+export declare function deserializeEnumEntry(entry: SerializedEnumEntry): [EnumKeyType, DeserializedMapEnumFieldTypeEntry];
+export type EnumKeyType = string | number;

package/core/data/fieldtypedefinition/deserializedmapenumfieldtype.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeEnumEntry = exports.serializeEnumEntry = exports.isSerializedEnumEntry = exports.isSerializedMapEnumFieldType = exports.isDeserializedMapEnumFieldType = exports.DeserializedMapEnumFieldType = void 0;
+const checks_1 = require("../../checks");
+const validators_1 = require("../../validators/validators");
+class DeserializedMapEnumFieldType {
+    constructor(validEntries) {
+        this.validEntries = validEntries;
+    }
+    toJSON() {
+        return {
+            'ValidItems': [...this.validEntries.entries()].map(([key, value]) => serializeEnumEntry(key, value)),
+        };
+    }
+    static fromJSON(val) {
+        return new DeserializedMapEnumFieldType(new Map(val['ValidItems'].map(deserializeEnumEntry)));
+    }
+}
+exports.DeserializedMapEnumFieldType = DeserializedMapEnumFieldType;
+function isDeserializedMapEnumFieldType(val) {
+    return val instanceof DeserializedMapEnumFieldType;
+}
+exports.isDeserializedMapEnumFieldType = isDeserializedMapEnumFieldType;
+function isSerializedMapEnumFieldType(fieldType) {
+    return ((0, checks_1.isObjectUnsafe)(fieldType) &&
+        Array.isArray(fieldType['ValidItems']) &&
+        fieldType['ValidItems'].every(isSerializedEnumEntry));
+}
+exports.isSerializedMapEnumFieldType = isSerializedMapEnumFieldType;
+function isSerializedEnumEntry(entry) {
+    return ((0, checks_1.isObjectUnsafe)(entry) &&
+        (0, checks_1.isString)(entry['Id']) &&
+        (0, validators_1.nullableOption)(checks_1.isString)(entry['Name']) &&
+        (0, validators_1.nullableOption)(checks_1.isString)(entry['Description']) &&
+        (0, validators_1.nullableOption)(checks_1.isString)(entry['Color']) &&
+        (0, validators_1.nullableOption)(checks_1.isString)(entry['IconUrl']));
+}
+exports.isSerializedEnumEntry = isSerializedEnumEntry;
+function serializeEnumEntry(id, entry) {
+    return {
+        'Id': id,
+        'Name': entry.name,
+        'Description': entry.description,
+        'Color': entry.color,
+        'IconUrl': entry.iconUrl,
+    };
+}
+exports.serializeEnumEntry = serializeEnumEntry;
+function deserializeEnumEntry(entry) {
+    return [
+        entry['Id'],
+        {
+            name: entry['Name'],
+            description: entry['Description'],
+            color: entry['Color'],
+            iconUrl: entry['IconUrl'],
+        },
+    ];
+}
+exports.deserializeEnumEntry = deserializeEnumEntry;

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

@@ -1,4 +1,5 @@
 import { CollectionEnumFieldType, SerializedCollectionEnumFieldType } from './collectionenumfieldtype';
+import { DeserializedMapEnumFieldType, SerializedMapEnumFieldType } from './deserializedmapenumfieldtype';
 import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
 import { ScalarFieldTypeEnum } from './scalarfieldtype';
 export declare abstract class BaseFieldTypeArray<Type> {
@@ -9,10 +10,10 @@ export declare abstract class BaseFieldTypeArray<Type> {
     getInnerNonArrayTypes(): Exclude<Type, BaseFieldTypeArray<Type>>[];
     toJSON(): SerializedFieldTypeArray;
 }
-export type FieldTypeArraySubTypes = ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray<any>;
-export type SerializedFieldTypeArraySubTypes = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedCollectionEnumFieldType;
+export type FieldTypeArraySubTypes = ScalarFieldTypeEnum | CollectionEnumFieldType | DeserializedMapEnumFieldType | LiteralFieldType | FieldTypeArray<any>;
+export type SerializedFieldTypeArraySubTypes = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedCollectionEnumFieldType | SerializedMapEnumFieldType;
 export declare class FieldTypeArray<SubTypes extends FieldTypeArraySubTypes = FieldTypeArraySubTypes> extends BaseFieldTypeArray<SubTypes> {
-    protected serializeType(t: FieldTypeArraySubTypes): string | SerializedCollectionEnumFieldType | ScalarFieldTypeEnum | SerializedFieldTypeArray;
+    protected serializeType(t: FieldTypeArraySubTypes): string | SerializedCollectionEnumFieldType | ScalarFieldTypeEnum | SerializedMapEnumFieldType | SerializedFieldTypeArray;
 }
 export type SerializedFieldTypeArray = {
     'ND': false;

package/core/data/fieldtypedefinition/fieldtypearray.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deserializeFieldTypeArray = exports.isSerializedFieldTypeArray = exports.FieldTypeArray = exports.BaseFieldTypeArray = void 0;
 const checks_1 = require("../../checks");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
+const deserializedmapenumfieldtype_1 = require("./deserializedmapenumfieldtype");
 const literalfieldtype_1 = require("./literalfieldtype");
 const scalarfieldtype_1 = require("./scalarfieldtype");
 class BaseFieldTypeArray {
@@ -47,6 +48,9 @@ function deserializeFieldTypeArray(serializedFieldTypeArray) {
         else if ((0, collectionenumfieldtype_1.isSerializedCollectionEnumFieldType)(t)) {
             return (0, collectionenumfieldtype_1.deserializeCollectionEnumFieldType)(t);
         }
+        else if ((0, deserializedmapenumfieldtype_1.isSerializedMapEnumFieldType)(t)) {
+            return deserializedmapenumfieldtype_1.DeserializedMapEnumFieldType.fromJSON(t);
+        }
         else if ((0, checks_1.isObject)(t)) {
             return deserializeFieldTypeArray(t);
         }

package/core/data/fieldtypedefinition/fieldtypedefinition.js

@@ -4,6 +4,7 @@ exports.isSerializedFieldTypeDefinition = exports.deserializeFieldTypeDefinition
 const checks_1 = require("../../checks");
 const basefieldtypedefinition_1 = require("./basefieldtypedefinition");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
+const deserializedmapenumfieldtype_1 = require("./deserializedmapenumfieldtype");
 const fieldtypearray_1 = require("./fieldtypearray");
 const literalfieldtype_1 = require("./literalfieldtype");
 const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
@@ -17,6 +18,14 @@ function fieldTypesEqual(a, b, checkEnumCollectionId = true) {
     if ((0, collectionenumfieldtype_1.isCollectionEnumFieldType)(a) && (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(b)) {
         return checkEnumCollectionId ? a.collectionId === b.collectionId : true;
     }
+    if ((0, deserializedmapenumfieldtype_1.isDeserializedMapEnumFieldType)(a) && (0, deserializedmapenumfieldtype_1.isDeserializedMapEnumFieldType)(b)) {
+        for (const [key, value] of a.validEntries.entries()) {
+            if (!b.validEntries.has(key) || b.validEntries.get(key) !== value) {
+                return false;
+            }
+        }
+        return true;
+    }
     a = (0, checks_1.isArray)(a) ? a : [a];
     b = (0, checks_1.isArray)(b) ? b : [b];
     const setA = new Set(a);

package/package.json

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