lucid-extension-sdk 0.0.377 → 0.0.379

package/core/assertnever.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use this to assert that a type check is exhaustive at build-time. There should never be a code path that reaches this function.
+ * @param x the value to assert is never reached
+ */
+export declare function assertNever(x: never): never;

package/core/assertnever.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNever = void 0;
+/**
+ * Use this to assert that a type check is exhaustive at build-time. There should never be a code path that reaches this function.
+ * @param x the value to assert is never reached
+ */
+function assertNever(x) {
+    throw new Error(`Assertion failed! Expected assertNever to not be called, but it was called with parameter ${JSON.stringify(x)}`);
+}
+exports.assertNever = assertNever;

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

@@ -13,7 +13,7 @@ export interface SerializedImportedMetadataCollection {
 export declare const isSerializedImportedMetadataCollection: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
     Schema: typeof isSerializedSchema;
-    Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+    Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
 }>;
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export interface SerializedImportedCollection {
@@ -32,12 +32,12 @@ export interface SerializedImportedCollection {
 export declare const isSerializedImportedCollection: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
     Schema: typeof isSerializedSchema;
-    Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+    Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
     UpstreamConfig: typeof isObject;
     Metadata: (val: unknown) => val is Record<string, import("../../guards").DestructureGuardedTypeObj<{
         Name: typeof isString;
         Schema: typeof isSerializedSchema;
-        Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+        Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
     }>>;
     DataIsPartial: (x: unknown) => x is true | undefined;
 }>;
@@ -69,12 +69,12 @@ export declare const isSerializedImportedDataSource: (subject: unknown) => subje
     Collections: (val: unknown) => val is import("../../guards").DestructureGuardedTypeObj<{
         Name: typeof isString;
         Schema: typeof isSerializedSchema;
-        Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+        Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
         UpstreamConfig: typeof isObject;
         Metadata: (val: unknown) => val is Record<string, import("../../guards").DestructureGuardedTypeObj<{
             Name: typeof isString;
             Schema: typeof isSerializedSchema;
-            Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+            Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
         }>>;
         DataIsPartial: (x: unknown) => x is true | undefined;
     }>[];
@@ -109,12 +109,12 @@ export declare const isSerializedPreviewData: (subject: unknown) => subject is i
         Data: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
             Name: typeof isString;
             Schema: typeof isSerializedSchema;
-            Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+            Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
             UpstreamConfig: typeof isObject;
             Metadata: (val: unknown) => val is Record<string, import("../../guards").DestructureGuardedTypeObj<{
                 Name: typeof isString;
                 Schema: typeof isSerializedSchema;
-                Items: (x: unknown) => x is Record<any, Record<any, import("../serializedfield/serializedfields").SerializedFieldType>>;
+                Items: (x: unknown) => x is Record<string | number, Record<string | number, import("../serializedfield/serializedfields").SerializedFieldType>>;
             }>>;
             DataIsPartial: (x: unknown) => x is true | undefined;
         }>;

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

@@ -2,4 +2,4 @@ import { SerializedFields } from './serializedfields';
 export interface SerializedDataItems {
     [primaryKey: string]: SerializedFields;
 }
-export declare const isSerializedDataItems: (x: unknown) => x is Record<any, Record<any, import("./serializedfields").SerializedFieldType>>;
+export declare const isSerializedDataItems: (x: unknown) => x is Record<string | number, Record<string | number, import("./serializedfields").SerializedFieldType>>;

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

@@ -115,4 +115,4 @@ export declare const isSerializedTimeObject: (subject: unknown) => subject is im
 }>;
 export declare function isSerializedFieldType(value: any): value is SerializedFieldType;
 export declare function isSerializedJsonFieldType(value: any): value is SerializedJsonFieldType;
-export declare const isSerializedFields: (x: unknown) => x is Record<any, SerializedFieldType>;
+export declare const isSerializedFields: (x: unknown) => x is Record<string | number, SerializedFieldType>;

package/core/pruners/pruners.d.ts

@@ -10,6 +10,14 @@ import { Pruner } from '../guards';
 export declare function objectPruner(subPruners: {
     [key: string]: Pruner;
 }): Pruner;
