lucid-extension-sdk 0.0.260 → 0.0.262

package/core/data/fieldspecification.d.ts

@@ -71,6 +71,7 @@ export declare class FormattedPrimaryKey<Fields extends FieldsStructure, Primary
      * ```
      */
     forItem(item: PartialItemType<Fields, PrimaryKey>): string;
+    static serializeList(items: unknown[]): string;
 }
 /**
  * Root type for something that looks like the field list we use to sync with the data-sync service.

package/core/data/fieldspecification.js

@@ -68,7 +68,10 @@ class FormattedPrimaryKey {
      * ```
      */
     forItem(item) {
-        let pk = JSON.stringify(this.elements.map((field) => item[field]));
+        return FormattedPrimaryKey.serializeList(this.elements.map((field) => item[field]));
+    }
+    static serializeList(items) {
+        let pk = JSON.stringify(items);
         pk = pk.substring(1, pk.length - 1);
         return pk;
     }

package/core/rules/conditions.d.ts

@@ -48,4 +48,8 @@ export declare enum ConnectedShapesCondition {
     Between = 14,
     NotBetween = 15
 }
-export type Conditions = TextConditions | ShapeDataConditions | ShapeTypeConditions | ConnectedShapesCondition;
+export declare enum ContainmentConditions {
+    TextContains = 2,
+    TextDoesNotContain = 3
+}
+export type Conditions = TextConditions | ShapeDataConditions | ShapeTypeConditions | ConnectedShapesCondition | ContainmentConditions;

package/core/rules/conditions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectedShapesCondition = exports.ShapeTypeConditions = exports.ShapeDataConditions = exports.TextConditions = exports.ConditionCombination = void 0;
+exports.ContainmentConditions = exports.ConnectedShapesCondition = exports.ShapeTypeConditions = exports.ShapeDataConditions = exports.TextConditions = exports.ConditionCombination = void 0;
 var ConditionCombination;
 (function (ConditionCombination) {
     ConditionCombination["AND"] = "AND";
@@ -56,3 +56,8 @@ var ConnectedShapesCondition;
     ConnectedShapesCondition[ConnectedShapesCondition["Between"] = 14] = "Between";
     ConnectedShapesCondition[ConnectedShapesCondition["NotBetween"] = 15] = "NotBetween";
 })(ConnectedShapesCondition || (exports.ConnectedShapesCondition = ConnectedShapesCondition = {}));
+var ContainmentConditions;
+(function (ContainmentConditions) {
+    ContainmentConditions[ContainmentConditions["TextContains"] = 2] = "TextContains";
+    ContainmentConditions[ContainmentConditions["TextDoesNotContain"] = 3] = "TextDoesNotContain";
+})(ContainmentConditions || (exports.ContainmentConditions = ContainmentConditions = {}));

package/core/rules/conditiontype.d.ts

@@ -3,5 +3,6 @@ export declare enum ConditionType {
     ShapeData = 1,
     Formula = 2,
     ShapeType = 3,
-    ConnectedShapes = 4
+    ConnectedShapes = 4,
+    Containment = 5
 }

package/core/rules/conditiontype.js

@@ -8,4 +8,5 @@ var ConditionType;
     ConditionType[ConditionType["Formula"] = 2] = "Formula";
     ConditionType[ConditionType["ShapeType"] = 3] = "ShapeType";
     ConditionType[ConditionType["ConnectedShapes"] = 4] = "ConnectedShapes";
+    ConditionType[ConditionType["Containment"] = 5] = "Containment";
 })(ConditionType || (exports.ConditionType = ConditionType = {}));

package/dataconnector/actions/patchresponsebody.d.ts

