lucid-extension-sdk 0.0.133 → 0.0.134

package/package.json

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

package/sdk/data/branchedcollectionid.d.ts

@@ -0,0 +1,4 @@
+/** @ignore */
+export declare function branchedCollectionId(upstreamId: string): string;
+/** @ignore */
+export declare function patchCollectionIdFromPossibleBranchedCollectionId(branchId: string): string | undefined;

package/sdk/data/branchedcollectionid.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchCollectionIdFromPossibleBranchedCollectionId = exports.branchedCollectionId = void 0;
+/** @ignore */
+function branchedCollectionId(upstreamId) {
+    return upstreamId + '_b';
+}
+exports.branchedCollectionId = branchedCollectionId;
+/** @ignore */
+function patchCollectionIdFromPossibleBranchedCollectionId(branchId) {
+    if (branchId && branchId.endsWith('_b')) {
+        return branchId.substring(0, branchId.length - 2);
+    }
+    return undefined;
+}
+exports.patchCollectionIdFromPossibleBranchedCollectionId = patchCollectionIdFromPossibleBranchedCollectionId;

package/sdk/data/collectionproxy.d.ts

@@ -3,6 +3,7 @@ import { MapProxy } from '../document/mapproxy';
 import { PropertyStoreProxy } from '../document/propertystoreproxy';
 import { EditorClient } from '../editorclient';
 import { DataItemProxy } from './dataitemproxy';
+import { PatchCollectionProxy } from './patchcollectionproxy';
 import { SchemaDefinition } from './schemadefinition';
 /**
  * A collection is a set of data items, each with the same set of fields (though some data items may not have all
@@ -30,6 +31,11 @@ export declare class CollectionProxy extends PropertyStoreProxy {
      * is not a branch
      */
     getBranchedFrom(): CollectionProxy | undefined;
