@fluid-experimental/tree 0.58.2002 → 0.58.3000-61081

package/dist/default-edits/HistoryEditFactory.js

@@ -1,187 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.revert = void 0;
-const Common_1 = require("../Common");
-const Snapshot_1 = require("../Snapshot");
-const PersistedTypes_1 = require("./PersistedTypes");
-const Transaction_1 = require("./Transaction");
-const EditUtilities_1 = require("./EditUtilities");
-/**
- * Given a sequence of changes, produces an inverse sequence of changes, i.e. the minimal changes required to revert the given changes
- * @param changes - the changes for which to produce an inverse.
- * @param before - a snapshot of the tree state before `changes` are/were applied - used as a basis for generating the inverse.
- * @returns a sequence of changes _r_ that will produce `before` if applied to a snapshot _A_, where _A_ is the result of
- * applying `changes` to `before`. Applying _r_ to snapshots other than _A_ is legal but may cause the changes to fail to apply or may
- * not be a true semantic inverse.
- *
- * TODO: what should this do if `changes` fails to apply to `before`?
- * @public
- */
-function revert(changes, before) {
-    const result = [];
-    const builtNodes = new Map();
-    const detachedNodes = new Map();
-    // Open edit on revision to update it as changes are walked through
-    const editor = new Transaction_1.Transaction(before);
-    // Apply `edit`, generating an inverse as we go.
-    for (const change of changes) {
-        // Generate an inverse of each change
-        switch (change.type) {
-            case PersistedTypes_1.ChangeType.Build: {
-                // Save nodes added to the detached state for use in future changes
-                const { destination, source } = change;
-                Common_1.assert(!builtNodes.has(destination), `Cannot revert Build: destination is already used by a Build`);
-                Common_1.assert(!detachedNodes.has(destination), `Cannot revert Build: destination is already used by a Detach`);
-                builtNodes.set(destination, source.map((node) => node.identifier));
-                break;
-            }
-            case PersistedTypes_1.ChangeType.Insert: {
-                const { source } = change;
-                const nodesBuilt = builtNodes.get(source);
-                const nodesDetached = detachedNodes.get(source);
-                if (nodesBuilt !== undefined) {
-                    result.unshift(createInvertedInsert(change, nodesBuilt));
-                    builtNodes.delete(source);
-                }
-                else if (nodesDetached !== undefined) {
-                    result.unshift(createInvertedInsert(change, nodesDetached, true));
-                    detachedNodes.delete(source);
-                }
-                else {
-                    Common_1.fail('Cannot revert Insert: source has not been built or detached.');
-                }
-                break;
-            }
-            case PersistedTypes_1.ChangeType.Detach: {
-                const { destination } = change;
-                const { invertedDetach, detachedNodeIds } = createInvertedDetach(change, editor.view);
-                if (destination !== undefined) {
-                    Common_1.assert(!builtNodes.has(destination), `Cannot revert Detach: destination is already used by a Build`);
-                    Common_1.assert(!detachedNodes.has(destination), `Cannot revert Detach: destination is already used by a Detach`);
-                    detachedNodes.set(destination, detachedNodeIds);
-                }
-                result.unshift(...invertedDetach);
-                break;
-            }
-            case PersistedTypes_1.ChangeType.SetValue:
-                result.unshift(...createInvertedSetValue(change, editor.view));
-                break;
-            case PersistedTypes_1.ChangeType.Constraint:
-                // TODO:#46759: Support Constraint in reverts
-                Common_1.fail('Revert currently does not support Constraints');
-                break;
-            default:
-                Common_1.fail('Revert does not support the change type.');
-        }
-        // Update the revision
-        editor.applyChange(change);
-    }
-    editor.close();
-    return result;
-}
-exports.revert = revert;
-/**
- * Inverse of an Insert is a Detach that starts before the leftmost node inserted and ends after the rightmost.
- */
-function createInvertedInsert(insert, nodesInserted, saveDetached = false) {
-    const leftmostNode = nodesInserted[0];
-    const rightmostNode = nodesInserted[nodesInserted.length - 1];
-    const source = {
-        start: {
-            referenceSibling: leftmostNode,
-            side: Snapshot_1.Side.Before,
-        },
-        end: {
-            referenceSibling: rightmostNode,
-            side: Snapshot_1.Side.After,
-        },
-    };
-    return PersistedTypes_1.Change.detach(source, saveDetached ? insert.source : undefined);
-}
-/**
- * If a detach does not include a destination, its inverse is a build and insert. Otherwise, it is just an insert.
- * Information on the nodes that were detached is obtained by going to the revision before the detach.
- *
- * The anchor for the resulting Insert is chosen in the following order:
- *     1. If detach.source.start.side is After: detach.source.start
- *
- *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,
- *            if detach.source.start is "After B", the anchor for the resulting Insert will also be "After B".
- *
- *            For nodes [A..F] G H where [A..F] represents the detached nodes,
- *            if detach.source.start is "After start of trait", the anchor for the resulting Insert will also be "After start of trait".
- *
- *     2. Else if detach.source.end.side is Before: detach.source.end
- *
- *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,
- *            if detach.source.start is "Before C" and detach.source.end is "Before G",
- *            the anchor for the resulting Insert will be "Before G".
- *
- *     3. Else: After the node directly to the left of the originally detached nodes
- *
- *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,
- *            if detach.source.start is "Before C" and detach.source.end is "After F",
- *            the anchor for the resulting Insert will be "After B".
- *
- *  When choosing the anchor, the existing anchors on detach.source are preferred when they have a valid sibling. Otherwise, the valid
- *  anchor to the left of the originally detached nodes is chosen.
- */
-function createInvertedDetach(detach, snapshotBeforeEdit) {
-    const { source } = detach;
-    const { start, end } = EditUtilities_1.rangeFromStableRange(snapshotBeforeEdit, source);
-    const { trait: referenceTrait } = start;
-    const nodes = snapshotBeforeEdit.getTrait(referenceTrait);
-    const startIndex = snapshotBeforeEdit.findIndexWithinTrait(start);
-    const endIndex = snapshotBeforeEdit.findIndexWithinTrait(end);
-    const detachedNodeIds = nodes.slice(startIndex, endIndex);
-    const leftOfDetached = nodes.slice(0, startIndex);
-    let insertDestination;
-    if (start.side === Snapshot_1.Side.After) {
-        insertDestination =
-            start.sibling === undefined
-                ? { side: Snapshot_1.Side.After, referenceTrait }
-                : { side: Snapshot_1.Side.After, referenceSibling: start.sibling };
-    }
-    else if (end.side === Snapshot_1.Side.Before) {
-        insertDestination =
-            end.sibling === undefined
-                ? { side: Snapshot_1.Side.Before, referenceTrait }
-                : { side: Snapshot_1.Side.Before, referenceSibling: end.sibling };
-    }
-    else {
-        const referenceSibling = leftOfDetached.pop();
-        insertDestination = {
-            side: Snapshot_1.Side.After,
-            referenceSibling,
-            referenceTrait: referenceSibling === undefined ? referenceTrait : undefined,
-        };
-    }
-    if (detach.destination !== undefined) {
-        return {
-            invertedDetach: [PersistedTypes_1.Change.insert(detach.destination, insertDestination)],
-            detachedNodeIds,
-        };
-    }
-    const detachedSequenceId = 0;
-    return {
-        invertedDetach: [
-            PersistedTypes_1.Change.build(snapshotBeforeEdit.getChangeNodes(detachedNodeIds), detachedSequenceId),
-            PersistedTypes_1.Change.insert(detachedSequenceId, insertDestination),
-        ],
-        detachedNodeIds,
-    };
-}
-function createInvertedSetValue(setValue, revisionBeforeEdit) {
-    const { nodeToModify } = setValue;
-    const oldPayload = revisionBeforeEdit.getSnapshotNode(nodeToModify).payload;
-    // Rationale: 'undefined' is reserved for future use (see 'SetValue' interface)
-    if (oldPayload !== null) {
-        return [PersistedTypes_1.Change.setPayload(nodeToModify, oldPayload)];
-    }
-    return [PersistedTypes_1.Change.clearPayload(nodeToModify)];
-}
-//# sourceMappingURL=HistoryEditFactory.js.map