@@ -1,4 +1,4 @@
-import { ItemsPatch } from '../datasourceupdatetypes';
+import { ItemsPatch, SerializedItemsPatch } from '../datasourceupdatetypes';
 export type PatchChangeCollection = {
     collectionId: string;
     itemsPatch: ItemsPatch;
@@ -26,12 +26,7 @@ export type SerializedPatchChange = {
     'syncId': string;
     'collections': {
         'collectionId': string;
-        'itemsPatch': {
-            'items': Record<string, object>;
-            'itemsDeleted': string[];
-        } | {
-            'exhaustiveItems': Record<string, object>;
-        };
+        'itemsPatch': SerializedItemsPatch;
     }[];
 };
 /** Wire format for "Patch" Action responses */

package/dataconnector/dataconnector.d.ts

@@ -3,8 +3,9 @@ import { DataConnectorActionKeys } from './actions/dataconnectoractionkeys';
 import { PatchChange } from './actions/patchresponsebody';
 import { DataConnectorClient } from './dataconnectorclient';
 import { ExpressAppLike, RunDebugServerOptions } from './debugserver';
+import { ItemRekeyer } from './itemrekeyer';
 /** Type to define an action request handler. That is a function that can fulfil an incoming action */
-type ActionRequest<ArgType, BodyType = unknown> = (args: ArgType) => Promise<BodyType>;
+type ActionRequest<ArgType, BodyType = unknown> = (args: ArgType, dataConnectorRequestState: DataConnectorRequestState) => Promise<BodyType>;
 /** Type to define an arbitrary non-action request to this server. Useful for handling webhook responses in the same
  * lambda that handles data actions */
 export type DataConnectorRoute = (args: {
@@ -32,6 +33,10 @@ export declare class DataConnectorRequestError extends Error {
     constructor(status: number, message: string, response: string, statusText?: string | undefined);
     toString(): string;
 }
+export declare class DataConnectorRequestState {
+    itemRekeyer: ItemRekeyer;
+    constructor(itemRekeyer: ItemRekeyer);
+}
 /** Thrown by any APIs the client didn't recognize when parsing */
 export declare class DataConnectorResponseError extends Error {
     response: string;

package/dataconnector/dataconnector.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataConnector = exports.DataConnectorResponseError = exports.DataConnectorRequestError = exports.DataConnectorRunError = void 0;
+exports.DataConnector = exports.DataConnectorResponseError = exports.DataConnectorRequestState = exports.DataConnectorRequestError = exports.DataConnectorRunError = void 0;
 const checks_1 = require("../core/checks");
 const validators_1 = require("../core/validators/validators");
 const action_1 = require("./actions/action");
@@ -8,6 +8,7 @@ const dataconnectoractionkeys_1 = require("./actions/dataconnectoractionkeys");
 const managewebhookresponsebody_1 = require("./actions/managewebhookresponsebody");
 const patchresponsebody_1 = require("./actions/patchresponsebody");
 const debugserver_1 = require("./debugserver");
+const itemrekeyer_1 = require("./itemrekeyer");
 /** Throw this from an action request handler to produce a non-200 response code and not have to return the expected
  * result type */
 class DataConnectorRunError extends Error {
@@ -34,6 +35,12 @@ class DataConnectorRequestError extends Error {
     }
 }
 exports.DataConnectorRequestError = DataConnectorRequestError;
+class DataConnectorRequestState {
+    constructor(itemRekeyer) {
+        this.itemRekeyer = itemRekeyer;
+    }
+}
+exports.DataConnectorRequestState = DataConnectorRequestState;
 /** Thrown by any APIs the client didn't recognize when parsing */
 class DataConnectorResponseError extends Error {
     constructor(message, response) {
@@ -65,6 +72,7 @@ class DataConnector {
     }
     /** Call a defined action handler and gather its serialized response */
     async runAction(url, headers, body) {
+        const state = new DataConnectorRequestState(new itemrekeyer_1.ItemRekeyer());
         const actions = await this.client.parseActions(url, headers, body);
         if (!actions) {
             console.warn('Received bad request', url, headers, body);
@@ -83,10 +91,10 @@ class DataConnector {
                         if (!(action instanceof action_1.DataConnectorAsynchronousAction)) {
                             throw DataConnectorRunError.withMessage(400, `Passing uncredentialed action to ${action.name} which is defined to be asynchronous`);
                         }
-                        return actionResponder(action);
+                        return actionResponder(action, state);
                     }
                     else {
-                        return actionResponder(action);
+                        return actionResponder(action, state);
                     }
                 })();
                 responses.push(await response);

package/dataconnector/datasourceupdatetypes.d.ts

@@ -59,6 +59,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;
+    private readonly _brand;
     constructor(
     /**
      * Items to be added or changed in the collection. Mapping from item serialized primary key to
@@ -72,6 +73,7 @@ export declare class ItemsPatchExhaustive {
     items: Map<string, SerializedFields>;
     rekeyingMap?: Map<string, string | null> | undefined;
     errors?: Map<string, SerializedLucidDictionary> | undefined;
+    private readonly _brand;
     constructor(items: Map<string, SerializedFields>, rekeyingMap?: Map<string, string | null> | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
 }
 export type ItemsPatch = {

package/dataconnector/datasourceupdatetypes.js

@@ -17,6 +17,7 @@ class ItemsPatchInexhaustive {
         this.items = items;
         this.itemsDeleted = itemsDeleted;
         this.errors = errors;
+        this._brand = ItemsPatchInexhaustive;
     }
 }
 exports.ItemsPatchInexhaustive = ItemsPatchInexhaustive;
@@ -25,6 +26,7 @@ class ItemsPatchExhaustive {
         this.items = items;
         this.rekeyingMap = rekeyingMap;
         this.errors = errors;
+        this._brand = ItemsPatchExhaustive;
     }
 }
 exports.ItemsPatchExhaustive = ItemsPatchExhaustive;

package/dataconnector/itemrekeyer.d.ts

@@ -0,0 +1,15 @@
+import { FormattedPrimaryKey } from '../core/data/fieldspecification';
+import { Patch, PatchItems } from './actions/action';
+import { ItemsPatch } from './datasourceupdatetypes';
+export declare class RekeyingMap {
+    map: Map<string, string | null>;
+    constructor(map: Map<string, string | null>);
+    getNewKey(key: string): string;
+    getRecordWithNewKeys(items: PatchItems): PatchItems;
+    getRekeyedPatch(patch: Patch): Patch;
+}
+export declare class ItemRekeyer {
+    private rekeyingMaps;
+    addRekeyingsFor(collectionId: string, itemsPatch: ItemsPatch, primaryKey?: FormattedPrimaryKey<any, string>): void;
+    getRekeyingMap(patch: Patch): RekeyingMap | undefined;
+}

package/dataconnector/itemrekeyer.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemRekeyer = exports.RekeyingMap = void 0;
+const fieldspecification_1 = require("../core/data/fieldspecification");
+const object_1 = require("../core/object");
+const action_1 = require("./actions/action");
+const datasourceupdatetypes_1 = require("./datasourceupdatetypes");
+function calculateRekeyingMap(itemsPatch, primaryKey) {
+    var _a, _b;
+    if (itemsPatch instanceof datasourceupdatetypes_1.ItemsPatchExhaustive) {
+        return itemsPatch.rekeyingMap;
+    }
+    else {
+        if (!primaryKey) {
+            return undefined;
+        }
+        const constPrimaryKey = primaryKey;
+        function primaryKeyIfChanged(oldPrimaryKey, item) {
+            const changedParts = constPrimaryKey.elements.map((field) => item[field]);
+            if (changedParts.find((x) => x !== undefined) === undefined) {
+                // this patch didn't touch the primary key
+                return undefined;
+            }
+            // we might need parts of the old primary key if only some of the primary key fields changed.
+            // As an optimization we could only compute this if at least one of the changedParts is
+            // undefined.
+            const oldParts = JSON.parse(`[${oldPrimaryKey}]`);
+            const newParts = changedParts.map((part, index) => (part !== undefined ? part : oldParts[index]));
+            const newPrimaryKey = fieldspecification_1.FormattedPrimaryKey.serializeList(newParts);
+            if (newPrimaryKey !== oldPrimaryKey) {
+                return newPrimaryKey;
+            }
+            else {
+                return undefined;
+            }
+        }
+        const itemsMap = [...itemsPatch.items.entries()]
+            .map(([key, value]) => [key, primaryKeyIfChanged(key, value)])
+            .filter((x) => x[1] !== undefined);
+        const deletedMap = (_b = (_a = itemsPatch.itemsDeleted) === null || _a === void 0 ? void 0 : _a.map((key) => [key, null])) !== null && _b !== void 0 ? _b : [];
+        const theMap = new Map([...itemsMap, ...deletedMap]);
+        return theMap.size > 0 ? theMap : undefined;
+    }
+}
+class RekeyingMap {
+    constructor(map) {
+        this.map = map;
+    }
+    getNewKey(key) {
+        var _a;
+        return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : key;
+    }
+    getRecordWithNewKeys(items) {
+        return (0, object_1.fromEntries)(Object.entries(items).map(([key, value]) => [this.getNewKey(key), value]));
+    }
+    getRekeyedPatch(patch) {
+        var _a;
+        return new action_1.Patch(patch.id, this.getRecordWithNewKeys(patch.itemsAdded), this.getRecordWithNewKeys(patch.itemsChanged), patch.itemsDeleted.map((key) => this.getNewKey(key)), (_a = patch.itemOrderChanged) === null || _a === void 0 ? void 0 : _a.map(([a, b]) => [this.getNewKey(a), b && this.getNewKey(b)]), patch.syncSourceId, patch.syncCollectionId);
+    }
+}
+exports.RekeyingMap = RekeyingMap;
+class ItemRekeyer {
+    constructor() {
+        this.rekeyingMaps = new Map();
+    }
+    addRekeyingsFor(collectionId, itemsPatch, primaryKey) {
+        var _a;
+        const rekeyingMap = calculateRekeyingMap(itemsPatch, primaryKey);
+        if (rekeyingMap) {
+            const existingMap = this.rekeyingMaps.get(collectionId);
+            const rekeyedExisting = [...((_a = existingMap === null || existingMap === void 0 ? void 0 : existingMap.map.entries()) !== null && _a !== void 0 ? _a : [])].map(([key, value]) => { var _a; return [key, value && ((_a = rekeyingMap.get(value)) !== null && _a !== void 0 ? _a : value)]; });
+            this.rekeyingMaps.set(collectionId, new RekeyingMap(new Map([...rekeyingMap.entries(), ...rekeyedExisting])));
+        }
+    }
+    getRekeyingMap(patch) {
+        return this.rekeyingMaps.get(patch.syncCollectionId);
+    }
+}
+exports.ItemRekeyer = ItemRekeyer;

package/document/documentelement/documentelementtype.d.ts

@@ -13,5 +13,6 @@ export declare enum DocumentElementType {
     TaskCardFieldsConfig = "TaskCardFieldsConfig",
     GeneratorView = "GeneratorView",
     ShapeStylePreset = "ShapeStylePreset",
-    ShapeSpecificDefaultProperties = "ShapeSpecificDefaultProperties"
+    ShapeSpecificDefaultProperties = "ShapeSpecificDefaultProperties",
+    TrackedFormulaLocation = "TrackedFormulaLocation"
 }

package/document/documentelement/documentelementtype.js

@@ -18,4 +18,5 @@ var DocumentElementType;
     DocumentElementType["GeneratorView"] = "GeneratorView";
     DocumentElementType["ShapeStylePreset"] = "ShapeStylePreset";
     DocumentElementType["ShapeSpecificDefaultProperties"] = "ShapeSpecificDefaultProperties";
+    DocumentElementType["TrackedFormulaLocation"] = "TrackedFormulaLocation";
 })(DocumentElementType || (exports.DocumentElementType = DocumentElementType = {}));

package/package.json

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