+    /**
+     * @returns information about any changes made locally to the collection that have not been synchronized
+     * with the external data source.
+     */
+    getLocalChanges(): PatchCollectionProxy | undefined;
     /**
      * The data items in this collection, organized by their primary key. The primary key is usually calculated
      * from the content of the data item, but may differ from the expected value in some circumstances, e.g. if

package/sdk/data/collectionproxy.js

@@ -4,7 +4,9 @@ exports.CollectionProxy = void 0;
 const checks_1 = require("../core/checks");
 const mapproxy_1 = require("../document/mapproxy");
 const propertystoreproxy_1 = require("../document/propertystoreproxy");
+const branchedcollectionid_1 = require("./branchedcollectionid");
 const dataitemproxy_1 = require("./dataitemproxy");
+const patchcollectionproxy_1 = require("./patchcollectionproxy");
 const schemadefinition_1 = require("./schemadefinition");
 /**
  * A collection is a set of data items, each with the same set of fields (though some data items may not have all
@@ -51,6 +53,18 @@ class CollectionProxy extends propertystoreproxy_1.PropertyStoreProxy {
         const id = this.properties.get('BranchedFrom');
         return id ? new CollectionProxy(id, this.client) : undefined;
     }
+    /**
+     * @returns information about any changes made locally to the collection that have not been synchronized
+     * with the external data source.
+     */
+    getLocalChanges() {
+        const patchCollectionId = (0, branchedcollectionid_1.patchCollectionIdFromPossibleBranchedCollectionId)(this.id);
+        const original = this.getBranchedFrom();
+        if (!patchCollectionId || !original) {
+            return undefined;
+        }
+        return new patchcollectionproxy_1.PatchCollectionProxy(this.client, this, new CollectionProxy(patchCollectionId, this.client), original);
+    }
     patchItems(patch) {
         var _a, _b;
         const changed = {};

package/sdk/data/patchcollectionproxy.d.ts

@@ -0,0 +1,52 @@
+import { EditorClient } from '../editorclient';
+import { CollectionProxy } from './collectionproxy';
+import { DataItemProxy } from './dataitemproxy';
+export declare class PatchedDataItemProxy extends DataItemProxy {
+    /**
+     * The names of all fields that have been changed locally on this data item and
+     * not yet synced back to the external data source.
+     */
+    readonly changedFields: string[];
+    /**
+     * The original data item, before local changes. You can query the original values
+     * for the changedFields from this data item.
+     */
+    readonly original: DataItemProxy;
+    constructor(primaryKey: string, collection: CollectionProxy, 
+    /**
+     * The names of all fields that have been changed locally on this data item and
+     * not yet synced back to the external data source.
+     */
+    changedFields: string[], 
+    /**
+     * The original data item, before local changes. You can query the original values
+     * for the changedFields from this data item.
+     */
+    original: DataItemProxy, client: EditorClient);
+}
+export declare class PatchCollectionProxy {
+    private readonly client;
+    private readonly branchedCollection;
+    private readonly patchCollection;
+    private readonly originalCollection;
+    /**
+     * Use CollectionProxy.getLocalChanges() to get a PatchCollectionProxy rather
+     * than constructing one directly.
+     */
+    constructor(client: EditorClient, branchedCollection: CollectionProxy, patchCollection: CollectionProxy, originalCollection: CollectionProxy);
+    /**
+     * @returns all data items that have been added to this collection locally, but that
+     * have not yet been synced back to the external data source.
+     */
+    getAddedItems(): DataItemProxy[];
+    /**
+     * @returns all data items that were deleted from this collection locally, but that
+     * have not yet been deleted in the external data source.
+     */
+    getDeletedItems(): DataItemProxy[];
+    /**
+     * @returns all data items that have been changed locally, but that have not
+     * yet been synced back to the external data source.
+     */
+    getChangedItems(): PatchedDataItemProxy[];
+}

package/sdk/data/patchcollectionproxy.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatchCollectionProxy = exports.PatchedDataItemProxy = void 0;
+const dataitemproxy_1 = require("./dataitemproxy");
+class PatchedDataItemProxy extends dataitemproxy_1.DataItemProxy {
+    constructor(primaryKey, collection, 
+    /**
+     * The names of all fields that have been changed locally on this data item and
+     * not yet synced back to the external data source.
+     */
+    changedFields, 
+    /**
+     * The original data item, before local changes. You can query the original values
+     * for the changedFields from this data item.
+     */
+    original, client) {
+        super(primaryKey, collection, client);
+        this.changedFields = changedFields;
+        this.original = original;
+    }
+}
+exports.PatchedDataItemProxy = PatchedDataItemProxy;
+class PatchCollectionProxy {
+    /**
+     * Use CollectionProxy.getLocalChanges() to get a PatchCollectionProxy rather
+     * than constructing one directly.
+     */
+    constructor(client, branchedCollection, patchCollection, originalCollection) {
+        this.client = client;
+        this.branchedCollection = branchedCollection;
+        this.patchCollection = patchCollection;
+        this.originalCollection = originalCollection;
+    }
+    /**
+     * @returns all data items that have been added to this collection locally, but that
+     * have not yet been synced back to the external data source.
+     */
+    getAddedItems() {
+        //Note: We could get this list directly from the metadata collection associated with the
+        //patch collection, but at this time we're not sure we want to expose metadata collections
+        //to the extension API, so this somewhat less-performance-optimal solution seems like the
+        //best overall answer.
+        return this.patchCollection.items.filter((item, primaryKey) => !this.originalCollection.items.get(primaryKey).exists());
+    }
+    /**
+     * @returns all data items that were deleted from this collection locally, but that
+     * have not yet been deleted in the external data source.
+     */
+    getDeletedItems() {
+        //See comment in getAddedItems
+        return this.originalCollection.items.filter((item, primaryKey) => !this.branchedCollection.items.get(primaryKey).exists());
+    }
+    /**
+     * @returns all data items that have been changed locally, but that have not
+     * yet been synced back to the external data source.
+     */
+    getChangedItems() {
+        const changed = [];
+        for (const [primaryKey, patchItem] of this.patchCollection.items) {
+            const original = this.originalCollection.items.get(primaryKey);
+            if (original.exists()) {
+                //Not just using .keys() because we want to filter out undefined values,
+                //which the `for...of` iterator on patchItem.fields (MapProxy) does for us.
+                const changedFields = [];
+                for (const [key] of patchItem.fields) {
+                    changedFields.push(key);
+                }
+                changed.push(new PatchedDataItemProxy(primaryKey, this.branchedCollection, changedFields, original, this.client));
+            }
+        }
+        return changed;
+    }
+}
+exports.PatchCollectionProxy = PatchCollectionProxy;

package/sdk/document/mapproxy.d.ts

@@ -10,6 +10,7 @@ export declare class MapProxy<KEY, VALUE> {
     [Symbol.iterator](): Iterator<[KEY, VALUE]>;
     values(): Generator<VALUE, void, unknown>;
     find(filter: (item: VALUE, key: KEY) => boolean): VALUE | undefined;
+    filter(filter: (item: VALUE, key: KEY) => boolean): VALUE[];
     keys(): KEY[];
     get size(): number;
     get(key: KEY): VALUE;

package/sdk/document/mapproxy.js

@@ -35,6 +35,15 @@ class MapProxy {
         }
         return undefined;
     }
+    filter(filter) {
+        const filtered = [];
+        for (const [key, value] of this) {
+            if (filter(value, key)) {
+                filtered.push(value);
+            }
+        }
+        return filtered;
+    }
     keys() {
         return this.getKeys();
     }