package/dist/default-edits/HistoryEditFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HistoryEditFactory.js","sourceRoot":"","sources":["../../src/default-edits/HistoryEditFactory.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { DetachedSequenceId, NodeId } from '../Identifiers';\nimport { assert, fail } from '../Common';\nimport { Snapshot, Side } from '../Snapshot';\nimport { BuildNode, TreeNode } from '../generic';\nimport { Change, ChangeType, Detach, Insert, SetValue, StableRange, StablePlace } from './PersistedTypes';\nimport { Transaction } from './Transaction';\nimport { rangeFromStableRange } from './EditUtilities';\n\n/**\n * Given a sequence of changes, produces an inverse sequence of changes, i.e. the minimal changes required to revert the given changes\n * @param changes - the changes for which to produce an inverse.\n * @param before - a snapshot of the tree state before `changes` are/were applied - used as a basis for generating the inverse.\n * @returns a sequence of changes _r_ that will produce `before` if applied to a snapshot _A_, where _A_ is the result of\n * applying `changes` to `before`. Applying _r_ to snapshots other than _A_ is legal but may cause the changes to fail to apply or may\n * not be a true semantic inverse.\n *\n * TODO: what should this do if `changes` fails to apply to `before`?\n * @public\n */\nexport function revert(changes: readonly Change[], before: Snapshot): Change[] {\n\tconst result: Change[] = [];\n\n\tconst builtNodes = new Map<DetachedSequenceId, NodeId[]>();\n\tconst detachedNodes = new Map<DetachedSequenceId, NodeId[]>();\n\n\t// Open edit on revision to update it as changes are walked through\n\tconst editor = new Transaction(before);\n\t// Apply `edit`, generating an inverse as we go.\n\tfor (const change of changes) {\n\t\t// Generate an inverse of each change\n\t\tswitch (change.type) {\n\t\t\tcase ChangeType.Build: {\n\t\t\t\t// Save nodes added to the detached state for use in future changes\n\t\t\t\tconst { destination, source } = change;\n\t\t\t\tassert(!builtNodes.has(destination), `Cannot revert Build: destination is already used by a Build`);\n\t\t\t\tassert(!detachedNodes.has(destination), `Cannot revert Build: destination is already used by a Detach`);\n\t\t\t\tbuiltNodes.set(\n\t\t\t\t\tdestination,\n\t\t\t\t\tsource.map((node) => (node as TreeNode<BuildNode>).identifier)\n\t\t\t\t);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ChangeType.Insert: {\n\t\t\t\tconst { source } = change;\n\t\t\t\tconst nodesBuilt = builtNodes.get(source);\n\t\t\t\tconst nodesDetached = detachedNodes.get(source);\n\n\t\t\t\tif (nodesBuilt !== undefined) {\n\t\t\t\t\tresult.unshift(createInvertedInsert(change, nodesBuilt));\n\t\t\t\t\tbuiltNodes.delete(source);\n\t\t\t\t} else if (nodesDetached !== undefined) {\n\t\t\t\t\tresult.unshift(createInvertedInsert(change, nodesDetached, true));\n\t\t\t\t\tdetachedNodes.delete(source);\n\t\t\t\t} else {\n\t\t\t\t\tfail('Cannot revert Insert: source has not been built or detached.');\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ChangeType.Detach: {\n\t\t\t\tconst { destination } = change;\n\t\t\t\tconst { invertedDetach, detachedNodeIds } = createInvertedDetach(change, editor.view);\n\n\t\t\t\tif (destination !== undefined) {\n\t\t\t\t\tassert(\n\t\t\t\t\t\t!builtNodes.has(destination),\n\t\t\t\t\t\t`Cannot revert Detach: destination is already used by a Build`\n\t\t\t\t\t);\n\t\t\t\t\tassert(\n\t\t\t\t\t\t!detachedNodes.has(destination),\n\t\t\t\t\t\t`Cannot revert Detach: destination is already used by a Detach`\n\t\t\t\t\t);\n\t\t\t\t\tdetachedNodes.set(destination, detachedNodeIds);\n\t\t\t\t}\n\n\t\t\t\tresult.unshift(...invertedDetach);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase ChangeType.SetValue:\n\t\t\t\tresult.unshift(...createInvertedSetValue(change, editor.view));\n\t\t\t\tbreak;\n\t\t\tcase ChangeType.Constraint:\n\t\t\t\t// TODO:#46759: Support Constraint in reverts\n\t\t\t\tfail('Revert currently does not support Constraints');\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tfail('Revert does not support the change type.');\n\t\t}\n\n\t\t// Update the revision\n\t\teditor.applyChange(change);\n\t}\n\n\teditor.close();\n\treturn result;\n}\n\n/**\n * Inverse of an Insert is a Detach that starts before the leftmost node inserted and ends after the rightmost.\n */\nfunction createInvertedInsert(insert: Insert, nodesInserted: readonly NodeId[], saveDetached = false): Change {\n\tconst leftmostNode = nodesInserted[0];\n\tconst rightmostNode = nodesInserted[nodesInserted.length - 1];\n\n\tconst source: StableRange = {\n\t\tstart: {\n\t\t\treferenceSibling: leftmostNode,\n\t\t\tside: Side.Before,\n\t\t},\n\t\tend: {\n\t\t\treferenceSibling: rightmostNode,\n\t\t\tside: Side.After,\n\t\t},\n\t};\n\n\treturn Change.detach(source, saveDetached ? insert.source : undefined);\n}\n\n/**\n * If a detach does not include a destination, its inverse is a build and insert. Otherwise, it is just an insert.\n * Information on the nodes that were detached is obtained by going to the revision before the detach.\n *\n * The anchor for the resulting Insert is chosen in the following order:\n *     1. If detach.source.start.side is After: detach.source.start\n *\n *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,\n *            if detach.source.start is \"After B\", the anchor for the resulting Insert will also be \"After B\".\n *\n *            For nodes [A..F] G H where [A..F] represents the detached nodes,\n *            if detach.source.start is \"After start of trait\", the anchor for the resulting Insert will also be \"After start of trait\".\n *\n *     2. Else if detach.source.end.side is Before: detach.source.end\n *\n *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,\n *            if detach.source.start is \"Before C\" and detach.source.end is \"Before G\",\n *            the anchor for the resulting Insert will be \"Before G\".\n *\n *     3. Else: After the node directly to the left of the originally detached nodes\n *\n *        ex: For nodes A B [C..F] G H where [C..F] represents the detached nodes,\n *            if detach.source.start is \"Before C\" and detach.source.end is \"After F\",\n *            the anchor for the resulting Insert will be \"After B\".\n *\n *  When choosing the anchor, the existing anchors on detach.source are preferred when they have a valid sibling. Otherwise, the valid\n *  anchor to the left of the originally detached nodes is chosen.\n */\nfunction createInvertedDetach(\n\tdetach: Detach,\n\tsnapshotBeforeEdit: Snapshot\n): { invertedDetach: Change[]; detachedNodeIds: NodeId[] } {\n\tconst { source } = detach;\n\n\tconst { start, end } = rangeFromStableRange(snapshotBeforeEdit, source);\n\tconst { trait: referenceTrait } = start;\n\tconst nodes = snapshotBeforeEdit.getTrait(referenceTrait);\n\n\tconst startIndex = snapshotBeforeEdit.findIndexWithinTrait(start);\n\tconst endIndex = snapshotBeforeEdit.findIndexWithinTrait(end);\n\tconst detachedNodeIds: NodeId[] = nodes.slice(startIndex, endIndex);\n\n\tconst leftOfDetached = nodes.slice(0, startIndex);\n\n\tlet insertDestination: StablePlace;\n\n\tif (start.side === Side.After) {\n\t\tinsertDestination =\n\t\t\tstart.sibling === undefined\n\t\t\t\t? { side: Side.After, referenceTrait }\n\t\t\t\t: { side: Side.After, referenceSibling: start.sibling };\n\t} else if (end.side === Side.Before) {\n\t\tinsertDestination =\n\t\t\tend.sibling === undefined\n\t\t\t\t? { side: Side.Before, referenceTrait }\n\t\t\t\t: { side: Side.Before, referenceSibling: end.sibling };\n\t} else {\n\t\tconst referenceSibling = leftOfDetached.pop();\n\t\tinsertDestination = {\n\t\t\tside: Side.After,\n\t\t\treferenceSibling,\n\t\t\treferenceTrait: referenceSibling === undefined ? referenceTrait : undefined,\n\t\t};\n\t}\n\n\tif (detach.destination !== undefined) {\n\t\treturn {\n\t\t\tinvertedDetach: [Change.insert(detach.destination, insertDestination)],\n\t\t\tdetachedNodeIds,\n\t\t};\n\t}\n\n\tconst detachedSequenceId = 0 as DetachedSequenceId;\n\treturn {\n\t\tinvertedDetach: [\n\t\t\tChange.build(snapshotBeforeEdit.getChangeNodes(detachedNodeIds), detachedSequenceId),\n\t\t\tChange.insert(detachedSequenceId, insertDestination),\n\t\t],\n\t\tdetachedNodeIds,\n\t};\n}\n\nfunction createInvertedSetValue(setValue: SetValue, revisionBeforeEdit: Snapshot): Change[] {\n\tconst { nodeToModify } = setValue;\n\tconst oldPayload = revisionBeforeEdit.getSnapshotNode(nodeToModify).payload;\n\n\t// Rationale: 'undefined' is reserved for future use (see 'SetValue' interface)\n\tif (oldPayload !== null) {\n\t\treturn [Change.setPayload(nodeToModify, oldPayload)];\n\t}\n\treturn [Change.clearPayload(nodeToModify)];\n}\n"]}

package/dist/default-edits/PersistedTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PersistedTypes.d.ts","sourceRoot":"","sources":["../../src/default-edits/PersistedTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEpF,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AACH,oBAAY,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;AAE/C;;;GAGG;AACH,oBAAY,UAAU;IACrB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,UAAU,IAAA;CACV;AAED;;;;;;;GAOG;AACH,oBAAY,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,KAAK;IACrB,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,MAAM,CAAC;CACxC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,MAAM,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,QAAQ,CAAC;CAC1C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAElC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC;IAEnC;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,UAAU,CAAC;CAC5C;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IAC3B;;OAEG;IACH,iBAAiB,IAAA;IAEjB;;;OAGG;IACH,YAAY,IAAA;IAEZ;;;OAGG;IACH,UAAU,IAAA;CACV;AAGD;;GAEG;AACH,eAAO,MAAM,MAAM;oBACF,iBAAiB,SAAS,CAAC,eAAe,kBAAkB,KAAG,KAAK;qBAMnE,kBAAkB,eAAe,WAAW,KAAG,MAAM;qBAMrD,WAAW,mDAAqC,MAAM;+BAM5C,MAAM,WAAW,OAAO,KAAG,QAAQ;iCAMjC,MAAM,KAAG,QAAQ;8BAQhC,WAAW,UAChB,gBAAgB,gLAMtB,UAAU;CAUb,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,MAAM;IAClB;;OAEG;0BACmB,WAAW,KAAG,MAAM;CAC1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,MAAM;IAClB;;OAEG;oBACa,iBAAiB,SAAS,CAAC,eAAe,WAAW,KAAG,MAAM,EAAE;CAIhF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,IAAI;IAChB;;OAEG;qBACc,WAAW,eAAe,WAAW,KAAG,MAAM,EAAE;CAIjE,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAEpB;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAEnC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC1B;AAED;;;;;;GAMG;AAGH;;GAEG;AACH,eAAO,MAAM,WAAW;IACvB;;OAEG;mBACY,QAAQ,GAAG,MAAM,KAAG,WAAW;IAI9C;;OAEG;kBACW,QAAQ,GAAG,MAAM,KAAG,WAAW;IAC7C;;OAEG;uBACgB,aAAa,KAAG,WAAW;IAC9C;;OAEG;qBACc,aAAa,KAAG,WAAW;CAC5C,CAAC;AAGF;;GAEG;AACH,eAAO,MAAM,WAAW;IACvB;;;;OAIG;kBACW,WAAW;kBAAe,WAAW,KAAK,WAAW;;IAUnE;;;OAGG;iBACU,QAAQ,GAAG,MAAM,KAAG,WAAW;IAC5C;;;;OAIG;iBACU,aAAa,KAAG,WAAW;CAIxC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,IAAI,QAAQ,CAEpE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAMzD"}

package/dist/default-edits/PersistedTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PersistedTypes.js","sourceRoot":"","sources":["../../src/default-edits/PersistedTypes.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// All types imported into this file inherit the requirements documented below.\n// These imports are ok because they consist only of type aliases for primitive types,\n// and thus have no impact on serialization as long as the primitive type they are an alias for does not change.\n// This does mean that the various UuidString types must remain strings, and must never change the format unless the process for changing\n// persisted types (as documented below) is followed.\nimport { DetachedSequenceId, NodeId, TraitLabel, UuidString } from '../Identifiers';\nimport { assertNotUndefined, assert } from '../Common';\nimport { Side } from '../Snapshot';\nimport { EditBase, BuildNode, NodeData, Payload, TraitLocation, TreeNodeSequence } from '../generic';\n\n/**\n * Types for Edits in Fluid Ops and Fluid summaries.\n *\n * Types describing locations in the tree are stable in the presence of other concurrent edits.\n *\n * All types are compatible with Fluid Serializable.\n *\n * These types can only be modified in ways that are both backwards and forwards compatible since they\n * are used in edits, and thus are persisted (using Fluid serialization).\n *\n * This means these types cannot be changed in any way that impacts their Fluid serialization\n * except through a very careful process:\n *\n * 1. The planned change must support all old data, and maintain the exact semantics of it.\n * This means that the change is pretty much limited to adding optional fields,\n * or making required fields optional.\n * 2. Support for the new format must be deployed to all users (This means all applications using SharedTree must do this),\n * and this deployment must be confirmed to be stable and will not be rolled back.\n * 3. Usage of the new format may start.\n *\n * Support for the old format can NEVER be removed: it must be maintained indefinably or old documents will break.\n * Because this process puts requirements on applications using shared tree,\n * step 3 should only ever be done in a Major version update,\n * and must be explicitly called out in the release notes\n * stating which versions of SharedTree are supported for documents modified by the new version.\n */\n\n/**\n * The information included in an edit.\n * @public\n */\nexport type DefaultEditBase = EditBase<Change>;\n\n/**\n * The type of a Change\n * @public\n */\nexport enum ChangeType {\n\tInsert,\n\tDetach,\n\tBuild,\n\tSetValue,\n\tConstraint,\n}\n\n/**\n * A change that composes an Edit.\n *\n * `Change` objects can be conveniently constructed with the helper methods exported on a constant of the same name.\n * @example\n * Change.insert(sourceId, destination)\n * @public\n */\nexport type Change = Insert | Detach | Build | SetValue | Constraint;\n\n/**\n * Constructs a sequence of nodes, associates it with the supplied ID, and stores it for use in later changes.\n * Does not modify the document.\n *\n * Valid if (transitively) all DetachedSequenceId are used according to their rules (use here counts as a destination),\n * and all Nodes' identifiers are previously unused.\n *\n * TODO: Design Decision:\n * If allowing 'moving from nowhere' to restore nodes: all new Nodes must have never before used identifiers.\n * Otherwise could just forbid identifiers currently reachable?\n * Could also allow introducing a node with a particular identifier to mean replacing that node with the new one\n * (could include optional constraint to require/prevent this).\n *\n * @public\n */\nexport interface Build {\n\treadonly destination: DetachedSequenceId;\n\treadonly source: TreeNodeSequence<BuildNode>;\n\treadonly type: typeof ChangeType.Build;\n}\n\n/**\n * Inserts a sequence of nodes at the specified destination.\n * The source can be constructed either by a Build (used to insert new nodes) or a Detach (amounts to a \"move\" operation).\n * @public\n */\nexport interface Insert {\n\treadonly destination: StablePlace;\n\treadonly source: DetachedSequenceId;\n\treadonly type: typeof ChangeType.Insert;\n}\n\n/**\n * Removes a sequence of nodes from the tree.\n * If a destination is specified, the detached sequence is associated with that ID and held for possible reuse\n * by later changes in this same Edit (such as by an Insert).\n * A Detach without a destination is a deletion of the specified sequence, as is a Detach with a destination that is not used later.\n * @public\n */\nexport interface Detach {\n\treadonly destination?: DetachedSequenceId;\n\treadonly source: StableRange;\n\treadonly type: typeof ChangeType.Detach;\n}\n\n/**\n * Modifies the payload of a node.\n * @public\n */\nexport interface SetValue {\n\treadonly nodeToModify: NodeId;\n\t/**\n\t * Sets or clears the payload.\n\t * To improve ease of forwards compatibility, an explicit `null` value is used to represent the clearing of a payload.\n\t * SetValue may use `undefined` in future API versions to mean \"don't change the payload\" (which is useful if e.g. other\n\t * fields are added to SetValue that can be changed without altering the payload)\n\t */\n\treadonly payload: Payload | null;\n\treadonly type: typeof ChangeType.SetValue;\n}\n\n/**\n * A set of constraints on the validity of an Edit.\n * A Constraint is used to detect when an Edit, due to other concurrent edits, may have unintended effects or merge in\n * non-semantic ways. It is processed in order like any other Change in an Edit. It can cause an edit to fail if the\n * various constraints are not met at the time of evaluation (ex: the parentNode has changed due to concurrent editing).\n * Does not modify the document.\n * @public\n */\nexport interface Constraint {\n\t/**\n\t * Selects a sequence of nodes which will be checked against the constraints specified by the optional fields.\n\t * If `toConstrain` is invalid, it will be treated like a constraint being unmet.\n\t * Depending on `effect` this may or may not make the Edit invalid.\n\t *\n\t * When a constraint is not met, the effects is specified by `effect`.\n\t */\n\treadonly toConstrain: StableRange;\n\n\t/**\n\t * Require that the identities of all the nodes in toConstrain hash to this value.\n\t * Hash is order dependent.\n\t * TODO: implement and specify exact hash function.\n\t *\n\t * This is an efficient (O(1) space) way to constrain a sequence of nodes to have specific identities.\n\t */\n\treadonly identityHash?: UuidString;\n\n\t/**\n\t * Require that the number of nodes in toConstrain is this value.\n\t */\n\treadonly length?: number;\n\n\t/**\n\t * Require that the contents of all of the nodes in toConstrain hash to this value.\n\t * Hash is an order dependant deep hash, which includes all subtree content recursively.\n\t * TODO: implement and specify exact hash function.\n\t *\n\t * This is an efficient (O(1) space) way to constrain a sequence of nodes have exact values (transitively).\n\t */\n\treadonly contentHash?: UuidString;\n\n\t/**\n\t * Require that parent under which toConstrain is located has this identifier.\n\t */\n\treadonly parentNode?: NodeId;\n\n\t/**\n\t * Require that the trait under which toConstrain is located has this label.\n\t */\n\treadonly label?: TraitLabel;\n\n\t/**\n\t * What to do if a constraint is not met.\n\t */\n\treadonly effect: ConstraintEffect;\n\n\t/**\n\t * Marker for which kind of Change this is.\n\t */\n\treadonly type: typeof ChangeType.Constraint;\n}\n\n/**\n * What to do when a Constraint is violated.\n * @public\n */\nexport enum ConstraintEffect {\n\t/**\n\t * Discard Edit.\n\t */\n\tInvalidAndDiscard,\n\n\t/**\n\t * Discard Edit, but record metadata that application may want to try and recover this change by recreating it.\n\t * Should this be the default policy for when another (non Constraint) change is invalid?\n\t */\n\tInvalidRetry,\n\n\t/**\n\t * Apply the change, but flag it for possible reconsideration by the app\n\t * (applying it is better than not, but perhaps the high level logic could produce something better).\n\t */\n\tValidRetry,\n}\n\n// Note: Documentation of this constant is merged with documentation of the `Change` interface.\n/**\n * @public\n */\nexport const Change = {\n\tbuild: (source: TreeNodeSequence<BuildNode>, destination: DetachedSequenceId): Build => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeType.Build,\n\t}),\n\n\tinsert: (source: DetachedSequenceId, destination: StablePlace): Insert => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeType.Insert,\n\t}),\n\n\tdetach: (source: StableRange, destination?: DetachedSequenceId): Detach => ({\n\t\tdestination,\n\t\tsource,\n\t\ttype: ChangeType.Detach,\n\t}),\n\n\tsetPayload: (nodeToModify: NodeId, payload: Payload): SetValue => ({\n\t\tnodeToModify,\n\t\tpayload,\n\t\ttype: ChangeType.SetValue,\n\t}),\n\n\tclearPayload: (nodeToModify: NodeId): SetValue => ({\n\t\tnodeToModify,\n\t\t// Rationale: 'undefined' is reserved for future use (see 'SetValue' interface above.)\n\t\tpayload: null,\n\t\ttype: ChangeType.SetValue,\n\t}),\n\n\tconstraint: (\n\t\ttoConstrain: StableRange,\n\t\teffect: ConstraintEffect,\n\t\tidentityHash?: UuidString,\n\t\tlength?: number,\n\t\tcontentHash?: UuidString,\n\t\tparentNode?: NodeId,\n\t\tlabel?: TraitLabel\n\t): Constraint => ({\n\t\ttoConstrain,\n\t\teffect,\n\t\tidentityHash,\n\t\tlength,\n\t\tcontentHash,\n\t\tparentNode,\n\t\tlabel,\n\t\ttype: ChangeType.Constraint,\n\t}),\n};\n\n/**\n * Helper for creating a `Delete` edit.\n * @public\n */\nexport const Delete = {\n\t/**\n\t * @returns a Change that deletes the supplied part of the tree.\n\t */\n\tcreate: (stableRange: StableRange): Change => Change.detach(stableRange),\n};\n\n/**\n * Helper for creating an `Insert` edit.\n * @public\n */\nexport const Insert = {\n\t/**\n\t * @returns a Change that inserts 'nodes' into the specified location in the tree.\n\t */\n\tcreate: (nodes: TreeNodeSequence<BuildNode>, destination: StablePlace): Change[] => {\n\t\tconst build = Change.build(nodes, 0 as DetachedSequenceId);\n\t\treturn [build, Change.insert(build.destination, destination)];\n\t},\n};\n\n/**\n * Helper for creating a `Move` edit.\n * @public\n */\nexport const Move = {\n\t/**\n\t * @returns a Change that moves the specified content to a new location in the tree.\n\t */\n\tcreate: (source: StableRange, destination: StablePlace): Change[] => {\n\t\tconst detach = Change.detach(source, 0 as DetachedSequenceId);\n\t\treturn [detach, Change.insert(assertNotUndefined(detach.destination), destination)];\n\t},\n};\n\n/**\n * A location in a trait.\n * This is NOT the location of a node, but a location where a node could be inserted:\n * it is next to a sibling or at one end of the trait.\n *\n * To be well formed, either `sibling` or `trait` must be defined, but not both.\n *\n * Any given insertion location can be described by two `StablePlace` objects, one with `Side.After` and one with `Side.Before`.\n * For example, in a trait containing two strings \"foo\" and \"bar\", there are 6 places corresponding to 3 places into the trait a new node\n * could be inserted: at the start, before \"foo\", after \"foo\", before \"bar\", after \"bar\", and at the end.\n * The anchor (`referenceSibling` or `referenceTrait`) used for a particular `StablePlace` can have an impact in collaborative scenarios.\n *\n * `StablePlace` objects can be conveniently constructed with the helper methods exported on a constant of the same name.\n * @example\n * StablePlace.before(node)\n * StablePlace.atStartOf(trait)\n * @public\n */\nexport interface StablePlace {\n\t/**\n\t * Where this StablePlace is relative to the sibling (if specified), or an end of the trait (if no sibling specified).\n\t * If 'After' and there is no sibling, this StablePlace is after the front of the trait.\n\t * If 'Before' and there is no sibling, this StablePlace is before the back of the trait.\n\t */\n\treadonly side: Side;\n\n\t/**\n\t * The sibling to which this 'StablePlace' is anchored (by 'side').\n\t * If specified, referenceTrait must be unspecified.\n\t */\n\treadonly referenceSibling?: NodeId;\n\n\t/**\n\t * The trait to which this 'StablePlace' is anchored (by 'side').\n\t * If specified, referenceSibling must be unspecified.\n\t */\n\treadonly referenceTrait?: TraitLocation;\n}\n\n/**\n * Specifies the range of nodes from `start` to `end` within a trait.\n * Valid iff start and end are valid and are within the same trait and the start does not occur after the end in the trait.\n *\n * `StableRange` objects can be conveniently constructed with the helper methods exported on a constant of the same name.\n * @example\n * StableRange.from(StablePlace.before(startNode)).to(StablePlace.after(endNode))\n * @public\n */\nexport interface StableRange {\n\treadonly start: StablePlace;\n\treadonly end: StablePlace;\n}\n\n/**\n * The remainder of this file consists of ergonomic factory methods for persisted types, or common combinations thereof (e.g. \"Move\" as a\n * combination of a \"Detach\" change and an \"Insert\" change).\n *\n * None of these helpers are persisted in documents, and therefore changes to their semantics need only follow standard semantic versioning\n * practices.\n */\n\n// Note: Documentation of this constant is merged with documentation of the `StablePlace` interface.\n/**\n * @public\n */\nexport const StablePlace = {\n\t/**\n\t * @returns The location directly before `node`.\n\t */\n\tbefore: (node: NodeData | NodeId): StablePlace => ({\n\t\tside: Side.Before,\n\t\treferenceSibling: getNodeId(node),\n\t}),\n\t/**\n\t * @returns The location directly after `node`.\n\t */\n\tafter: (node: NodeData | NodeId): StablePlace => ({ side: Side.After, referenceSibling: getNodeId(node) }),\n\t/**\n\t * @returns The location at the start of `trait`.\n\t */\n\tatStartOf: (trait: TraitLocation): StablePlace => ({ side: Side.After, referenceTrait: trait }),\n\t/**\n\t * @returns The location at the end of `trait`.\n\t */\n\tatEndOf: (trait: TraitLocation): StablePlace => ({ side: Side.Before, referenceTrait: trait }),\n};\n\n// Note: Documentation of this constant is merged with documentation of the `StableRange` interface.\n/**\n * @public\n */\nexport const StableRange = {\n\t/**\n\t * Factory for producing a `StableRange` from a start `StablePlace` to an end `StablePlace`.\n\t * @example\n\t * StableRange.from(StablePlace.before(startNode)).to(StablePlace.after(endNode))\n\t */\n\tfrom: (start: StablePlace): { to: (end: StablePlace) => StableRange } => ({\n\t\tto: (end: StablePlace): StableRange => {\n\t\t\tif (start.referenceTrait && end.referenceTrait) {\n\t\t\t\tconst message = 'StableRange must be constructed with endpoints from the same trait';\n\t\t\t\tassert(start.referenceTrait.parent === end.referenceTrait.parent, message);\n\t\t\t\tassert(start.referenceTrait.label === end.referenceTrait.label, message);\n\t\t\t}\n\t\t\treturn { start, end };\n\t\t},\n\t}),\n\t/**\n\t * @returns a `StableRange` which contains only the provided `node`.\n\t * Both the start and end `StablePlace` objects used to anchor this `StableRange` are in terms of the passed in node.\n\t */\n\tonly: (node: NodeData | NodeId): StableRange => ({ start: StablePlace.before(node), end: StablePlace.after(node) }),\n\t/**\n\t * @returns a `StableRange` which contains everything in the trait.\n\t * This is anchored using the provided `trait`, and is independent of the actual contents of the trait:\n\t * it does not use sibling anchoring.\n\t */\n\tall: (trait: TraitLocation): StableRange => ({\n\t\tstart: StablePlace.atStartOf(trait),\n\t\tend: StablePlace.atEndOf(trait),\n\t}),\n};\n\n/**\n * @returns True iff the given `node` is of type NodeData.\n * @internal\n */\nexport function isNodeData(node: NodeData | NodeId): node is NodeData {\n\treturn (node as NodeData).definition !== undefined && (node as NodeData).identifier !== undefined;\n}\n\n/**\n * @returns The NodeId for a given node or its id.\n * @internal\n */\nexport function getNodeId(node: NodeData | NodeId): NodeId {\n\tif (isNodeData(node)) {\n\t\treturn node.identifier;\n\t} else {\n\t\treturn node;\n\t}\n}\n"]}

package/dist/default-edits/SharedTree.d.ts

@@ -1,111 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
-import { EditId, NodeId } from '../Identifiers';
-import { Snapshot } from '../Snapshot';
-import { Edit, BuildNode, GenericSharedTree, NodeData, SharedTreeSummaryBase } from '../generic';
-import { OrderedEditSet } from '../EditLog';
-import { Change, StableRange, StablePlace } from './PersistedTypes';
-import { SharedTreeFactory } from './Factory';
-/**
- * Wrapper around a `SharedTree` which provides ergonomic imperative editing functionality. All methods apply changes in their own edit.
- *
- * @example
- * // The following two lines of code are equivalent:
- * tree.applyEdit(...Insert.create([newNode], StablePlace.before(existingNode)));
- * tree.editor.insert(newNode, StablePlace.before(existingNode))
- * @public
- */
-export declare class SharedTreeEditor {
-    private readonly tree;
-    constructor(tree: SharedTree);
-    /**
-     * Inserts a node at a location.
-     * @param node - Node to insert.
-     * @param destination - StablePlace at which the insert should take place.
-     */
-    insert(node: BuildNode, destination: StablePlace): EditId;
-    /**
-     * Inserts nodes at a location.
-     * @param nodes - Nodes to insert.
-     * @param destination - StablePlace at which the insert should take place.
-     */
-    insert(nodes: BuildNode[], destination: StablePlace): EditId;
-    /**
-     * Moves a node to a specified location.
-     * @param source - Node to move.
-     * @param destination - StablePlace to which the node should be moved.
-     */
-    move(source: NodeData, destination: StablePlace): EditId;
-    /**
-     * Moves a node to a specified location.
-     * @param source - Node to move.
-     * @param destination - StablePlace to which the node should be moved.
-     */
-    move(source: NodeId, destination: StablePlace): EditId;
-    /**
-     * Moves a part of a trait to a specified location.
-     * @param source - Portion of a trait to move.
-     * @param destination - StablePlace to which the portion of the trait should be moved.
-     */
-    move(source: StableRange, destination: StablePlace): EditId;
-    /**
-     * Deletes a node.
-     * @param target - Node to delete
-     */
-    delete(target: NodeData): EditId;
-    /**
-     * Deletes a node.
-     * @param target - Node to delete
-     */
-    delete(target: NodeId): EditId;
-    /**
-     * Deletes a portion of a trait.
-     * @param target - Range of nodes to delete, specified as a `StableRange`
-     */
-    delete(target: StableRange): EditId;
-    /**
-     * Reverts a previous edit.
-     * @param edit - the edit to revert
-     * @param view - the revision to which the edit is applied (not the output of applying edit: it's the one just before that)
-     */
-    revert(edit: Edit<Change>, view: Snapshot): EditId;
-    private isStableRange;
-}
-/**
- * A distributed tree.
- * @public
- * @sealed
- */
-export declare class SharedTree extends GenericSharedTree<Change> {
-    /**
-     * Create a new SharedTree. It will contain the default value (see initialTree).
-     */
-    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedTree;
-    /**
-     * Get a factory for SharedTree to register with the data store.
-     * @param historySummarizing - determines how history is summarized by the returned `SharedTree`.
-     * @returns A factory that creates `SharedTree`s and loads them from storage.
-     */
-    static getFactory(summarizeHistory?: boolean): SharedTreeFactory;
-    /**
-     * Create a new SharedTreeFactory.
-     * @param runtime - The runtime the SharedTree will be associated with
-     * @param id - Unique ID for the SharedTree
-     * @param expensiveValidation - enable expensive asserts
-     * @param summarizeHistory - Determines if the history is included in summaries.
-     */
-    constructor(runtime: IFluidDataStoreRuntime, id: string, expensiveValidation?: boolean, summarizeHistory?: boolean);
-    private _editor;
-    /**
-     * Returns a `SharedTreeEditor` for editing this tree in an imperative fashion. All edits are performed on the current tree view.
-     */
-    get editor(): SharedTreeEditor;
-    /**
-     * {@inheritDoc GenericSharedTree.generateSummary}
-     */
-    protected generateSummary(editLog: OrderedEditSet<Change>): SharedTreeSummaryBase;
-}
-//# sourceMappingURL=SharedTree.d.ts.map

package/dist/default-edits/SharedTree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SharedTree.d.ts","sourceRoot":"","sources":["../../src/default-edits/SharedTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAyB,iBAAiB,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACxH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAwB,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAA8B,MAAM,WAAW,CAAC;AAK1E;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;gBAEf,IAAI,EAAE,UAAU;IAInC;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;IAChE;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;IAOnE;;;;OAIG;IACI,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;IAC/D;;;;OAIG;IACI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;IAC7D;;;;OAIG;IACI,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,GAAG,MAAM;IASlE;;;OAGG;IACI,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM;IACvC;;;OAGG;IACI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IACrC;;;OAGG;IACI,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM;IAS1C;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM;IAIzD,OAAO,CAAC,aAAa;CAGrB;AAED;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,iBAAiB,CAAC,MAAM,CAAC;IACxD;;OAEG;WACW,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU;IAI9E;;;;OAIG;WACW,UAAU,CAAC,gBAAgB,UAAO,GAAG,iBAAiB;IAIpE;;;;;;OAMG;gBAEF,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,MAAM,EACV,mBAAmB,UAAQ,EAC3B,gBAAgB,UAAO;IAKxB,OAAO,CAAC,OAAO,CAA+B;IAE9C;;OAEG;IACH,IAAW,MAAM,IAAI,gBAAgB,CAMpC;IAED;;OAEG;IACH,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,qBAAqB;CAMjF"}

package/dist/default-edits/SharedTree.js

@@ -1,124 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedTree = exports.SharedTreeEditor = void 0;
-const generic_1 = require("../generic");
-const PersistedTypes_1 = require("./PersistedTypes");
-const Factory_1 = require("./Factory");
-const HistoryEditFactory = __importStar(require("./HistoryEditFactory"));
-const Transaction_1 = require("./Transaction");
-const Summary_1 = require("./Summary");
-/**
- * Wrapper around a `SharedTree` which provides ergonomic imperative editing functionality. All methods apply changes in their own edit.
- *
- * @example
- * // The following two lines of code are equivalent:
- * tree.applyEdit(...Insert.create([newNode], StablePlace.before(existingNode)));
- * tree.editor.insert(newNode, StablePlace.before(existingNode))
- * @public
- */
-class SharedTreeEditor {
-    constructor(tree) {
-        this.tree = tree;
-    }
-    insert(nodeOrNodes, destination) {
-        return this.tree.applyEdit(...PersistedTypes_1.Insert.create(Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes], destination));
-    }
-    move(source, destination) {
-        if (!this.isStableRange(source)) {
-            return this.tree.applyEdit(...PersistedTypes_1.Move.create(PersistedTypes_1.StableRange.only(source), destination));
-        }
-        return this.tree.applyEdit(...PersistedTypes_1.Move.create(source, destination));
-    }
-    delete(target) {
-        if (!this.isStableRange(target)) {
-            return this.tree.applyEdit(PersistedTypes_1.Delete.create(PersistedTypes_1.StableRange.only(target)));
-        }
-        return this.tree.applyEdit(PersistedTypes_1.Delete.create(target));
-    }
-    /**
-     * Reverts a previous edit.
-     * @param edit - the edit to revert
-     * @param view - the revision to which the edit is applied (not the output of applying edit: it's the one just before that)
-     */
-    revert(edit, view) {
-        return this.tree.applyEdit(...HistoryEditFactory.revert(edit.changes, view));
-    }
-    isStableRange(source) {
-        return source.start !== undefined && source.end !== undefined;
-    }
-}
-exports.SharedTreeEditor = SharedTreeEditor;
-/**
- * A distributed tree.
- * @public
- * @sealed
- */
-class SharedTree extends generic_1.GenericSharedTree {
-    /**
-     * Create a new SharedTreeFactory.
-     * @param runtime - The runtime the SharedTree will be associated with
-     * @param id - Unique ID for the SharedTree
-     * @param expensiveValidation - enable expensive asserts
-     * @param summarizeHistory - Determines if the history is included in summaries.
-     */
-    constructor(runtime, id, expensiveValidation = false, summarizeHistory = true) {
-        super(runtime, id, Transaction_1.Transaction.factory, Factory_1.SharedTreeFactory.Attributes, expensiveValidation, summarizeHistory);
-    }
-    /**
-     * Create a new SharedTree. It will contain the default value (see initialTree).
-     */
-    static create(runtime, id) {
-        return runtime.createChannel(id, Factory_1.SharedTreeFactory.Type);
-    }
-    /**
-     * Get a factory for SharedTree to register with the data store.
-     * @param historySummarizing - determines how history is summarized by the returned `SharedTree`.
-     * @returns A factory that creates `SharedTree`s and loads them from storage.
-     */
-    static getFactory(summarizeHistory = true) {
-        return summarizeHistory ? new Factory_1.SharedTreeFactory() : new Factory_1.SharedTreeFactoryNoHistory();
-    }
-    /**
-     * Returns a `SharedTreeEditor` for editing this tree in an imperative fashion. All edits are performed on the current tree view.
-     */
-    get editor() {
-        if (!this._editor) {
-            this._editor = new SharedTreeEditor(this);
-        }
-        return this._editor;
-    }
-    /**
-     * {@inheritDoc GenericSharedTree.generateSummary}
-     */
-    generateSummary(editLog) {
-        if (!this.summarizeHistory) {
-            return Summary_1.noHistorySummarizer(editLog, this.currentView);
-        }
-        return generic_1.fullHistorySummarizer(editLog, this.currentView);
-    }
-}
-exports.SharedTree = SharedTree;
-//# sourceMappingURL=SharedTree.js.map

