lucid-extension-sdk 0.0.233 → 0.0.236

package/commandtypes.d.ts

@@ -1540,7 +1540,7 @@ export type ShowModalQuery = {
     /** URL to display in the modal (this or c is required). Can be relative to /public directory in the package */
     'u'?: string | undefined;
 };
-export type ShowModalResult = undefined;
+export type ShowModalResult = Promise<undefined>;
 export type ShowPackageSettingsModalQuery = undefined;
 export type ShowPackageSettingsModalResult = Promise<void>;
 export type ShowPanelQuery = {

package/core/data/fieldspecification.d.ts

@@ -3,6 +3,7 @@ import { CollectionEnumFieldType } from './fieldtypedefinition/collectionenumfie
 import { FieldTypeArray } from './fieldtypedefinition/fieldtypearray';
 import { FieldTypeDefinition } from './fieldtypedefinition/fieldtypedefinition';
 import { ScalarFieldTypeEnum } from './fieldtypedefinition/scalarfieldtype';
+import { SemanticFields } from './fieldtypedefinition/semanticfields';
 import { SemanticKind } from './fieldtypedefinition/semantickind';
 import { SerializedColorObject, SerializedLucidCurrency, SerializedLucidDateObject, SerializedLucidDictionary } from './serializedfield/serializedfields';
 type TsTypeOf<X> = X extends ScalarFieldTypeEnum.ANY ? unknown : X extends ScalarFieldTypeEnum.NUMBER ? number : X extends ScalarFieldTypeEnum.BOOLEAN ? boolean : X extends ScalarFieldTypeEnum.STRING ? string : X extends ScalarFieldTypeEnum.COLOR ? SerializedColorObject : X extends ScalarFieldTypeEnum.DATE ? SerializedLucidDateObject : X extends ScalarFieldTypeEnum.NULL ? null : X extends ScalarFieldTypeEnum.DICTIONARY ? SerializedLucidDictionary : X extends FieldTypeArray<infer Inner> ? TsTypeOf<Inner>[] : X extends ScalarFieldTypeEnum.CURRENCY ? SerializedLucidCurrency : X extends ScalarFieldTypeEnum.DATEONLY ? SerializedLucidDateObject & {
@@ -17,11 +18,11 @@ type TsTypeOf<X> = X extends ScalarFieldTypeEnum.ANY ? unknown : X extends Scala
  * which allows all the fields not part of the primaryKey to be undefined. The former should
  * be used with initial imports, and the latter can be used for updates.
  */
-export declare function declareSchema<Names extends string, Types extends Readonly<FieldTypeDefinition>, Constraint extends FieldConstraintDefinition, SemanticFieldTypes extends SemanticKind, Fields extends {
+export declare function declareSchema<Names extends string, Types extends Readonly<FieldTypeDefinition>, Constraint extends FieldConstraintDefinition, Fields extends {
     [Name in Names]: {
         type: Types;
         constraints?: readonly Constraint[];
-        mapping?: readonly SemanticFieldTypes[] | undefined;
+        mapping?: readonly SemanticKind[] | readonly SemanticFields[] | undefined;
     };
 }, PrimaryKey extends keyof Fields>({ primaryKey, fields }: {
     primaryKey: PrimaryKey[];
@@ -32,7 +33,7 @@ export declare function declareSchema<Names extends string, Types extends Readon
         name: Exclude<keyof typeof fields, number>;
         type: FieldTypeDefinition;
         constraints: FieldConstraintDefinition[];
-        mapping: SemanticFieldTypes[];
+        mapping: readonly SemanticKind[] | readonly SemanticFields[];
     }[];
     primaryKey: FormattedPrimaryKey<Fields, PrimaryKey>;
     fromItemsSparse: (items: PartialItemType<typeof fields, PrimaryKey>[]) => Map<string, PartialItemType<Fields, PrimaryKey>>;
@@ -78,7 +79,7 @@ export declare class FormattedPrimaryKey<Fields extends FieldsStructure, Primary
 type FieldsStructure = {
     [Name in string]: {
         type: Readonly<FieldTypeDefinition>;
-        mapping?: undefined | readonly SemanticKind[];
+        mapping?: undefined | readonly SemanticKind[] | readonly SemanticFields[];
     };
 };
 /**

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

@@ -0,0 +1,72 @@
+/**
+ * Semantic Fields serve as standardized categories that transcend individual data source labels, facilitating
+ * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
+ * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
+ * Lucid’s Semantic Fields ensure that such data is recognized and treated consistently within the platform,
+ * regardless of external labeling conventions.
+ *
+ * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
+ * Semantic Fields. By using Semantic Fields like Title, Description, User, and Project, Lucid simplifies the way
+ * users access and interact with data brought in from external sources.
+ *
+ * Benefits of Semantic Fields:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Fields.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+export declare enum SemanticFields {
+    /**
+     * Represents the title or main descriptor of an item.
+     */
+    Title = "title",
+    /**
+     * Captures detailed information or a summary about an item.
+     */
+    Description = "description",
+    /**
+     * Refers to the user associated with or assigned to an item.
+     */
+    User = "user",
+    /**
+     * Specific to the reporting user, typically in the context of a ticketing system.
+     */
+    Reporter = "user.reporter",
+    /**
+     * Refers to the time associated with an item.
+     */
+    Time = "time",
+    /**
+     * Pertains to the ending or completion time of an item.
+     */
+    EndTime = "time.endtime",
+    /**
+     * Contains estimations related to items, like time or resource estimates.
+     */
+    Estimate = "estimate",
+    /**
+     * Reflects status of an item, typically in the context of a ticketing system.
+     */
+    Status = "status",
+    /**
+     * Classifies the type of issue or item, typically in the context of a ticketing system.
+     */
+    IssueType = "issuetype",
+    /**
+     * Indicates the importance or urgency level of an item.
+     */
+    Priority = "priority",
+    /**
+     * Relates to the project with which an item is associated.
+     */
+    Project = "project",
+    /**
+     * The unique URL or identifier linking back to the item’s source.
+     */
+    SourceItemUrl = "url",
+    /**
+     * Refers to the URL of the image associated with this item
+     */
+    ImageUrl = "url.image"
+}
+export declare const isSemanticFields: (x: unknown) => x is SemanticFields;

package/core/data/fieldtypedefinition/semanticfields.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemanticFields = exports.SemanticFields = void 0;
+const validators_1 = require("../../validators/validators");
+/**
+ * Semantic Fields serve as standardized categories that transcend individual data source labels, facilitating
+ * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
+ * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
+ * Lucid’s Semantic Fields ensure that such data is recognized and treated consistently within the platform,
+ * regardless of external labeling conventions.
+ *
+ * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
+ * Semantic Fields. By using Semantic Fields like Title, Description, User, and Project, Lucid simplifies the way
+ * users access and interact with data brought in from external sources.
+ *
+ * Benefits of Semantic Fields:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Fields.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+var SemanticFields;
+(function (SemanticFields) {
+    /**
+     * Represents the title or main descriptor of an item.
+     */
+    SemanticFields["Title"] = "title";
+    /**
+     * Captures detailed information or a summary about an item.
+     */
+    SemanticFields["Description"] = "description";
+    /**
+     * Refers to the user associated with or assigned to an item.
+     */
+    SemanticFields["User"] = "user";
+    /**
+     * Specific to the reporting user, typically in the context of a ticketing system.
+     */
+    SemanticFields["Reporter"] = "user.reporter";
+    /**
+     * Refers to the time associated with an item.
+     */
+    SemanticFields["Time"] = "time";
+    /**
+     * Pertains to the ending or completion time of an item.
+     */
+    SemanticFields["EndTime"] = "time.endtime";
+    /**
+     * Contains estimations related to items, like time or resource estimates.
+     */
+    SemanticFields["Estimate"] = "estimate";
+    /**
+     * Reflects status of an item, typically in the context of a ticketing system.
+     */
+    SemanticFields["Status"] = "status";
+    /**
+     * Classifies the type of issue or item, typically in the context of a ticketing system.
+     */
+    SemanticFields["IssueType"] = "issuetype";
+    /**
+     * Indicates the importance or urgency level of an item.
+     */
+    SemanticFields["Priority"] = "priority";
+    /**
+     * Relates to the project with which an item is associated.
+     */
+    SemanticFields["Project"] = "project";
+    /**
+     * The unique URL or identifier linking back to the item’s source.
+     */
+    SemanticFields["SourceItemUrl"] = "url";
+    /**
+     * Refers to the URL of the image associated with this item
+     */
+    SemanticFields["ImageUrl"] = "url.image";
+})(SemanticFields || (exports.SemanticFields = SemanticFields = {}));
+exports.isSemanticFields = (0, validators_1.stringEnumValidator)(SemanticFields);

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

@@ -1,3 +1,7 @@
+import { SemanticFields } from './semanticfields';
+/**
+ * @deprecated use SemanticFields instead. SemanticKind has not been removed to ensure backwards compatability.
+ */
 export declare enum SemanticKind {
     Id = "id",
     Title = "title",
@@ -18,3 +22,4 @@ export declare enum SemanticKind {
     URL = "url"
 }
 export declare const isSemanticKind: (x: unknown) => x is SemanticKind;
+export declare function semanticKindToSemanticFields(semanticField: SemanticKind | SemanticFields): SemanticFields | undefined;

package/core/data/fieldtypedefinition/semantickind.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSemanticKind = exports.SemanticKind = void 0;
+exports.semanticKindToSemanticFields = exports.isSemanticKind = exports.SemanticKind = void 0;
 const validators_1 = require("../../validators/validators");
+const semanticfields_1 = require("./semanticfields");
+/**
+ * @deprecated use SemanticFields instead. SemanticKind has not been removed to ensure backwards compatability.
+ */
 var SemanticKind;
 (function (SemanticKind) {
     SemanticKind["Id"] = "id";
@@ -23,3 +27,49 @@ var SemanticKind;
     SemanticKind["URL"] = "url";
 })(SemanticKind || (exports.SemanticKind = SemanticKind = {}));
 exports.isSemanticKind = (0, validators_1.enumValidator)(SemanticKind);
+function semanticKindToSemanticFields(semanticField) {
+    if ((0, semanticfields_1.isSemanticFields)(semanticField)) {
+        return semanticField;
+    }
+    else {
+        switch (semanticField) {
+            case SemanticKind.Id:
+                return undefined;
+            case SemanticKind.Title:
+                return semanticfields_1.SemanticFields.Title;
+            case SemanticKind.Name:
+                return semanticfields_1.SemanticFields.User;
+            case SemanticKind.Image:
+                return semanticfields_1.SemanticFields.ImageUrl;
+            case SemanticKind.Description:
+                return semanticfields_1.SemanticFields.Description;
+            case SemanticKind.Assignee:
+                return semanticfields_1.SemanticFields.User;
+            case SemanticKind.Estimate:
+                return semanticfields_1.SemanticFields.Estimate;
+            case SemanticKind.Status:
+                return semanticfields_1.SemanticFields.Status;
+            case SemanticKind.IssueType:
+                return semanticfields_1.SemanticFields.IssueType;
+            case SemanticKind.Priority:
+                return semanticfields_1.SemanticFields.Priority;
+            case SemanticKind.Project:
+                return semanticfields_1.SemanticFields.Project;
+            case SemanticKind.Reporter:
+                return semanticfields_1.SemanticFields.Reporter;
+            case SemanticKind.StartTime:
+                return semanticfields_1.SemanticFields.Time;
+            case SemanticKind.EndTime:
+                return semanticfields_1.SemanticFields.EndTime;
+            case SemanticKind.GroupByHint:
+                return undefined;
+            case SemanticKind.PrimaryKeyReference:
+                return undefined;
+            case SemanticKind.URL:
+                return semanticfields_1.SemanticFields.SourceItemUrl;
+            default:
+                return undefined;
+        }
+    }
+}
+exports.semanticKindToSemanticFields = semanticKindToSemanticFields;

package/core/data/serializedfield/serializedfielddefinition.d.ts

@@ -1,6 +1,7 @@
 import { isString } from '../../checks';
 import { JsonSerializable } from '../../jsonserializable';
 import { SerializedFieldTypeDefinition, isSerializedFieldTypeDefinition } from '../fieldtypedefinition/fieldtypedefinition';
+import { SemanticFields } from '../fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../fieldtypedefinition/semantickind';
 export declare enum FieldConstraintType {
     REQUIRED = "required",
@@ -25,7 +26,7 @@ export type SerializedFieldDefinition = {
     'Type': SerializedFieldTypeDefinition;
     'Constraints'?: SerializedFieldConstraint[] | undefined;
     'SyncSchema'?: string | undefined;
-    'Mapping'?: readonly SemanticKind[] | undefined;
+    'Mapping'?: readonly SemanticFields[] | readonly SemanticKind[] | undefined;
 };
 export declare const isSerializedFieldDefinition: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
@@ -35,5 +36,5 @@ export declare const isSerializedFieldDefinition: (subject: unknown) => subject
         Details: (x: unknown) => x is any;
     }>[] | undefined;
     SyncSchema: (x: unknown) => x is string | undefined;
-    Mapping: (x: unknown) => x is SemanticKind[] | undefined;
+    Mapping: (x: unknown) => x is SemanticFields[] | SemanticKind[] | undefined;
 }>;

package/core/data/serializedfield/serializedfielddefinition.js

@@ -4,6 +4,7 @@ exports.isSerializedFieldDefinition = exports.isSerializedFieldConstraint = expo
 const checks_1 = require("../../checks");
 const validators_1 = require("../../validators/validators");
 const fieldtypedefinition_1 = require("../fieldtypedefinition/fieldtypedefinition");
+const semanticfields_1 = require("../fieldtypedefinition/semanticfields");
 const semantickind_1 = require("../fieldtypedefinition/semantickind");
 // The options here must match com.lucidchart.data.model.fielddefinition.FieldConstraintType on the backend
 var FieldConstraintType;
@@ -26,5 +27,5 @@ exports.isSerializedFieldDefinition = (0, validators_1.strictObjectValidator)({
     'Type': fieldtypedefinition_1.isSerializedFieldTypeDefinition,
     'Constraints': (0, validators_1.option)((0, validators_1.arrayValidator)(exports.isSerializedFieldConstraint)),
     'SyncSchema': (0, validators_1.option)(checks_1.isString),
-    'Mapping': (0, validators_1.option)((0, validators_1.arrayValidator)((0, validators_1.stringEnumValidator)(semantickind_1.SemanticKind))),
+    'Mapping': (0, validators_1.option)((0, validators_1.either)((0, validators_1.arrayValidator)(semanticfields_1.isSemanticFields), (0, validators_1.arrayValidator)(semantickind_1.isSemanticKind))),
 });

package/data/schemadefinition.d.ts

@@ -1,5 +1,6 @@
 import { isNumber, isUndefined } from '../core/checks';
 import { FieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
+import { SemanticFields } from '../core/data/fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
 import { FieldConstraintType, SerializedFieldConstraint, SerializedFieldDefinition } from '../core/data/serializedfield/serializedfielddefinition';
 import { SerializedSchema } from '../core/data/serializedfield/serializedschema';
@@ -51,7 +52,7 @@ export interface FieldDefinition {
     name: string;
     type: FieldTypeDefinition;
     constraints?: FieldConstraintDefinition[] | undefined;
-    mapping?: readonly SemanticKind[] | undefined;
+    mapping?: readonly SemanticFields[] | readonly SemanticKind[] | undefined;
 }
 /**
  * Definition of a schema for creating a [Collection](#classes_data_collectionproxy-CollectionProxy)

package/dataconnector/datasourceupdatetypes.d.ts

@@ -1,5 +1,6 @@
 import { UpstreamPatchType } from '../core/data/datasource/upstreampatchtype';
 import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
+import { SemanticFields } from '../core/data/fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
 import { FieldConstraintType } from '../core/data/serializedfield/serializedfielddefinition';
 import { SerializedFields, SerializedLucidDictionary } from '../core/data/serializedfield/serializedfields';
@@ -32,7 +33,7 @@ type SerializedFieldDefinitionForApi = {
     'type': SerializedFieldTypeDefinition;
     'constraints': SerializedFieldConstraintForApi[];
     'syncSchema'?: string;
-    'mapping'?: readonly SemanticKind[];
+    'mapping'?: readonly SemanticKind[] | readonly SemanticFields[];
 };
 type SerializedSchemaForApi = {
     'fields': SerializedFieldDefinitionForApi[];

package/package.json

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

package/ui/modal.d.ts

@@ -57,7 +57,7 @@ export declare abstract class Modal extends IframeUI {
     private visible;
     constructor(client: EditorClient, config: ModalConfig);
     protected frameClosed(): void;
-    show(): void;
+    show(): Promise<void>;
     /**
      * If this modal is currently visible, close it, destroying the iframe.
      */

package/ui/modal.js

@@ -22,10 +22,10 @@ class Modal extends iframeui_1.IframeUI {
         this.visible = false;
         this.unhookMessages();
     }
-    show() {
+    async show() {
         if (!this.visible) {
             this.hookMessages();
-            this.client.sendCommand("sm" /* CommandName.ShowModal */, {
+            await this.client.sendCommand("sm" /* CommandName.ShowModal */, {
                 'n': this.messageActionName,
                 't': this.config.title,
                 'w': this.config.width,