lucid-extension-sdk 0.0.405 → 0.0.406

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

@@ -18,10 +18,12 @@ export declare const isFieldConstraintType: (x: unknown) => x is FieldConstraint
 export type SerializedFieldConstraint = {
     'Type': FieldConstraintType;
     'Details'?: UnsafeJsonSerializableOrUndefined;
+    'Reason'?: string | undefined;
 };
 export declare const isSerializedFieldConstraint: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Type: (x: unknown) => x is FieldConstraintType;
     Details: (x: unknown) => x is any;
+    Reason: (x: unknown) => x is string | undefined;
 }>;
 export type SerializedFieldDefinition = {
     'Name': string;
@@ -36,6 +38,7 @@ export declare const isSerializedFieldDefinition: (subject: unknown) => subject
     Constraints: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
         Type: (x: unknown) => x is FieldConstraintType;
         Details: (x: unknown) => x is any;
+        Reason: (x: unknown) => x is string | undefined;
     }>[] | undefined;
     SyncSchema: (x: unknown) => x is string | undefined;
     Mapping: (x: unknown) => x is LucidFields[] | SemanticKind[] | undefined;

package/core/data/serializedfield/serializedfielddefinition.js

@@ -22,6 +22,7 @@ exports.isFieldConstraintType = (0, validators_1.enumValidator)(FieldConstraintT
 exports.isSerializedFieldConstraint = (0, validators_1.objectValidator)({
     'Type': (0, validators_1.enumValidator)(FieldConstraintType),
     'Details': (0, validators_1.option)(checks_1.isAny),
+    'Reason': (0, validators_1.option)(checks_1.isString),
 });
 exports.isSerializedFieldDefinition = (0, validators_1.strictObjectValidator)({
     'Name': checks_1.isString,

package/core/sharedcardintegration/cardintegrationdefinitions.d.ts

@@ -105,8 +105,8 @@ export declare const isSerializedExtensionCardFieldDefinition: (subject: unknown
     Type: typeof isSerializedFieldTypeDefinition;
     Constraints: (x: unknown) => x is import("../guards").DestructureGuardedTypeObj<{
         Type: (x: unknown) => x is import("../data/serializedfield/serializedfielddefinition").FieldConstraintType;
-        /** The label to display in the UI */
-        Details: (x: unknown) => x is any;
+        Details: (x: unknown) => x is any; /** If defined, the default value for this field */
+        Reason: (x: unknown) => x is string | undefined;
     }>[] | undefined;
     l: typeof isString;
     d: (x: unknown) => x is string | undefined;

package/data/schemadefinition.d.ts

@@ -8,37 +8,45 @@ import { SerializedSchema } from '../core/data/serializedfield/serializedschema'
 export interface RequiredFieldConstraintDefinition {
     type: FieldConstraintType.REQUIRED;
     value?: undefined;
+    reason?: string | undefined;
 }
 export interface LockedFieldConstraintDefinition {
     type: FieldConstraintType.LOCKED;
     value?: undefined;
+    reason?: string | undefined;
 }
 export interface MinValueFieldConstraintDefinition {
     type: FieldConstraintType.MIN_VALUE;
     value: number;
+    reason?: string | undefined;
 }
 export interface MaxValueFieldConstraintDefinition {
     type: FieldConstraintType.MAX_VALUE;
     value: number;
+    reason?: string | undefined;
 }
 export interface SingleLineFieldConstraintDefinition {
     type: FieldConstraintType.SINGLE_LINE_ONLY;
     value?: undefined;
+    reason?: string | undefined;
 }
 export interface NoWhitespaceFieldConstraintDefinition {
     type: FieldConstraintType.NO_WHITESPACE;
     value?: undefined;
+    reason?: string | undefined;
 }
 export interface UniqueEditFieldConstraintDefinition {
     type: FieldConstraintType.UNIQUE_EDIT;
     value?: undefined;
+    reason?: string | undefined;
 }
 export interface MaxLengthConstraintDefinition {
     type: FieldConstraintType.MAX_LENGTH;
     value: number;
+    reason?: string | undefined;
 }
 export type FieldConstraintDefinition = RequiredFieldConstraintDefinition | LockedFieldConstraintDefinition | MinValueFieldConstraintDefinition | MaxValueFieldConstraintDefinition | SingleLineFieldConstraintDefinition | NoWhitespaceFieldConstraintDefinition | UniqueEditFieldConstraintDefinition | MaxLengthConstraintDefinition;
-export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number): FieldConstraintDefinition;
+export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number, reason?: string): FieldConstraintDefinition;
 export declare function minMaxFieldConstraintValidator(val: unknown): val is FieldConstraintType.MIN_VALUE | FieldConstraintType.MAX_VALUE | FieldConstraintType.MAX_LENGTH;
 export declare const isFieldConstraintDefinition: (x: unknown) => x is {
     type?: FieldConstraintType | undefined;

package/data/schemadefinition.js

@@ -6,25 +6,25 @@ const checks_1 = require("../core/checks");
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 const serializedfielddefinition_1 = require("../core/data/serializedfield/serializedfielddefinition");
 const validators_1 = require("../core/validators/validators");
-function createFieldConstraintDefinition(type, value) {
+function createFieldConstraintDefinition(type, value, reason) {
     switch (type) {
         case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
         case serializedfielddefinition_1.FieldConstraintType.LOCKED:
-            return { type };
+            return Object.assign({ type }, (reason && { reason }));
         case serializedfielddefinition_1.FieldConstraintType.MIN_VALUE:
         case serializedfielddefinition_1.FieldConstraintType.MAX_VALUE:
         case serializedfielddefinition_1.FieldConstraintType.MAX_LENGTH:
             if (value === undefined) {
                 throw new Error('Invalid constraint value');
             }
-            return { type, value };
+            return Object.assign({ type, value }, (reason && { reason }));
         case serializedfielddefinition_1.FieldConstraintType.SINGLE_LINE_ONLY:
         case serializedfielddefinition_1.FieldConstraintType.NO_WHITESPACE:
         case serializedfielddefinition_1.FieldConstraintType.UNIQUE_EDIT:
             if (value !== undefined) {
                 throw new Error('Invalid constraint value');
             }
-            return { type };
+            return Object.assign({ type }, (reason && { reason }));
         default:
             (0, assertnever_1.assertNever)(type);
     }
@@ -44,6 +44,7 @@ function serializeFieldConstraintDefinition(constraint) {
     return {
         'Type': constraint.type,
         'Details': constraint.value,
+        'Reason': constraint.reason,
     };
 }
 exports.serializeFieldConstraintDefinition = serializeFieldConstraintDefinition;
@@ -78,6 +79,7 @@ function parseFieldDefinition(field) {
         name: field['Name'],
         type: (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(field['Type']),
         constraints: (_a = field['Constraints']) === null || _a === void 0 ? void 0 : _a.map((constraint) => {
+            var _a, _b;
             switch (constraint['Type']) {
                 case serializedfielddefinition_1.FieldConstraintType.MIN_VALUE:
                 case serializedfielddefinition_1.FieldConstraintType.MAX_VALUE:
@@ -85,13 +87,17 @@ function parseFieldDefinition(field) {
                     if (!(0, checks_1.isNumber)(constraint['Details'])) {
                         throw new Error('Invalid constraint format');
                     }
-                    return { type: constraint['Type'], value: constraint['Details'] };
+                    return {
+                        type: constraint['Type'],
+                        value: constraint['Details'],
+                        reason: (_a = constraint['Reason']) !== null && _a !== void 0 ? _a : undefined,
+                    };
                 case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
                 case serializedfielddefinition_1.FieldConstraintType.LOCKED:
                 case serializedfielddefinition_1.FieldConstraintType.SINGLE_LINE_ONLY:
                 case serializedfielddefinition_1.FieldConstraintType.NO_WHITESPACE:
                 case serializedfielddefinition_1.FieldConstraintType.UNIQUE_EDIT:
-                    return { type: constraint['Type'] };
+                    return { type: constraint['Type'], reason: (_b = constraint['Reason']) !== null && _b !== void 0 ? _b : undefined };
                 default:
                     throw new Error('Invalid constraint format');
             }

package/dataconnector/datasourceupdatetypes.d.ts

@@ -35,6 +35,7 @@ export type DataSourceRequest = {
 export type SerializedFieldConstraintForApi = {
     'type': FieldConstraintType;
     'details'?: UnsafeJsonSerializableOrUndefined;
+    'reason'?: string | undefined;
 };
 type SerializedFieldDefinitionForApi = {
     'name': string;

package/dataconnector/datasourceupdatetypes.js

@@ -69,6 +69,7 @@ function serializeFieldConstraintForApi(constraint) {
     return {
         'type': constraint.type,
         'details': constraint.value,
+        'reason': constraint.reason,
     };
 }
 /** @ignore */

package/package.json

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