package/dist/default-edits/SharedTree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SharedTree.js","sourceRoot":"","sources":["../../src/default-edits/SharedTree.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';\nimport { EditId, NodeId } from '../Identifiers';\nimport { Snapshot } from '../Snapshot';\nimport { Edit, BuildNode, fullHistorySummarizer, GenericSharedTree, NodeData, SharedTreeSummaryBase } from '../generic';\nimport { OrderedEditSet } from '../EditLog';\nimport { Change, Delete, Insert, Move, StableRange, StablePlace } from './PersistedTypes';\nimport { SharedTreeFactory, SharedTreeFactoryNoHistory } from './Factory';\nimport * as HistoryEditFactory from './HistoryEditFactory';\nimport { Transaction } from './Transaction';\nimport { noHistorySummarizer } from './Summary';\n\n/**\n * Wrapper around a `SharedTree` which provides ergonomic imperative editing functionality. All methods apply changes in their own edit.\n *\n * @example\n * // The following two lines of code are equivalent:\n * tree.applyEdit(...Insert.create([newNode], StablePlace.before(existingNode)));\n * tree.editor.insert(newNode, StablePlace.before(existingNode))\n * @public\n */\nexport class SharedTreeEditor {\n\tprivate readonly tree: SharedTree;\n\n\tpublic constructor(tree: SharedTree) {\n\t\tthis.tree = tree;\n\t}\n\n\t/**\n\t * Inserts a node at a location.\n\t * @param node - Node to insert.\n\t * @param destination - StablePlace at which the insert should take place.\n\t */\n\tpublic insert(node: BuildNode, destination: StablePlace): EditId;\n\t/**\n\t * Inserts nodes at a location.\n\t * @param nodes - Nodes to insert.\n\t * @param destination - StablePlace at which the insert should take place.\n\t */\n\tpublic insert(nodes: BuildNode[], destination: StablePlace): EditId;\n\tpublic insert(nodeOrNodes: BuildNode | BuildNode[], destination: StablePlace): EditId {\n\t\treturn this.tree.applyEdit(\n\t\t\t...Insert.create(Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes], destination)\n\t\t);\n\t}\n\n\t/**\n\t * Moves a node to a specified location.\n\t * @param source - Node to move.\n\t * @param destination - StablePlace to which the node should be moved.\n\t */\n\tpublic move(source: NodeData, destination: StablePlace): EditId;\n\t/**\n\t * Moves a node to a specified location.\n\t * @param source - Node to move.\n\t * @param destination - StablePlace to which the node should be moved.\n\t */\n\tpublic move(source: NodeId, destination: StablePlace): EditId;\n\t/**\n\t * Moves a part of a trait to a specified location.\n\t * @param source - Portion of a trait to move.\n\t * @param destination - StablePlace to which the portion of the trait should be moved.\n\t */\n\tpublic move(source: StableRange, destination: StablePlace): EditId;\n\tpublic move(source: NodeData | NodeId | StableRange, destination: StablePlace): EditId {\n\t\tif (!this.isStableRange(source)) {\n\t\t\treturn this.tree.applyEdit(...Move.create(StableRange.only(source), destination));\n\t\t}\n\n\t\treturn this.tree.applyEdit(...Move.create(source, destination));\n\t}\n\n\t/**\n\t * Deletes a node.\n\t * @param target - Node to delete\n\t */\n\tpublic delete(target: NodeData): EditId;\n\t/**\n\t * Deletes a node.\n\t * @param target - Node to delete\n\t */\n\tpublic delete(target: NodeId): EditId;\n\t/**\n\t * Deletes a portion of a trait.\n\t * @param target - Range of nodes to delete, specified as a `StableRange`\n\t */\n\tpublic delete(target: StableRange): EditId;\n\tpublic delete(target: NodeData | NodeId | StableRange): EditId {\n\t\tif (!this.isStableRange(target)) {\n\t\t\treturn this.tree.applyEdit(Delete.create(StableRange.only(target)));\n\t\t}\n\n\t\treturn this.tree.applyEdit(Delete.create(target));\n\t}\n\n\t/**\n\t * Reverts a previous edit.\n\t * @param edit - the edit to revert\n\t * @param view - the revision to which the edit is applied (not the output of applying edit: it's the one just before that)\n\t */\n\tpublic revert(edit: Edit<Change>, view: Snapshot): EditId {\n\t\treturn this.tree.applyEdit(...HistoryEditFactory.revert(edit.changes, view));\n\t}\n\n\tprivate isStableRange(source: NodeData | NodeId | StableRange): source is StableRange {\n\t\treturn (source as StableRange).start !== undefined && (source as StableRange).end !== undefined;\n\t}\n}\n\n/**\n * A distributed tree.\n * @public\n * @sealed\n */\nexport class SharedTree extends GenericSharedTree<Change> {\n\t/**\n\t * Create a new SharedTree. It will contain the default value (see initialTree).\n\t */\n\tpublic static create(runtime: IFluidDataStoreRuntime, id?: string): SharedTree {\n\t\treturn runtime.createChannel(id, SharedTreeFactory.Type) as SharedTree;\n\t}\n\n\t/**\n\t * Get a factory for SharedTree to register with the data store.\n\t * @param historySummarizing - determines how history is summarized by the returned `SharedTree`.\n\t * @returns A factory that creates `SharedTree`s and loads them from storage.\n\t */\n\tpublic static getFactory(summarizeHistory = true): SharedTreeFactory {\n\t\treturn summarizeHistory ? new SharedTreeFactory() : new SharedTreeFactoryNoHistory();\n\t}\n\n\t/**\n\t * Create a new SharedTreeFactory.\n\t * @param runtime - The runtime the SharedTree will be associated with\n\t * @param id - Unique ID for the SharedTree\n\t * @param expensiveValidation - enable expensive asserts\n\t * @param summarizeHistory - Determines if the history is included in summaries.\n\t */\n\tpublic constructor(\n\t\truntime: IFluidDataStoreRuntime,\n\t\tid: string,\n\t\texpensiveValidation = false,\n\t\tsummarizeHistory = true\n\t) {\n\t\tsuper(runtime, id, Transaction.factory, SharedTreeFactory.Attributes, expensiveValidation, summarizeHistory);\n\t}\n\n\tprivate _editor: SharedTreeEditor | undefined;\n\n\t/**\n\t * Returns a `SharedTreeEditor` for editing this tree in an imperative fashion. All edits are performed on the current tree view.\n\t */\n\tpublic get editor(): SharedTreeEditor {\n\t\tif (!this._editor) {\n\t\t\tthis._editor = new SharedTreeEditor(this);\n\t\t}\n\n\t\treturn this._editor;\n\t}\n\n\t/**\n\t * {@inheritDoc GenericSharedTree.generateSummary}\n\t */\n\tprotected generateSummary(editLog: OrderedEditSet<Change>): SharedTreeSummaryBase {\n\t\tif (!this.summarizeHistory) {\n\t\t\treturn noHistorySummarizer(editLog, this.currentView);\n\t\t}\n\t\treturn fullHistorySummarizer(editLog, this.currentView);\n\t}\n}\n"]}

