lucid-extension-sdk 0.0.299 → 0.0.301

package/commandtypes.d.ts

@@ -715,6 +715,10 @@ export type AddCardIntegrationQuery = {
     'gdc': string;
     /** If specified, import modal settings */
     'im'?: {
+        /** Import Modal Heading */
+        'imh'?: string;
+        /** Use Isolated Search Bar */
+        'uisbui'?: boolean;
         /** Get search fields action */
         'gsf': string;
         /** Search action */

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -87,6 +87,12 @@ class LucidCardIntegrationRegistry {
                     'i': LucidCardIntegrationRegistry.nextHookName(),
                     'os': importModal.onSetup ? LucidCardIntegrationRegistry.nextHookName() : undefined,
                 };
+                if (importModal.importModalHeading) {
+                    serialized['im']['imh'] = importModal.importModalHeading;
+                }
+                if (importModal.useIsolatedSearchBarUI) {
+                    serialized['im']['uisbui'] = importModal.useIsolatedSearchBarUI;
+                }
                 client.registerAction(serialized['im']['gsf'], async ({ 's': searchSoFar }) => {
                     const result = await importModal.getSearchFields(new Map(searchSoFar));
                     return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);

package/core/cardintegration/lucidcardintegrationstandardimportmodal.d.ts

@@ -33,6 +33,11 @@ import { ExtensionCardFieldDefinition } from './cardintegrationdefinitions';
  *
  */
 export interface LucidCardIntegrationStandardImportModal {
+    /**
+     * Heading used in the import modal.
+     */
+    importModalHeading?: string;
+    useIsolatedSearchBarUI?: boolean;
     getSearchFields: (searchSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardFieldDefinition[]>;
     search: (fields: Map<string, SerializedFieldType>) => Promise<SearchResult>;
     import: (primaryKeys: string[], searchFields: Map<string, SerializedFieldType>) => Promise<ImportResult>;

package/dataconnector/actions/getmergedpatches.d.ts

@@ -0,0 +1,14 @@
+import { ItemPatch } from './patch';
+/**
+ * Take an optional cumulative patch "patch up to this point" and combine it with the new patch this is being
+ * applied.
+ *
+ * Note that this function assumes that the patches are both being applied to the exact same collection. We do
+ * not validate that this is the case, and breaking that assumption could result in unexpected bad behavior. That
+ * needs to have been checked or otherwise contrained by the calling code.
+ *
+ * @param cumulativePatch The previous patches merged in to a single patch up to this point
+ * @param newPatch The new patches which are now being applied at this point
+ * @returns The combined patch
+ */
+export declare function getMergedPatches(prevCumulativePatch: ItemPatch | undefined, newPatch: ItemPatch): ItemPatch;

package/dataconnector/actions/getmergedpatches.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMergedPatches = void 0;
+const object_1 = require("../../core/object");
+const patch_1 = require("./patch");
+/**
+ * A utility function that hasn't been moved in to the lucid-extension-sdk yet. It takes something that satisfies the
+ * map interface, `mapLike`, and finds if `maplike` contains the existing key. If it does, it returns the key. If it
+ * does not, it creates a new instance of the key value from the `fallback` function, adds it to the map, and then
+ * returns that.
+ *
+ * @param mapLike The map-like object we are getting/setting on.
+ * @param key The key we are looking up.
+ * @param fallback A function with provides a default value for when the map doesn't have the given key.
+ * @returns The value of the map at the given key, having created the entry in the map if it didn't already exist.
+ */
+function setIfNotPresentAndGet(mapLike, key, fallback) {
+    const valIfPresent = mapLike.get(key);
+    if (valIfPresent !== undefined) {
+        return valIfPresent;
+    }
+    const newVal = fallback();
+    mapLike.set(key, newVal);
+    return newVal;
+}
+/**
+ * Turn an array of raw moves into an equivalent set of connected chains. It also returns utility maps which track
+ * which elements end up in the tail of which returned chains (`backMapping`) and which anchors each chain starts with,
+ * `anchorMapping`.
+ *
+ * @param itemOrderChanged The original sequence of raw moves that we are consolidating into chains.
+ * @returns an object containing the relevant chains and some lookup utility values. The contents of the response are:
+ *
+ * connectedChains: an array of chains representing the original reordering as described by the ConnectedChain type.
+ * backMapping: An array from primary keys to the index of the chains that contain those keys in their tails. Note that
+ *              the arrays are in reverse order, largest indexes first.
+ * anchorMapping: An array from priamry keys to the index of the chains that have the key as their anchor. These are
+ *                also in reverse order, largest indexes first.
+ *
+ */
+function getConnectedChains(itemOrderChanged) {
+    const connectedChains = [];
+    const backMapping = new Map();
+    const anchorMapping = new Map();
+    let lastMoved = undefined;
+    let currentTail = new Set();
+    let currentAnchor = undefined;
+    itemOrderChanged === null || itemOrderChanged === void 0 ? void 0 : itemOrderChanged.forEach(([moved, next]) => {
+        if (lastMoved !== next) {
+            if (currentAnchor !== undefined) {
+                setIfNotPresentAndGet(anchorMapping, currentAnchor, () => []).unshift(connectedChains.length);
+                connectedChains.push({
+                    anchor: currentAnchor,
+                    tail: currentTail,
+                    anchorBlockers: new Set([...currentTail]
+                        .filter((tailKey) => anchorMapping.has(tailKey))
+                        .map((key) => { var _a, _b; return (_b = (_a = anchorMapping.get(key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : -1; })),
+                });
+            }
+            currentAnchor = next;
+            currentTail = new Set();
+        }
+        currentTail.add(moved);
+        setIfNotPresentAndGet(backMapping, moved, () => []).unshift(connectedChains.length);
+        lastMoved = moved;
+    });
+    if (lastMoved !== undefined) {
+        if (currentAnchor !== undefined) {
+            setIfNotPresentAndGet(anchorMapping, currentAnchor, () => []).unshift(connectedChains.length);
+            connectedChains.push({
+                anchor: currentAnchor,
+                tail: currentTail,
+                anchorBlockers: new Set([...currentTail]
+                    .filter((tailKey) => anchorMapping.has(tailKey))
+                    .map((key) => { var _a, _b; return (_b = (_a = anchorMapping.get(key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : -1; })),
+            });
+        }
+    }
+    return { connectedChains, backMapping, anchorMapping };
+}
+/**
+ * Take an array of connected chains (plus auxillary maps for efficient access) and remove all possible moves involving
+ * the given key. Note that if the key was used as an anchor for a chain somewhere, we can't delete references to it
+ * from that chain or any chains before, because we don't necessarily know where the key was moved from when used as
+ * an anchor.
+ *
+ * @param connectedChains The connected chains of the type returned from getConnectedChains
+ * @param backMapping The map from the non-anchor elements of the chains to which chains they appear in in connected chains
+ * @param anchorMapping The map from the anchor elements of the chains to the chains of which they are anchor
+ *
+ * @returns Doesn't explicitly return anything, but does modify all input parameters in place to do the expected
+ * update.
+ */
+function trimChains(connectedChains, backMapping, anchorMapping, key) {
+    var _a, _b, _c;
+    const keyBarrier = (_b = (_a = anchorMapping.get(key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : -1;
+    const backMappingList = (_c = backMapping.get(key)) !== null && _c !== void 0 ? _c : [];
+    [...backMappingList].every((previousInstanceRow) => {
+        if (previousInstanceRow < keyBarrier) {
+            return false;
+        }
+        connectedChains[previousInstanceRow].tail.delete(key);
+        backMappingList.shift();
+        return true;
+    });
+}
+/**
+ * Our goal when combining moves is to minimize the number of chains produced. When we are adding new moves, we
+ * thus first search for existing chains they can be inserted into. It sometimes happens that there is a target
+ * chain that we can add the new move to, but that the new move cannot "reach" the target chain because one of the
+ * intermediate chains block the insertion (the move operators do not commute and cannot be modified to have an
+ * equivalent move). When that happens, it is sometimes possible to instead move the target chain down through the
+ * list of chains to a location where the new move actually can be inserted correctly. This function is about moving
+ * the chains around so that the insertion can be performed consistently, if possible.
+ *
+ *
+ * @param connectedChains See the description on `getConnectedChains`.
+ * @param backMapping See the description on `getConnectedChains`.
+ * @param anchorMapping See the description on `getConnectedChains`.
+ * @param mostRecentBlocker The index of the chain that stops the new move from being added.
+ * @param targetIndex The index of the chain that we are trying to insert the new move into.
+ * @returns An object containing the target index of the actual chain that we can insert the move into, if it exists. If
+ * we can not insert the move into the original target, it returns undefined. Note that if `newTargetIndex` is different
+ * from `targetIndex`, this function has changed `connectedChains`, `backMapping` and `anchorMapping` in place
+ * in order to actually move the target.
+ */
+function rearrangeAroundBlockersIfPossible(connectedChains, backMapping, anchorMapping, mostRecentBlocker, targetIndex) {
+    if (mostRecentBlocker <= targetIndex) {
+        return { newTargetIndex: targetIndex };
+    }
+    if (targetIndex < 0 || targetIndex >= connectedChains.length) {
+        return undefined;
+    }
+    let blocked = false;
+    for (let i = targetIndex + 1; !blocked && i <= mostRecentBlocker; i++) {
+        blocked = connectedChains[i].anchorBlockers.has(targetIndex);
+    }
+    if (blocked) {
+        return undefined;
+    }
+    function indexMapper(index) {
+        if (index < targetIndex || index > mostRecentBlocker) {
+            return index;
+        }
+        if (index === targetIndex) {
+            return mostRecentBlocker;
+        }
+        return index - 1;
+    }
+    connectedChains.forEach((chain) => {
+        chain.anchorBlockers = new Set([...chain.anchorBlockers].map(indexMapper));
+    });
+    [...backMapping].forEach(([key, rows]) => {
+        backMapping.set(key, rows.map(indexMapper));
+    });
+    [...anchorMapping].forEach(([anchorKey, rows]) => {
+        anchorMapping.set(anchorKey, rows.map(indexMapper));
+    });
+    const targetRow = connectedChains.splice(targetIndex, 1)[0];
+    connectedChains.splice(mostRecentBlocker, 0, targetRow);
+    return { newTargetIndex: mostRecentBlocker };
+}
+/**
+ * Function which modifies the chain information to add a new chain to the current list. Note this this aggresively
+ * tries to combine a new chain with existing chains, if possible, but will add a new chain if necessary.
+ *
+ * @param connectedChains See the description on `getConnectedChains`.
+ * @param backMapping See the description on `getConnectedChains`.
+ * @param anchorMapping See the description on `getConnectedChains`.
+ * @param anchor The anchor for the new chain.
+ * @param chain The tail for the new chain.
+ * @returns Nothing, but modifies `connectedChains`, `backMapping` and `anchorMapping` in place to incorporate the
+ * new chain.
+ */
+function insertNewChain(connectedChains, backMapping, anchorMapping, anchor, chain) {
+    var _a, _b, _c, _d;
+    const anchorBlockers = new Set([...chain].filter((key) => anchorMapping.has(key)).map((key) => { var _a, _b; return (_b = (_a = anchorMapping.get(key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : -1; }));
+    const anchorMergeTarget = (_b = (_a = anchorMapping.get(anchor)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : -1;
+    const nonAnchorMergeTarget = anchor !== null ? (_d = (_c = backMapping.get(anchor)) === null || _c === void 0 ? void 0 : _c[0]) !== null && _d !== void 0 ? _d : -1 : -1;
+    const targetIndex = Math.max(anchorMergeTarget, nonAnchorMergeTarget);
+    const isAnchorTarget = targetIndex !== nonAnchorMergeTarget;
+    const mostRecentBlocker = Math.max(...anchorBlockers);
+    const newTargetIfPossible = rearrangeAroundBlockersIfPossible(connectedChains, backMapping, anchorMapping, mostRecentBlocker, targetIndex);
+    function backLinkKeys(chain, index) {
+        chain.forEach((chainKey) => setIfNotPresentAndGet(backMapping, chainKey, () => []).unshift(index));
+    }
+    if (!newTargetIfPossible || newTargetIfPossible.newTargetIndex < 0) {
+        connectedChains.push({ anchor, tail: chain, anchorBlockers });
+        const endingChainIndex = connectedChains.length - 1;
+        setIfNotPresentAndGet(anchorMapping, anchor, () => []).unshift(endingChainIndex);
+        backLinkKeys(chain, endingChainIndex);
+        return;
+    }
+    const { newTargetIndex } = newTargetIfPossible;
+    const newChain = isAnchorTarget ? new Set([...chain]) : new Set();
+    const targetChain = connectedChains[newTargetIndex];
+    targetChain.tail.forEach((chainKey) => {
+        newChain.delete(chainKey);
+        newChain.add(chainKey);
+        if (!isAnchorTarget && chainKey === anchor) {
+            chain.forEach((insertedKey) => {
+                newChain.delete(insertedKey);
+                newChain.add(insertedKey);
+            });
+        }
+    });
+    connectedChains[newTargetIndex].tail = newChain;
+    backLinkKeys(newChain, newTargetIndex);
+}
+/**
+ * This function takes an array of new item order moves and appends them to the end of the existing chains,
+ * aggressively merging chains if possible.
+ *
+ * @param connectedChains See the description on `getConnectedChains`.
+ * @param backMapping See the description on `getConnectedChains`.
+ * @param anchorMapping See the description on `getConnectedChains`.
+ * @param newItemOrderChanged The new set of moves from the new patch that we are adding it.
+ * @returns Nothing, but modifies `connectedChains`, `backMapping` and `anchorMapping` in place to incorporate the
+ * new moves.
+ */
+function mergeIntoChains(connectedChains, backMapping, anchorMapping, newItemOrderChanged) {
+    var _a, _b;
+    // Pop off the last available chain, because we need to continue to growth as thought it started up again clean
+    // with the next item order. The logic changes are to account for the fact that keys might now be duplicated.
+    const lastChain = connectedChains.pop();
+    lastChain === null || lastChain === void 0 ? void 0 : lastChain.tail.forEach((keyInLastChain) => { var _a; return (_a = backMapping.get(keyInLastChain)) === null || _a === void 0 ? void 0 : _a.shift(); });
+    (lastChain === null || lastChain === void 0 ? void 0 : lastChain.anchor) !== undefined && ((_a = anchorMapping.get(lastChain.anchor)) === null || _a === void 0 ? void 0 : _a.shift());
+    let currentAnchor = lastChain === null || lastChain === void 0 ? void 0 : lastChain.anchor;
+    let currentChain = (_b = lastChain === null || lastChain === void 0 ? void 0 : lastChain.tail) !== null && _b !== void 0 ? _b : new Set();
+    let lastMoved = [...currentChain][currentChain.size - 1];
+    newItemOrderChanged === null || newItemOrderChanged === void 0 ? void 0 : newItemOrderChanged.forEach(([key, pred]) => {
+        if (lastMoved !== pred) {
+            if (currentAnchor !== undefined) {
+                insertNewChain(connectedChains, backMapping, anchorMapping, currentAnchor, currentChain);
+            }
+            currentAnchor = pred;
+            currentChain = new Set();
+        }
+        if (key !== currentAnchor) {
+            trimChains(connectedChains, backMapping, anchorMapping, key);
+        }
+        // Need to delete the key if it is already in the chain so that it gets moved to the end by the add, because
+        // order matters.
+        currentChain.delete(key);
+        currentChain.add(key);
+        lastMoved = key;
+    });
+    if (lastMoved !== undefined) {
+        // Need to delete the key if it is already in the chain so that it gets moved to the end by the add, because
+        // order matters.
+        currentChain.delete(lastMoved);
+        currentChain.add(lastMoved);
+        if (currentAnchor !== undefined) {
+            insertNewChain(connectedChains, backMapping, anchorMapping, currentAnchor, currentChain);
+        }
+    }
+}
+/**
+ * Take an optional cumulative patch "patch up to this point" and combine it with the new patch this is being
+ * applied.
+ *
+ * Note that this function assumes that the patches are both being applied to the exact same collection. We do
+ * not validate that this is the case, and breaking that assumption could result in unexpected bad behavior. That
+ * needs to have been checked or otherwise contrained by the calling code.
+ *
+ * @param cumulativePatch The previous patches merged in to a single patch up to this point
+ * @param newPatch The new patches which are now being applied at this point
+ * @returns The combined patch
+ */
+function getMergedPatches(prevCumulativePatch, newPatch) {
+    if (prevCumulativePatch === undefined) {
+        return newPatch;
+    }
+    // Copy the patch so we can change it in place
+    const itemsDeleted = new Set(prevCumulativePatch.itemsDeleted);
+    const itemsAdded = new Map(Object.entries(prevCumulativePatch.itemsAdded));
+    const itemsChanged = new Map(Object.entries(prevCumulativePatch.itemsChanged));
+    const { connectedChains, backMapping, anchorMapping } = getConnectedChains(prevCumulativePatch.itemOrderChanged);
+    // Merge items changed in the new patch into the cumulative patch
+    for (const [changedKey, changes] of Object.entries(newPatch.itemsChanged)) {
+        if (itemsDeleted.has(changedKey)) {
+            continue;
+        }
+        if (itemsAdded.has(changedKey)) {
+            itemsAdded.set(changedKey, Object.assign(Object.assign({}, itemsAdded.get(changedKey)), changes));
+        }
+        else {
+            itemsChanged.set(changedKey, Object.assign(Object.assign({}, itemsChanged.get(changedKey)), changes));
+        }
+    }
+    // Add items added by the new patch to the cumulative patch
+    for (const [addedKey, addedData] of Object.entries(newPatch.itemsAdded)) {
+        itemsDeleted.delete(addedKey);
+        itemsChanged.delete(addedKey);
+        itemsAdded.set(addedKey, addedData);
+    }
+    mergeIntoChains(connectedChains, backMapping, anchorMapping, newPatch.itemOrderChanged);
+    // Clear out any items deleted in upstream patches, or actively target pre-existing items for deletion
+    const deletedItems = new Set(newPatch.itemsDeleted);
+    for (const deletedKey of deletedItems) {
+        if (itemsAdded.has(deletedKey)) {
+            itemsAdded.delete(deletedKey);
+        }
+        else {
+            itemsChanged.delete(deletedKey);
+        }
+        itemsDeleted.add(deletedKey);
+        trimChains(connectedChains, backMapping, anchorMapping, deletedKey);
+    }
+    const itemOrderChanged = [];
+    connectedChains.forEach(({ anchor, tail }) => {
+        let lastNext = anchor;
+        tail.forEach((chainEntry) => {
+            if (!deletedItems.has(chainEntry)) {
+                itemOrderChanged.push([chainEntry, lastNext]);
+                lastNext = chainEntry;
+            }
+        });
+    });
+    return new patch_1.ItemPatch(prevCumulativePatch.id, (0, object_1.fromEntries)(itemsAdded), (0, object_1.fromEntries)(itemsChanged), [...itemsDeleted], itemOrderChanged.length === 0 ? undefined : itemOrderChanged, prevCumulativePatch.syncSourceId, prevCumulativePatch.syncCollectionId);
+}
+exports.getMergedPatches = getMergedPatches;

package/dataconnector/actions/patch.d.ts

@@ -59,6 +59,7 @@ export declare class ThirdPartyColumn {
     toJSON(): object;
     static deserialize(data: SerializedThirdPartyColumn): ThirdPartyColumn;
 }
+export declare function areThirdPartyColumnsEqual(a: ThirdPartyColumn, b: ThirdPartyColumn): boolean;
 export declare class ThirdPartyColumnPatch {
     readonly name?: string | undefined;
     readonly fieldType?: FieldTypeDefinition | undefined;
@@ -67,6 +68,7 @@ export declare class ThirdPartyColumnPatch {
     toJSON(): object;
     static deserialize(data: SerializedThirdPartyColumnPatch): ThirdPartyColumnPatch;
 }
+export declare function areThirdPartyColumnPatchesEqual(a: ThirdPartyColumnPatch, b: ThirdPartyColumnPatch): boolean;
 export declare class SchemaPatch extends Patch {
     /** Mapping of item primary keys to new items introduced by Lucid */
     columnsAdded: ThirdPartyColumn[];

package/dataconnector/actions/patch.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaPatchParser = exports.SchemaPatch = exports.ThirdPartyColumnPatch = exports.ThirdPartyColumn = exports.itemPatchParser = exports.ItemPatch = exports.genericPatchParser = exports.Patch = void 0;
+exports.schemaPatchParser = exports.SchemaPatch = exports.areThirdPartyColumnPatchesEqual = exports.ThirdPartyColumnPatch = exports.areThirdPartyColumnsEqual = exports.ThirdPartyColumn = exports.itemPatchParser = exports.ItemPatch = exports.genericPatchParser = exports.Patch = void 0;
 const fieldtypedefinition_1 = require("../../core/data/fieldtypedefinition/fieldtypedefinition");
 const patchresponsebody_1 = require("./patchresponsebody");
 const serializedpatchtypes_1 = require("./serializedpatchtypes");
@@ -99,6 +99,10 @@ class ThirdPartyColumn {
     }
 }
 exports.ThirdPartyColumn = ThirdPartyColumn;
+function areThirdPartyColumnsEqual(a, b) {
+    return a.name === b.name && (0, fieldtypedefinition_1.fieldTypesEqual)(a.fieldType, b.fieldType);
+}
+exports.areThirdPartyColumnsEqual = areThirdPartyColumnsEqual;
 class ThirdPartyColumnPatch {
     constructor(name, fieldType) {
         this.name = name;
@@ -120,6 +124,12 @@ class ThirdPartyColumnPatch {
     }
 }
 exports.ThirdPartyColumnPatch = ThirdPartyColumnPatch;
+function areThirdPartyColumnPatchesEqual(a, b) {
+    return (a.name === b.name &&
+        ((a.fieldType === undefined && b.fieldType === undefined) ||
+            (a.fieldType !== undefined && b.fieldType !== undefined && (0, fieldtypedefinition_1.fieldTypesEqual)(a.fieldType, b.fieldType))));
+}
+exports.areThirdPartyColumnPatchesEqual = areThirdPartyColumnPatchesEqual;
 class SchemaPatch extends Patch {
     constructor(
     /** The id of the patch */

package/dataconnector/actions/patch.test.d.ts

@@ -0,0 +1,27 @@
+import { SerializedSchema } from '../../core/data/serializedfield/serializedschema';
+import { ItemPatch, Patch } from './patch';
+export declare function uuid(): string;
+export declare function getRandomEmptyPatch(optSyncSourceId?: string, optSyncCollectionId?: string): Patch;
+type Range = number | [number, number];
+export interface RandomPatchSettings {
+    previousDependency: number;
+    deleteFrequency: number;
+    addedIds: Range;
+    changedIds: Range;
+    changeDensity: number;
+    deletedIds: Range;
+    schema: SerializedSchema | Range;
+    orderedAnchors?: undefined | Range;
+}
+export declare function getRandomItemPatch(settings: RandomPatchSettings, previousPatches: ItemPatch[], optSyncSourceId?: string, optSyncCollectionId?: string): ItemPatch;
+/**
+ * When we use raw JSON.stringify on objects, it can depend in subtle ways how the object was created. This
+ * function is intended to make the resulting string depend only on the logical contents so as to minimize unneeded
+ * refreshes.
+ *
+ * @param data The Sheet-type to stringify
+ * @returns A custom stringified object
+ */
+export declare function orderedStringify(data: unknown): string;
+export declare function patchesEqual(patchA: Patch, patchB: Patch): boolean;
+export {};

package/dataconnector/actions/patch.test.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchesEqual = exports.orderedStringify = exports.getRandomItemPatch = exports.getRandomEmptyPatch = exports.uuid = void 0;
+const checks_1 = require("../../core/checks");
+const datasourceutils_1 = require("../../core/data/datasource/datasourceutils");
+const spreadsheetpossibledatatypes_1 = require("../../core/data/datasource/spreadsheetpossibledatatypes");
+const serializedschema_1 = require("../../core/data/serializedfield/serializedschema");
+const patch_1 = require("./patch");
+function arraysEqualWith(areEqual) {
+    return (a, b) => {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((aItem, index) => areEqual(aItem, b[index]));
+    };
+}
+function recordsEqualWith(areEqual) {
+    return (a, b) => {
+        for (const key in a) {
+            if (!b.hasOwnProperty(key) || !areEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        for (const key in b) {
+            if (!a.hasOwnProperty(key)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+function arraySetsEqual(deletedA, deletedB) {
+    const setA = new Set(deletedA);
+    const setB = new Set(deletedB);
+    if (setA.size !== setB.size) {
+        return false;
+    }
+    setB.forEach((b) => setA.delete(b));
+    return setA.size === 0;
+}
+function uuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => (c == 'x' ? Math.floor(Math.random() * 16) : Math.floor(Math.random() * 4) + 8).toString(16));
+}
+exports.uuid = uuid;
+function randomWordChar() {
+    const upperCaseChar = (0, datasourceutils_1.alphabetize)(Math.floor(Math.random() * 26));
+    if (Math.random() > 0.5) {
+        return upperCaseChar;
+    }
+    return upperCaseChar.toLowerCase();
+}
+function randomWord() {
+    return Array.from({ length: 10 }, randomWordChar).join('');
+}
+function randomWordOrPrevious(frequency, previous) {
+    const previousArray = [...previous];
+    if (previousArray.length === 0) {
+        return randomWord;
+    }
+    return () => {
+        if (Math.random() < frequency) {
+            return previousArray[Math.floor(Math.random() * previousArray.length)];
+        }
+        return randomWord();
+    };
+}
+function getRandomEmptyPatch(optSyncSourceId, optSyncCollectionId) {
+    const id = uuid();
+    const syncSourceId = optSyncSourceId !== null && optSyncSourceId !== void 0 ? optSyncSourceId : uuid();
+    const syncCollectionId = optSyncCollectionId !== null && optSyncCollectionId !== void 0 ? optSyncCollectionId : uuid();
+    return new patch_1.ItemPatch(id, {}, {}, [], undefined, syncSourceId, syncCollectionId);
+}
+exports.getRandomEmptyPatch = getRandomEmptyPatch;
+function randInRange(range) {
+    if ((0, checks_1.isNumber)(range)) {
+        return Math.floor(Math.random() * range);
+    }
+    return range[0] + Math.floor(Math.random() * (range[1] - range[0]));
+}
+function schemaFromRange(range) {
+    const width = randInRange(range);
+    const fields = Array.from({ length: width }, (_, index) => (0, datasourceutils_1.alphabetize)(index));
+    return {
+        'Fields': fields.map((field) => ({
+            'Name': field,
+            'Type': spreadsheetpossibledatatypes_1.SpreadSheetPossibleDataTypes,
+        })),
+        'PrimaryKey': [],
+    };
+}
+function getRandomPatchSettingsInstance(settings) {
+    const schema = (0, serializedschema_1.isSerializedSchema)(settings.schema) ? settings.schema : schemaFromRange(settings.schema);
+    return {
+        previousDependency: settings.previousDependency,
+        deleteFrequency: settings.deleteFrequency,
+        addedIds: randInRange(settings.addedIds),
+        changedIds: randInRange(settings.changedIds),
+        deletedIds: randInRange(settings.deletedIds),
+        orderedAnchors: settings.orderedAnchors !== undefined ? randInRange(settings.orderedAnchors) : undefined,
+        changeDensity: settings.changeDensity,
+        schema,
+    };
+}
+function getRandomPatchItemFields(schema, density) {
+    const result = {};
+    const primaryKeys = new Set(schema['PrimaryKey']);
+    let isEmptyResult = true;
+    schema['Fields'].forEach((field) => {
+        if (primaryKeys.has(field['Name']) || Math.random() < density) {
+            isEmptyResult = false;
+            result[field['Name']] = randomWord();
+        }
+    });
+    return isEmptyResult ? undefined : result;
+}
+function getRandomPatchItem(count, schema, density, wordGetter) {
+    const result = {};
+    for (let i = 0; i < count; i++) {
+        const name = wordGetter();
+        const newFields = getRandomPatchItemFields(schema, density);
+        if (newFields) {
+            result[name] = newFields;
+        }
+    }
+    return result;
+}
+function getPreviousPatchBuckets(previousPatches) {
+    const normal = new Set();
+    const deleted = new Set();
+    previousPatches.forEach((patch) => {
+        for (const addedKey in patch.itemsAdded) {
+            normal.add(addedKey);
+            deleted.delete(addedKey);
+        }
+        for (const changedKey in patch.itemsAdded) {
+            normal.add(changedKey);
+            deleted.delete(changedKey);
+        }
+        for (const deletedKey of patch.itemsDeleted) {
+            normal.delete(deletedKey);
+            deleted.add(deletedKey);
+        }
+    });
+    return { normal, deleted };
+}
+function getRandomItemPatch(settings, previousPatches, optSyncSourceId, optSyncCollectionId) {
+    var _a;
+    const id = uuid();
+    const syncSourceId = optSyncSourceId !== null && optSyncSourceId !== void 0 ? optSyncSourceId : uuid();
+    const syncCollectionId = optSyncCollectionId !== null && optSyncCollectionId !== void 0 ? optSyncCollectionId : uuid();
+    const previousPatchBuckets = getPreviousPatchBuckets(previousPatches);
+    const settingsInstance = getRandomPatchSettingsInstance(settings);
+    const deletedWordGetter = randomWordOrPrevious(settings.deleteFrequency, previousPatchBuckets.deleted);
+    const addedItems = getRandomPatchItem(settingsInstance.addedIds, settingsInstance.schema, 1.0, deletedWordGetter);
+    const existingWordGetter = randomWordOrPrevious(settings.previousDependency, previousPatchBuckets.normal);
+    const changedItems = getRandomPatchItem(settingsInstance.changedIds, settingsInstance.schema, settings.changeDensity, existingWordGetter);
+    const deletedItems = [...new Set(Array.from({ length: settingsInstance.deletedIds }, existingWordGetter))];
+    deletedItems.forEach((deletedKey) => delete changedItems[deletedKey]);
+    const itemOrderChains = new Map();
+    const orderedAnchorsSet = (settingsInstance.orderedAnchors &&
+        new Set(Array.from({ length: settingsInstance.orderedAnchors }, existingWordGetter))) ||
+        undefined;
+    const orderedAnchors = orderedAnchorsSet && [...orderedAnchorsSet];
+    if (orderedAnchors && orderedAnchors.length > 0) {
+        for (const key in addedItems) {
+            const anchorIndex = Math.floor(Math.random() * orderedAnchors.length);
+            const anchor = orderedAnchors[anchorIndex];
+            if (!itemOrderChains.has(anchor)) {
+                itemOrderChains.set(anchor, new Set());
+            }
+            (_a = itemOrderChains.get(anchor)) === null || _a === void 0 ? void 0 : _a.add(key);
+        }
+    }
+    const itemOrderChanged = [];
+    itemOrderChains.forEach((chain, anchor) => {
+        let lastNext = anchor;
+        chain.forEach((chainEntry) => {
+            itemOrderChanged.push([chainEntry, lastNext]);
+            lastNext = chainEntry;
+        });
+    });
+    return new patch_1.ItemPatch(id, addedItems, changedItems, deletedItems, itemOrderChanged, syncSourceId, syncCollectionId);
+}
+exports.getRandomItemPatch = getRandomItemPatch;
+/**
+ * When we use raw JSON.stringify on objects, it can depend in subtle ways how the object was created. This
+ * function is intended to make the resulting string depend only on the logical contents so as to minimize unneeded
+ * refreshes.
+ *
+ * @param data The Sheet-type to stringify
+ * @returns A custom stringified object
+ */
+function orderedStringify(data) {
+    if ((0, checks_1.isArray)(data)) {
+        return `[${data.map((arrayItem) => (arrayItem == null ? 'null' : orderedStringify(arrayItem))).join(',')}]`;
+    }
+    if ((0, checks_1.isObject)(data)) {
+        const entries = Object.entries(data).filter(([_key, value]) => value !== undefined);
+        entries.sort(([keyA], [keyB]) => (keyA > keyB ? 1 : keyA === keyB ? 0 : -1));
+        return `{${entries.map(([key, value]) => `${JSON.stringify(key)}:${orderedStringify(value)}`).join(',')}}`;
+    }
+    return JSON.stringify(data);
+}
+exports.orderedStringify = orderedStringify;
+function patchesEqual(patchA, patchB) {
+    if (patchA instanceof patch_1.ItemPatch && patchB instanceof patch_1.ItemPatch) {
+        if (patchA.id !== patchB.id ||
+            patchA.syncSourceId !== patchB.syncSourceId ||
+            patchA.syncCollectionId !== patchB.syncCollectionId ||
+            orderedStringify(patchA.itemsAdded) !== orderedStringify(patchB.itemsAdded) ||
+            orderedStringify(patchA.itemsChanged) !== orderedStringify(patchB.itemsChanged) ||
+            !arraySetsEqual(patchA.itemsDeleted, patchB.itemsDeleted)) {
+            return false;
+        }
+        const orderMapA = new Map(patchA.itemOrderChanged);
+        const orderMapB = new Map(patchB.itemOrderChanged);
+        if (orderMapA.size !== orderMapB.size) {
+            return false;
+        }
+        return [...orderMapA].every(([from, to]) => orderMapB.get(from) === to);
+    }
+    if (patchA instanceof patch_1.SchemaPatch && patchB instanceof patch_1.SchemaPatch) {
+        if (patchA.id !== patchB.id ||
+            patchA.syncSourceId !== patchB.syncSourceId ||
+            patchA.syncCollectionId !== patchB.syncCollectionId ||
+            !arraysEqualWith(patch_1.areThirdPartyColumnsEqual)(patchA.columnsAdded, patchB.columnsAdded) ||
+            !recordsEqualWith(patch_1.areThirdPartyColumnPatchesEqual)(patchA.columnsChanged, patchB.columnsChanged) ||
+            !arraySetsEqual(patchA.columnsDeleted, patchB.columnsDeleted)) {
+            return false;
+        }
+        const orderMapA = new Map(patchA.columnOrdering);
+        const orderMapB = new Map(patchB.columnOrdering);
+        if (orderMapA.size !== orderMapB.size) {
+            return false;
+        }
+        return [...orderMapA].every(([from, to]) => orderMapB.get(from) === to);
+    }
+    return false;
+}
+exports.patchesEqual = patchesEqual;

package/package.json

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