lucid-extension-sdk 0.0.375 → 0.0.377

package/commandtypes.d.ts

@@ -862,6 +862,10 @@ export type AddCardIntegrationQuery = {
              */
             'sih'?: string;
         };
+        /**
+         * Item label phrase
+         */
+        'ilp'?: string;
     } | undefined;
 };
 export type AddCardIntegrationResult = undefined;

package/core/cardintegration/cardintegrationparams.d.ts

@@ -36,6 +36,10 @@ interface DependenciesForItemParam {
 export interface DependenciesForItemsParam {
     'dfi': DependenciesForItemParam[];
 }
+export interface DependencyMappingItemLabelPhraseParam {
+    'ci': string;
+    'pk': string;
+}
 /** @ignore */
 export interface CustomImportParam {
     'd': JsonSerializable;

package/core/cardintegration/dependencymappingphrases.d.ts

@@ -1,3 +1,4 @@
+import { DataItemProxy } from '../../data/dataitemproxy';
 interface DependencyManagerEmptyStatePhrasesType {
     readonly multipleIssueKeyWithNoLink?: string;
     readonly createLinkInstruction?: string;
@@ -27,5 +28,9 @@ export interface DependencyMappingPhrasesType {
     cardLabel?: (locale: string, count: number) => string;
     manager?: DependencyManagerPhrasesType;
     edit?: DependencyEditPhrasesType;
+    /**
+     * This function is used to map the dataItemProxy to item label phrase.
+     */
+    itemLabelPhrase?: (dataItem: DataItemProxy) => string;
 }
 export {};

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -47,6 +47,7 @@ class LucidCardIntegrationRegistry {
             const manager = dependencyMappingPhrases.manager;
             const emptyState = manager === null || manager === void 0 ? void 0 : manager.emptyState;
             const edit = dependencyMappingPhrases.edit;
+            const itemLabelPhrase = dependencyMappingPhrases.itemLabelPhrase;
             // Strings that appear on the canvas must calculate their locale at runtime,
             // so all users get canvas content in the same locale
             const cardLabelActionName = dependencyMappingPhrases.cardLabel
@@ -73,6 +74,15 @@ class LucidCardIntegrationRegistry {
                     return (_a = edit === null || edit === void 0 ? void 0 : edit.selectedIssueHeading) === null || _a === void 0 ? void 0 : _a.call(edit, key);
                 });
             }
+            let itemLabelPhraseActionName = undefined;
+            if (itemLabelPhrase) {
+                itemLabelPhraseActionName = LucidCardIntegrationRegistry.nextHookName();
+                client.registerAction(itemLabelPhraseActionName, ({ 'ci': ci, 'pk': pk }) => {
+                    const collectionProxy = new collectionproxy_1.CollectionProxy(ci, client);
+                    const itemProxy = new dataitemproxy_1.DataItemProxy(pk, collectionProxy, client);
+                    return itemLabelPhrase(itemProxy);
+                });
+            }
             serialized['dmp'] = {
                 'ep': dependencyMappingPhrases.entrypoint,
                 'cl': cardLabelActionName,
@@ -105,6 +115,7 @@ class LucidCardIntegrationRegistry {
                         'sih': selectedIssueHeadingActionName,
                     }
                     : undefined,
+                'ilp': itemLabelPhraseActionName,
             };
         }
         if (cardIntegration.importDependencies) {

package/dataconnector/datasourceupdatetypes.d.ts

@@ -11,7 +11,7 @@ import { SerializedFields, SerializedLucidDictionary } from '../core/data/serial
 import { SerializedLabelOverrides } from '../core/data/serializedfield/serializedschema';
 import { JsonSerializable } from '../core/jsonserializable';
 import { DataUpdateFilterType } from '../data/dataupdatefiltertype';
-import { FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
+import { FieldConstraintDefinition, FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
 /**
  * Container for an update to a data source
  */
@@ -32,7 +32,7 @@ export type DataSourceRequest = {
     /** The level of permission the request has to create data */
     creationPermission?: UpdateCreationPermission;
 };
-type SerializedFieldConstraintForApi = {
+export type SerializedFieldConstraintForApi = {
     'type': FieldConstraintType;
     'details'?: JsonSerializable;
 };
@@ -66,6 +66,7 @@ export declare class ItemsPatchInexhaustive {
     /** Items to remove from the collection, based on the same primary key algorithm. */
     itemsDeleted?: string[] | undefined;
     errors?: Map<string, SerializedLucidDictionary> | undefined;
+    fieldConstraintsPerItem?: Map<string, Map<string, FieldConstraintDefinition[]>> | undefined;
     private readonly _brand;
     constructor(
     /**
@@ -74,15 +75,16 @@ export declare class ItemsPatchInexhaustive {
      **/
     items: Map<string, SerializedFields>, 
     /** Items to remove from the collection, based on the same primary key algorithm. */
-    itemsDeleted?: string[] | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
+    itemsDeleted?: string[] | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined, fieldConstraintsPerItem?: Map<string, Map<string, FieldConstraintDefinition[]>> | undefined);
 }
 export declare class ItemsPatchExhaustive {
     items: Map<string, SerializedFields>;
     rekeyingMap?: Map<string, string | null> | undefined;
     fieldNamesChanged?: Map<string, string | null> | undefined;
     errors?: Map<string, SerializedLucidDictionary> | undefined;
+    fieldConstraintsPerItem?: Map<string, Map<string, FieldConstraintDefinition[]>> | undefined;
     private readonly _brand;
-    constructor(items: Map<string, SerializedFields>, rekeyingMap?: Map<string, string | null> | undefined, fieldNamesChanged?: Map<string, string | null> | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
+    constructor(items: Map<string, SerializedFields>, rekeyingMap?: Map<string, string | null> | undefined, fieldNamesChanged?: Map<string, string | null> | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined, fieldConstraintsPerItem?: Map<string, Map<string, FieldConstraintDefinition[]>> | undefined);
 }
 export type ItemsPatch = {
     /**
@@ -94,16 +96,23 @@ export type ItemsPatch = {
     itemsDeleted?: string[];
     /** Errors found while patching the items */
     errors?: Map<string, SerializedLucidDictionary>;
+    /**
+     *Constraints that can be defined on a per-item basis to conditionally lock fields for a specific item.
+     *The key for this map is the primary key of an item, and the value is a map from the name a field on that item to the constraints that should be applied to that field.
+     */
+    fieldConstraintsPerItem?: Map<string, Map<string, FieldConstraintDefinition[]>>;
 } | ItemsPatchInexhaustive | ItemsPatchExhaustive;
 export type SerializedItemsPatch = {
     'items': Record<string, SerializedFields>;
     'itemsDeleted': string[];
     'errors'?: Record<string, SerializedLucidDictionary>;
+    'fieldConstraintsPerItem'?: Record<string, Record<string, SerializedFieldConstraintForApi[]>>;
 } | {
     'exhaustiveItems': Record<string, SerializedFields>;
     'rekeyingMap'?: Record<string, string | null>;
     'fieldNamesChanged'?: Record<string, string | null>;
     'errors'?: Record<string, SerializedLucidDictionary>;
+    'fieldConstraintsPerItem'?: Record<string, Record<string, SerializedFieldConstraintForApi[]>>;
 };
 export declare function serializeItemsPatch(patch: ItemsPatch): SerializedItemsPatch;
 /**

package/dataconnector/datasourceupdatetypes.js

@@ -13,40 +13,55 @@ class ItemsPatchInexhaustive {
      **/
     items, 
     /** Items to remove from the collection, based on the same primary key algorithm. */
-    itemsDeleted, errors) {
+    itemsDeleted, errors, fieldConstraintsPerItem) {
         this.items = items;
         this.itemsDeleted = itemsDeleted;
         this.errors = errors;
+        this.fieldConstraintsPerItem = fieldConstraintsPerItem;
         this._brand = ItemsPatchInexhaustive;
     }
 }
 exports.ItemsPatchInexhaustive = ItemsPatchInexhaustive;
 class ItemsPatchExhaustive {
-    constructor(items, rekeyingMap, fieldNamesChanged, errors) {
+    constructor(items, rekeyingMap, fieldNamesChanged, errors, fieldConstraintsPerItem) {
         this.items = items;
         this.rekeyingMap = rekeyingMap;
         this.fieldNamesChanged = fieldNamesChanged;
         this.errors = errors;
+        this.fieldConstraintsPerItem = fieldConstraintsPerItem;
         this._brand = ItemsPatchExhaustive;
     }
 }
 exports.ItemsPatchExhaustive = ItemsPatchExhaustive;
-function serializeErrors(errors) {
-    return errors && { 'errors': (0, object_1.fromEntries)(errors) };
-}
 function serializeRekeyingMap(rekeyingMap) {
     return rekeyingMap && { 'rekeyingMap': (0, object_1.fromEntries)(rekeyingMap) };
 }
 function serializeFieldNamesChanged(fieldNamesChanged) {
     return fieldNamesChanged && { 'fieldNamesChanged': (0, object_1.fromEntries)(fieldNamesChanged) };
 }
+function serializeErrors(errors) {
+    return errors && { 'errors': (0, object_1.fromEntries)(errors) };
+}
+function serializeFieldConstraintsPerItem(fieldConstraintsPerItem) {
+    if (!fieldConstraintsPerItem) {
+        return undefined;
+    }
+    const result = {};
+    fieldConstraintsPerItem.forEach((fieldNameToConstraints, key) => {
+        result[key] = {};
+        fieldNameToConstraints.forEach((constraints, fieldName) => {
+            result[key][fieldName] = constraints.map(serializeFieldConstraintForApi);
+        });
+    });
+    return { fieldConstraintsPerItem: result };
+}
 function serializeItemsPatch(patch) {
     var _a;
     if (patch instanceof ItemsPatchExhaustive) {
-        return Object.assign(Object.assign(Object.assign({ 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) }, serializeRekeyingMap(patch.rekeyingMap)), serializeFieldNamesChanged(patch.fieldNamesChanged)), serializeErrors(patch.errors));
+        return Object.assign(Object.assign(Object.assign(Object.assign({ 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) }, serializeRekeyingMap(patch.rekeyingMap)), serializeFieldNamesChanged(patch.fieldNamesChanged)), serializeErrors(patch.errors)), serializeFieldConstraintsPerItem(patch.fieldConstraintsPerItem));
     }
     else {
-        return Object.assign({ 'items': (0, object_1.fromEntries)(patch.items.entries()), 'itemsDeleted': (_a = patch.itemsDeleted) !== null && _a !== void 0 ? _a : [] }, serializeErrors(patch.errors));
+        return Object.assign(Object.assign({ 'items': (0, object_1.fromEntries)(patch.items.entries()), 'itemsDeleted': (_a = patch.itemsDeleted) !== null && _a !== void 0 ? _a : [] }, serializeErrors(patch.errors)), serializeFieldConstraintsPerItem(patch.fieldConstraintsPerItem));
     }
 }
 exports.serializeItemsPatch = serializeItemsPatch;

package/package.json

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