lucid-extension-sdk 0.0.317 → 0.0.319

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.319",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",