package/dist/default-edits/Summary.d.ts

@@ -1,15 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { OrderedEditSet } from '../EditLog';
-import { Snapshot } from '../Snapshot';
-import { SharedTreeSummary_0_0_2 } from '../SummaryBackCompatibility';
-import { Change } from './PersistedTypes';
-/**
- * Does not preserve (persist) history at all.
- * Instead, the history returned in the summary will contain a single change that creates a revision identical to the supplied view.
- * @public
- */
-export declare function noHistorySummarizer(_editLog: OrderedEditSet<Change>, currentView: Snapshot): SharedTreeSummary_0_0_2<Change>;
-//# sourceMappingURL=Summary.d.ts.map

package/dist/default-edits/Summary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Summary.d.ts","sourceRoot":"","sources":["../../src/default-edits/Summary.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,QAAQ,GACnB,uBAAuB,CAAC,MAAM,CAAC,CAoBjC"}

package/dist/default-edits/Summary.js

@@ -1,35 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noHistorySummarizer = void 0;
-const Common_1 = require("../Common");
-const InitialTree_1 = require("../InitialTree");
-const generic_1 = require("../generic");
-const EditUtilities_1 = require("./EditUtilities");
-/**
- * Does not preserve (persist) history at all.
- * Instead, the history returned in the summary will contain a single change that creates a revision identical to the supplied view.
- * @public
- */
-function noHistorySummarizer(_editLog, currentView) {
-    const currentTree = currentView.getChangeNodeTree();
-    const rootId = currentTree.identifier;
-    const changes = [];
-    // Generate a set of changes to set the root node's children to that of the root in the currentTree
-    Object.entries(currentTree.traits).forEach(([label, children]) => {
-        changes.push(...EditUtilities_1.setTrait({ parent: rootId, label: label }, children));
-    });
-    Common_1.assert(currentTree.payload === undefined, 'setValue not yet supported.');
-    Common_1.assert(currentTree.identifier === InitialTree_1.initialTree.identifier && currentTree.definition === InitialTree_1.initialTree.definition, 'root definition and identifier should be immutable.');
-    const edit = generic_1.newEdit(changes);
-    return {
-        currentTree,
-        sequencedEdits: [{ id: edit.id, changes: edit.changes }],
-        version: generic_1.formatVersion,
-    };
-}
-exports.noHistorySummarizer = noHistorySummarizer;
-//# sourceMappingURL=Summary.js.map