+/**
+ * Creates a pruner function that will set ALL object fields that are invalid to undefined.
+ * Use this pruner when an object's key names are not known ahead of time (e.g. UUIDs as object key names).
+ * @param subPruner the pruner to be used on the object fields
+ * @returns  A pruner function that takes data and invalid fields. If data is not an
+ * object, it will return the data as is instead of pruning.
+ */
+export declare function objectOfPruner(subPruner: Pruner): Pruner;
 /**
  * Creates a pruner function that will remove array elements that are invalid.
  * If a sub-pruner is provided, then the elements themselves will be pruned rather

package/core/pruners/pruners.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pruneObjectField = exports.arrayPruner = exports.objectPruner = void 0;
+exports.pruneObjectField = exports.arrayPruner = exports.objectOfPruner = exports.objectPruner = void 0;
 const checks_1 = require("../checks");
 /**
  * Creates a pruner function that will remove object fields that are invalid.
@@ -23,6 +23,26 @@ function objectPruner(subPruners) {
     };
 }
 exports.objectPruner = objectPruner;
+/**
+ * Creates a pruner function that will set ALL object fields that are invalid to undefined.
+ * Use this pruner when an object's key names are not known ahead of time (e.g. UUIDs as object key names).
+ * @param subPruner the pruner to be used on the object fields
+ * @returns  A pruner function that takes data and invalid fields. If data is not an
+ * object, it will return the data as is instead of pruning.
+ */
+function objectOfPruner(subPruner) {
+    return (data, invalidFields, level = 0) => {
+        if ((0, checks_1.isArray)(data) || !(0, checks_1.isObjectUnsafe)(data)) {
+            return data;
+        }
+        const dataToBePruned = Object.assign({}, data);
+        Object.entries(dataToBePruned).forEach(([key, value]) => {
+            dataToBePruned[key] = subPruner(dataToBePruned[key], invalidFields, level + 1, key);
+        });
+        return dataToBePruned;
+    };
+}
+exports.objectOfPruner = objectOfPruner;
 /**
  * Creates a pruner function that will remove array elements that are invalid.
  * If a sub-pruner is provided, then the elements themselves will be pruned rather
@@ -58,12 +78,12 @@ function arrayPruner(subPruner) {
 }
 exports.arrayPruner = arrayPruner;
 /*
- * Creates a pruner function to be passed in with the object pruner that will remove the field if it is invalid.
+ * Creates a pruner function to be passed in with the object/objectOf pruner that will remove the field if it is invalid.
  */
 function pruneObjectField() {
     return (data, invalidFields, level = 0, key = undefined) => {
         var _a;
-        // When this is called as a part of objectPruner, level will be atleast 1
+        // When this is called as a part of objectPruner/objectOfPruner, level will be atleast 1
         if ((0, checks_1.isArray)(data) || level <= 0) {
             return data;
         }

package/core/validators/validators.d.ts

@@ -103,12 +103,19 @@ export declare function strictObjectValidator<T extends {
 }>(validatorStructure: T): (subject: unknown) => subject is DestructureGuardedTypeObj<T>;
 export declare function recordValidator<K extends string, V>(keyList: K[], valueValidator: Validator<V>): (x: unknown) => x is Record<K, V>;
 export declare function typedRecordValidator<K extends string | number | symbol, V>(keyValidator: Validator<K>, valueValidator: Validator<V>): (x: unknown) => x is Record<K, V>;
-export declare function objectOfValidator<T>(subValidator: Validator<T>): (x: unknown) => x is Record<any, T>;
+/**
+ * Validates a structure that is an object of a specific type (defined by the subValidator).
+ * @param valueValidator The validator to be used on the object fields
+ * @param keyValidator Optional validator to be used on the object keys. If not provided, all key types are validated.
+ */
+export declare function objectOfValidator<T, K extends string | number | symbol = string>(valueValidator: Validator<T>, keyValidator?: Validator<K>): (x: unknown) => x is Record<K, T>;
 /**
  * This validator functions the same as {@link objectOfValidator}, with the option of passing in a map
  * which will track all of the fields that were found to be invalid.
+ * @param valueValidator The validator to be used on the object fields
+ * @param keyValidator Optional validator to be used on the object keys. If not provided, keys are not validated and asserted to be strings.
  */
-export declare function objectOfValidatorWithInvalidFieldTracking<T>(subValidator: ValidatorWithTracking<T>): (subject: unknown, invalidFields?: Map<number, unknown[]>, level?: number) => subject is Record<any, T>;
+export declare function objectOfValidatorWithInvalidFieldTracking<T, K extends string | number | symbol = string>(valueValidator: ValidatorWithTracking<T>, keyValidator?: ValidatorWithTracking<K>): (subject: unknown, invalidFields?: Map<number, unknown[]>, level?: number) => subject is Record<K, T>;
 /**
  * Create a validator which allows the target to be either null or satisfy the
  * sub-validator.

package/core/validators/validators.js

@@ -254,20 +254,29 @@ function typedRecordValidator(keyValidator, valueValidator) {
     };
 }
 exports.typedRecordValidator = typedRecordValidator;
-function objectOfValidator(subValidator) {
+/**
+ * Validates a structure that is an object of a specific type (defined by the subValidator).
+ * @param valueValidator The validator to be used on the object fields
+ * @param keyValidator Optional validator to be used on the object keys. If not provided, all key types are validated.
+ */
+function objectOfValidator(valueValidator, keyValidator = (key) => true) {
     return (x) => {
         if ((0, checks_1.isArray)(x) || !(0, checks_1.isObject)(x)) {
             return false;
         }
-        return Object.values(x).every((val) => subValidator(val));
+        return Object.entries(x).every(([key, val]) => {
+            return keyValidator(key) && valueValidator(val);
+        });
     };
 }
 exports.objectOfValidator = objectOfValidator;
 /**
  * This validator functions the same as {@link objectOfValidator}, with the option of passing in a map
  * which will track all of the fields that were found to be invalid.
+ * @param valueValidator The validator to be used on the object fields
+ * @param keyValidator Optional validator to be used on the object keys. If not provided, keys are not validated and asserted to be strings.
  */
-function objectOfValidatorWithInvalidFieldTracking(subValidator) {
+function objectOfValidatorWithInvalidFieldTracking(valueValidator, keyValidator = (key) => true) {
     return (subject, invalidFields, level = 0) => {
         var _a;
         if ((0, checks_1.isArray)(subject) || !(0, checks_1.isObjectUnsafe)(subject)) {
@@ -276,7 +285,9 @@ function objectOfValidatorWithInvalidFieldTracking(subValidator) {
         let valid = true;
         const invalidList = [];
         Object.entries(subject).forEach(([key, val]) => {
-            if (!subValidator(val, invalidFields, level + 1)) {
+            const isKeyValid = keyValidator(key, invalidFields, level + 1);
+            const isValueValid = valueValidator(val, invalidFields, level + 1);
+            if (!isKeyValid || !isValueValid) {
                 invalidList.push([key, val]);
                 valid = false;
             }

package/data/schemadefinition.d.ts

@@ -38,6 +38,7 @@ export interface MaxLengthConstraintDefinition {
     value: number;
 }
 export type FieldConstraintDefinition = RequiredFieldConstraintDefinition | LockedFieldConstraintDefinition | MinValueFieldConstraintDefinition | MaxValueFieldConstraintDefinition | SingleLineFieldConstraintDefinition | NoWhitespaceFieldConstraintDefinition | UniqueEditFieldConstraintDefinition | MaxLengthConstraintDefinition;
+export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number): 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

@@ -1,10 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchemaDefinition = exports.parseFieldDefinition = exports.serializeSchemaDefinition = exports.serializeFieldDefinition = exports.serializeFieldConstraintDefinition = exports.isFieldConstraintDefinition = exports.minMaxFieldConstraintValidator = void 0;
+exports.parseSchemaDefinition = exports.parseFieldDefinition = exports.serializeSchemaDefinition = exports.serializeFieldDefinition = exports.serializeFieldConstraintDefinition = exports.isFieldConstraintDefinition = exports.minMaxFieldConstraintValidator = exports.createFieldConstraintDefinition = void 0;
+const assertnever_1 = require("../core/assertnever");
 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) {
+    switch (type) {
+        case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
+        case serializedfielddefinition_1.FieldConstraintType.LOCKED:
+            return { type };
+        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 };
+        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 };
+        default:
+            (0, assertnever_1.assertNever)(type);
+    }
+}
+exports.createFieldConstraintDefinition = createFieldConstraintDefinition;
 function minMaxFieldConstraintValidator(val) {
     return (val === serializedfielddefinition_1.FieldConstraintType.MIN_VALUE ||
         val === serializedfielddefinition_1.FieldConstraintType.MAX_VALUE ||

package/dataconnector/actions/serializedpatchtypes.d.ts

@@ -2,10 +2,10 @@ import { isString, isUnknown } from '../../core/checks';
 import { isSerializedFieldTypeDefinition } from '../../core/data/fieldtypedefinition/fieldtypedefinition';
 import { GuardToType } from '../../core/guards';
 export declare const patchItemValidator: (subject: unknown) => subject is import("../../core/guards").DestructureGuardedTypeObj<{
-    itemsAdded: (x: unknown) => x is Record<any, {
+    itemsAdded: (x: unknown) => x is Record<string, {
         [key: string]: unknown;
     }>;
-    itemsChanged: (x: unknown) => x is Record<any, {
+    itemsChanged: (x: unknown) => x is Record<string, {
         [key: string]: unknown;
     }>;
     itemsDeleted: (p1: unknown) => p1 is string[];
@@ -43,10 +43,10 @@ export declare const patchSchemaValidator: (subject: unknown) => subject is impo
 }>;
 export type SerializedSchemaPatch = GuardToType<typeof patchSchemaValidator>;
 export declare const patchValidator: (x: unknown) => x is import("../../core/guards").DestructureGuardedTypeObj<{
-    itemsAdded: (x: unknown) => x is Record<any, {
+    itemsAdded: (x: unknown) => x is Record<string, {
         [key: string]: unknown;
     }>;
-    itemsChanged: (x: unknown) => x is Record<any, {
+    itemsChanged: (x: unknown) => x is Record<string, {
         [key: string]: unknown;
     }>;
     itemsDeleted: (p1: unknown) => p1 is string[];

package/package.json

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