package/dist/default-edits/Summary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Summary.js","sourceRoot":"","sources":["../../src/default-edits/Summary.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,sCAAmC;AAGnC,gDAA6C;AAE7C,wCAAoD;AAEpD,mDAA2C;AAE3C;;;;GAIG;AACH,SAAgB,mBAAmB,CAClC,QAAgC,EAChC,WAAqB;IAErB,MAAM,WAAW,GAAG,WAAW,CAAC,iBAAiB,EAAE,CAAC;IACpD,MAAM,MAAM,GAAG,WAAW,CAAC,UAAU,CAAC;IACtC,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,mGAAmG;IACnG,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE;QAChE,OAAO,CAAC,IAAI,CAAC,GAAG,wBAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAmB,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;IACrF,CAAC,CAAC,CAAC;IACH,eAAM,CAAC,WAAW,CAAC,OAAO,KAAK,SAAS,EAAE,6BAA6B,CAAC,CAAC;IACzE,eAAM,CACL,WAAW,CAAC,UAAU,KAAK,yBAAW,CAAC,UAAU,IAAI,WAAW,CAAC,UAAU,KAAK,yBAAW,CAAC,UAAU,EACtG,qDAAqD,CACrD,CAAC;IACF,MAAM,IAAI,GAAG,iBAAO,CAAC,OAAO,CAAC,CAAC;IAE9B,OAAO;QACN,WAAW;QACX,cAAc,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;QACxD,OAAO,EAAE,uBAAa;KACtB,CAAC;AACH,CAAC;AAvBD,kDAuBC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { TraitLabel } from '../Identifiers';\nimport { assert } from '../Common';\nimport { OrderedEditSet } from '../EditLog';\nimport { Snapshot } from '../Snapshot';\nimport { initialTree } from '../InitialTree';\nimport { SharedTreeSummary_0_0_2 } from '../SummaryBackCompatibility';\nimport { formatVersion, newEdit } from '../generic';\nimport { Change } from './PersistedTypes';\nimport { setTrait } from './EditUtilities';\n\n/**\n * Does not preserve (persist) history at all.\n * Instead, the history returned in the summary will contain a single change that creates a revision identical to the supplied view.\n * @public\n */\nexport function noHistorySummarizer(\n\t_editLog: OrderedEditSet<Change>,\n\tcurrentView: Snapshot\n): SharedTreeSummary_0_0_2<Change> {\n\tconst currentTree = currentView.getChangeNodeTree();\n\tconst rootId = currentTree.identifier;\n\tconst changes: Change[] = [];\n\t// Generate a set of changes to set the root node's children to that of the root in the currentTree\n\tObject.entries(currentTree.traits).forEach(([label, children]) => {\n\t\tchanges.push(...setTrait({ parent: rootId, label: label as TraitLabel }, children));\n\t});\n\tassert(currentTree.payload === undefined, 'setValue not yet supported.');\n\tassert(\n\t\tcurrentTree.identifier === initialTree.identifier && currentTree.definition === initialTree.definition,\n\t\t'root definition and identifier should be immutable.'\n\t);\n\tconst edit = newEdit(changes);\n\n\treturn {\n\t\tcurrentTree,\n\t\tsequencedEdits: [{ id: edit.id, changes: edit.changes }],\n\t\tversion: formatVersion,\n\t};\n}\n"]}