@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/modular-schema/crossFieldQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossFieldQueries.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/crossFieldQueries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EACN,QAAQ,EACR,gBAAgB,EAIhB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,GAAG,CAAC,WAAW,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;AAExD,wBAAgB,kBAAkB,CACjC,GAAG,EAAE,kBAAkB,EACvB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,MAAM,GACX,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,GACN,IAAI,CAEN;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAC1C,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,EACrB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,MAAM,GACX,gBAAgB,CAAC,CAAC,CAAC,CAErB;AAED;;GAEG;AACH,oBAAY,gBAAgB;IAC3B,MAAM,IAAA;IACN,WAAW,IAAA;CACX;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC7C;;;OAGG;IACH,GAAG,CACF,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,OAAO,GACpB,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAEvB;;;;OAIG;IACH,GAAG,CACF,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,EAAE,EAAE,gBAAgB,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,EACX,oBAAoB,EAAE,OAAO,GAC3B,IAAI,CAAC;CACR"}

package/dist/feature-libraries/modular-schema/crossFieldQueries.js

@@ -0,0 +1,29 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossFieldTarget = exports.getFirstFromCrossFieldMap = exports.setInCrossFieldMap = exports.addCrossFieldQuery = void 0;
+const util_1 = require("../../util");
+function addCrossFieldQuery(set, revision, id, count) {
+    setInCrossFieldMap(set, revision, id, count, true);
+}
+exports.addCrossFieldQuery = addCrossFieldQuery;
+function setInCrossFieldMap(map, revision, id, count, value) {
+    (0, util_1.setInRangeMap)((0, util_1.getOrAddInMap)(map, revision, []), id, count, value);
+}
+exports.setInCrossFieldMap = setInCrossFieldMap;
+function getFirstFromCrossFieldMap(map, revision, id, count) {
+    return (0, util_1.getFromRangeMap)(map.get(revision) ?? [], id, count);
+}
+exports.getFirstFromCrossFieldMap = getFirstFromCrossFieldMap;
+/**
+ * @internal
+ */
+var CrossFieldTarget;
+(function (CrossFieldTarget) {
+    CrossFieldTarget[CrossFieldTarget["Source"] = 0] = "Source";
+    CrossFieldTarget[CrossFieldTarget["Destination"] = 1] = "Destination";
+})(CrossFieldTarget || (exports.CrossFieldTarget = CrossFieldTarget = {}));
+//# sourceMappingURL=crossFieldQueries.js.map

package/dist/feature-libraries/modular-schema/crossFieldQueries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossFieldQueries.js","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/crossFieldQueries.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,qCAMoB;AAKpB,SAAgB,kBAAkB,CACjC,GAAuB,EACvB,QAAiC,EACjC,EAAoB,EACpB,KAAa;IAEb,kBAAkB,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACpD,CAAC;AAPD,gDAOC;AAED,SAAgB,kBAAkB,CACjC,GAAqB,EACrB,QAAiC,EACjC,EAAoB,EACpB,KAAa,EACb,KAAQ;IAER,IAAA,oBAAa,EAAC,IAAA,oBAAa,EAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACnE,CAAC;AARD,gDAQC;AAED,SAAgB,yBAAyB,CACxC,GAAqB,EACrB,QAAiC,EACjC,EAAoB,EACpB,KAAa;IAEb,OAAO,IAAA,sBAAe,EAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;AAC5D,CAAC;AAPD,8DAOC;AAED;;GAEG;AACH,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC3B,2DAAM,CAAA;IACN,qEAAW,CAAA;AACZ,CAAC,EAHW,gBAAgB,gCAAhB,gBAAgB,QAG3B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ChangesetLocalId, RevisionTag } from \"../../core\";\nimport {\n\tRangeMap,\n\tRangeQueryResult,\n\tgetFromRangeMap,\n\tgetOrAddInMap,\n\tsetInRangeMap,\n} from \"../../util\";\n\nexport type CrossFieldMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;\nexport type CrossFieldQuerySet = CrossFieldMap<boolean>;\n\nexport function addCrossFieldQuery(\n\tset: CrossFieldQuerySet,\n\trevision: RevisionTag | undefined,\n\tid: ChangesetLocalId,\n\tcount: number,\n): void {\n\tsetInCrossFieldMap(set, revision, id, count, true);\n}\n\nexport function setInCrossFieldMap<T>(\n\tmap: CrossFieldMap<T>,\n\trevision: RevisionTag | undefined,\n\tid: ChangesetLocalId,\n\tcount: number,\n\tvalue: T,\n): void {\n\tsetInRangeMap(getOrAddInMap(map, revision, []), id, count, value);\n}\n\nexport function getFirstFromCrossFieldMap<T>(\n\tmap: CrossFieldMap<T>,\n\trevision: RevisionTag | undefined,\n\tid: ChangesetLocalId,\n\tcount: number,\n): RangeQueryResult<T> {\n\treturn getFromRangeMap(map.get(revision) ?? [], id, count);\n}\n\n/**\n * @internal\n */\nexport enum CrossFieldTarget {\n\tSource,\n\tDestination,\n}\n\n/**\n * Used by {@link FieldChangeHandler} implementations for exchanging information across other fields\n * while rebasing, composing, or inverting a change.\n * @internal\n */\nexport interface CrossFieldManager<T = unknown> {\n\t/**\n\t * Returns the first data range associated with the key of `target`, `revision`, between `id` and `id + count`.\n\t * Calling this records a dependency for the current field on this key if `addDependency` is true.\n\t */\n\tget(\n\t\ttarget: CrossFieldTarget,\n\t\trevision: RevisionTag | undefined,\n\t\tid: ChangesetLocalId,\n\t\tcount: number,\n\t\taddDependency: boolean,\n\t): RangeQueryResult<T>;\n\n\t/**\n\t * Sets the range of keys to `newValue`.\n\t * If `invalidateDependents` is true, all fields which took a dependency on this key will be considered invalidated\n\t * and will be given a chance to address the new data in `amendCompose`, or a second pass of `rebase` or `invert` as appropriate.\n\t */\n\tset(\n\t\ttarget: CrossFieldTarget,\n\t\trevision: RevisionTag | undefined,\n\t\tid: ChangesetLocalId,\n\t\tcount: number,\n\t\tnewValue: T,\n\t\tinvalidateDependents: boolean,\n\t): void;\n}\n"]}

package/dist/feature-libraries/modular-schema/fieldChangeHandler.d.ts

@@ -0,0 +1,140 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TaggedChange, RevisionTag, RevisionMetadataSource, DeltaFieldMap, DeltaFieldChanges, DeltaDetachedNodeId, EncodedRevisionTag } from "../../core";
+import { IdAllocator, Invariant } from "../../util";
+import { ICodecFamily, IJsonCodec } from "../../codec";
+import { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator";
+import { CrossFieldManager } from "./crossFieldQueries";
+import { NodeChangeset } from "./modularChangeTypes";
+/**
+ * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to
+ * implement a unified ChangeFamily supporting documents with multiple field kinds.
+ */
+export interface FieldChangeHandler<TChangeset, TEditor extends FieldEditor<TChangeset> = FieldEditor<TChangeset>> {
+    _typeCheck?: Invariant<TChangeset>;
+    readonly rebaser: FieldChangeRebaser<TChangeset>;
+    readonly codecsFactory: (childCodec: IJsonCodec<NodeChangeset>, revisionTagCodec: IJsonCodec<RevisionTag, EncodedRevisionTag>) => ICodecFamily<TChangeset>;
+    readonly editor: TEditor;
+    intoDelta(change: TaggedChange<TChangeset>, deltaFromChild: ToDelta, idAllocator: MemoizedIdRangeAllocator): DeltaFieldChanges;
+    /**
+     * Returns the set of removed roots that should be in memory for the given change to be applied.
+     * A removed root is relevant if any of the following is true:
+     * - It is being inserted
+     * - It is being restored
+     * - It is being edited
+     * - The ID it is associated with is being changed
+     *
+     * Implementations are allowed to be conservative by returning more removed roots than strictly necessary
+     * (though they should, for the sake of performance, try to avoid doing so).
+     *
+     * Implementations are not allowed to return IDs for non-root trees, even if they are removed.
+     *
+     * @param change - The change to be applied.
+     * @param relevantRemovedRootsFromChild - Delegate for collecting relevant removed roots from child changes.
+     */
+    readonly relevantRemovedRoots: (change: TaggedChange<TChangeset>, relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild) => Iterable<DeltaDetachedNodeId>;
+    /**
+     * Returns whether this change is empty, meaning that it represents no modifications to the field
+     * and could be removed from the ModularChangeset tree without changing its behavior.
+     */
+    isEmpty(change: TChangeset): boolean;
+}
+export interface FieldChangeRebaser<TChangeset> {
+    /**
+     * Compose a collection of changesets into a single one.
+     * Every child included in the composed change must be the result of a call to `composeChild`,
+     * and should be tagged with the revision of its parent change.
+     * Children which were the result of an earlier call to `composeChild` should be tagged with
+     * undefined revision if later passed as an argument to `composeChild`.
+     * See `ChangeRebaser` for more details.
+     */
+    compose(changes: TaggedChange<TChangeset>[], composeChild: NodeChangeComposer, genId: IdAllocator, crossFieldManager: CrossFieldManager, revisionMetadata: RevisionMetadataSource): TChangeset;
+    /**
+     * Amend `composedChange` with respect to new data in `crossFieldManager`.
+     */
+    amendCompose(composedChange: TChangeset, composeChild: NodeChangeComposer, genId: IdAllocator, crossFieldManager: CrossFieldManager, revisionMetadata: RevisionMetadataSource): TChangeset;
+    /**
+     * @returns the inverse of `changes`.
+     * See `ChangeRebaser` for details.
+     */
+    invert(change: TaggedChange<TChangeset>, invertChild: NodeChangeInverter, genId: IdAllocator, crossFieldManager: CrossFieldManager, revisionMetadata: RevisionMetadataSource): TChangeset;
+    /**
+     * Rebase `change` over `over`.
+     * See `ChangeRebaser` for details.
+     */
+    rebase(change: TChangeset, over: TaggedChange<TChangeset>, rebaseChild: NodeChangeRebaser, genId: IdAllocator, crossFieldManager: CrossFieldManager, revisionMetadata: RebaseRevisionMetadata, existenceState?: NodeExistenceState): TChangeset;
+    /**
+     * @returns `change` with any empty child node changesets removed.
+     */
+    prune(change: TChangeset, pruneChild: NodeChangePruner): TChangeset;
+}
+/**
+ * Helper for creating a {@link FieldChangeRebaser} which does not need access to revision tags.
+ * This should only be used for fields where the child nodes cannot be edited.
+ */
+export declare function referenceFreeFieldChangeRebaser<TChangeset>(data: {
+    compose: (changes: TChangeset[]) => TChangeset;
+    invert: (change: TChangeset) => TChangeset;
+    rebase: (change: TChangeset, over: TChangeset) => TChangeset;
+}): FieldChangeRebaser<TChangeset>;
+export declare function isolatedFieldChangeRebaser<TChangeset>(data: {
+    compose: FieldChangeRebaser<TChangeset>["compose"];
+    invert: FieldChangeRebaser<TChangeset>["invert"];
+    rebase: FieldChangeRebaser<TChangeset>["rebase"];
+}): FieldChangeRebaser<TChangeset>;
+export interface FieldEditor<TChangeset> {
+    /**
+     * Creates a changeset which represents the given `change` to the child at `childIndex` of this editor's field.
+     */
+    buildChildChange(childIndex: number, change: NodeChangeset): TChangeset;
+}
+/**
+ * The `index` represents the index of the child node in the input context.
+ * The `index` should be `undefined` iff the child node does not exist in the input context (e.g., an inserted node).
+ * @internal
+ */
+export type ToDelta = (child: NodeChangeset) => DeltaFieldMap;
+/**
+ * @internal
+ */
+export type NodeChangeInverter = (change: NodeChangeset) => NodeChangeset;
+/**
+ * @internal
+ */
+export declare enum NodeExistenceState {
+    Alive = 0,
+    Dead = 1
+}
+/**
+ * @internal
+ */
+export type NodeChangeRebaser = (change: NodeChangeset | undefined, baseChange: NodeChangeset | undefined, 
+/**
+ * Whether or not the node is alive or dead in the input context of change.
+ * Defaults to Alive if undefined.
+ */
+state?: NodeExistenceState) => NodeChangeset | undefined;
+/**
+ * @internal
+ */
+export type NodeChangeComposer = (changes: TaggedChange<NodeChangeset>[]) => NodeChangeset;
+/**
+ * @internal
+ */
+export type NodeChangePruner = (change: NodeChangeset) => NodeChangeset | undefined;
+/**
+ * A function that returns the set of removed roots that should be in memory for a given node changeset to be applied.
+ *
+ * @internal
+ */
+export type RelevantRemovedRootsFromChild = (child: NodeChangeset) => Iterable<DeltaDetachedNodeId>;
+export interface RebaseRevisionMetadata extends RevisionMetadataSource {
+    readonly getBaseRevisions: () => RevisionTag[];
+}
+/**
+ * @internal
+ */
+export declare function getIntention(rev: RevisionTag | undefined, revisionMetadata: RevisionMetadataSource): RevisionTag | undefined;
+//# sourceMappingURL=fieldChangeHandler.d.ts.map

package/dist/feature-libraries/modular-schema/fieldChangeHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldChangeHandler.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/fieldChangeHandler.ts"],"names":[],"mappings":"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"}

package/dist/feature-libraries/modular-schema/fieldChangeHandler.js

@@ -0,0 +1,44 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntention = exports.NodeExistenceState = exports.isolatedFieldChangeRebaser = exports.referenceFreeFieldChangeRebaser = void 0;
+const util_1 = require("../../util");
+/**
+ * Helper for creating a {@link FieldChangeRebaser} which does not need access to revision tags.
+ * This should only be used for fields where the child nodes cannot be edited.
+ */
+function referenceFreeFieldChangeRebaser(data) {
+    return isolatedFieldChangeRebaser({
+        compose: (changes, _composeChild, _genId) => data.compose(changes.map((c) => c.change)),
+        invert: (change, _invertChild, _genId) => data.invert(change.change),
+        rebase: (change, over, _rebaseChild, _genId) => data.rebase(change, over.change),
+    });
+}
+exports.referenceFreeFieldChangeRebaser = referenceFreeFieldChangeRebaser;
+function isolatedFieldChangeRebaser(data) {
+    return {
+        ...data,
+        amendCompose: () => (0, util_1.fail)("Not implemented"),
+        prune: (change) => change,
+    };
+}
+exports.isolatedFieldChangeRebaser = isolatedFieldChangeRebaser;
+/**
+ * @internal
+ */
+var NodeExistenceState;
+(function (NodeExistenceState) {
+    NodeExistenceState[NodeExistenceState["Alive"] = 0] = "Alive";
+    NodeExistenceState[NodeExistenceState["Dead"] = 1] = "Dead";
+})(NodeExistenceState || (exports.NodeExistenceState = NodeExistenceState = {}));
+/**
+ * @internal
+ */
+function getIntention(rev, revisionMetadata) {
+    return revisionMetadata.tryGetInfo(rev)?.rollbackOf ?? rev;
+}
+exports.getIntention = getIntention;
+//# sourceMappingURL=fieldChangeHandler.js.map

package/dist/feature-libraries/modular-schema/fieldChangeHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldChangeHandler.js","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/fieldChangeHandler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAWH,qCAA0D;AAkH1D;;;GAGG;AACH,SAAgB,+BAA+B,CAAa,IAI3D;IACA,OAAO,0BAA0B,CAAC;QACjC,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACvF,MAAM,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QACpE,MAAM,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;KAChF,CAAC,CAAC;AACJ,CAAC;AAVD,0EAUC;AAED,SAAgB,0BAA0B,CAAa,IAItD;IACA,OAAO;QACN,GAAG,IAAI;QACP,YAAY,EAAE,GAAG,EAAE,CAAC,IAAA,WAAI,EAAC,iBAAiB,CAAC;QAC3C,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM;KACzB,CAAC;AACH,CAAC;AAVD,gEAUC;AAqBD;;GAEG;AACH,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC7B,6DAAK,CAAA;IACL,2DAAI,CAAA;AACL,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B;AAoCD;;GAEG;AACH,SAAgB,YAAY,CAC3B,GAA4B,EAC5B,gBAAwC;IAExC,OAAO,gBAAgB,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,UAAU,IAAI,GAAG,CAAC;AAC5D,CAAC;AALD,oCAKC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tTaggedChange,\n\tRevisionTag,\n\tRevisionMetadataSource,\n\tDeltaFieldMap,\n\tDeltaFieldChanges,\n\tDeltaDetachedNodeId,\n\tEncodedRevisionTag,\n} from \"../../core\";\nimport { fail, IdAllocator, Invariant } from \"../../util\";\nimport { ICodecFamily, IJsonCodec } from \"../../codec\";\nimport { MemoizedIdRangeAllocator } from \"../memoizedIdRangeAllocator\";\nimport { CrossFieldManager } from \"./crossFieldQueries\";\nimport { NodeChangeset } from \"./modularChangeTypes\";\n\n/**\n * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to\n * implement a unified ChangeFamily supporting documents with multiple field kinds.\n */\nexport interface FieldChangeHandler<\n\tTChangeset,\n\tTEditor extends FieldEditor<TChangeset> = FieldEditor<TChangeset>,\n> {\n\t_typeCheck?: Invariant<TChangeset>;\n\treadonly rebaser: FieldChangeRebaser<TChangeset>;\n\treadonly codecsFactory: (\n\t\tchildCodec: IJsonCodec<NodeChangeset>,\n\t\trevisionTagCodec: IJsonCodec<RevisionTag, EncodedRevisionTag>,\n\t) => ICodecFamily<TChangeset>;\n\treadonly editor: TEditor;\n\tintoDelta(\n\t\tchange: TaggedChange<TChangeset>,\n\t\tdeltaFromChild: ToDelta,\n\t\tidAllocator: MemoizedIdRangeAllocator,\n\t): DeltaFieldChanges;\n\t/**\n\t * Returns the set of removed roots that should be in memory for the given change to be applied.\n\t * A removed root is relevant if any of the following is true:\n\t * - It is being inserted\n\t * - It is being restored\n\t * - It is being edited\n\t * - The ID it is associated with is being changed\n\t *\n\t * Implementations are allowed to be conservative by returning more removed roots than strictly necessary\n\t * (though they should, for the sake of performance, try to avoid doing so).\n\t *\n\t * Implementations are not allowed to return IDs for non-root trees, even if they are removed.\n\t *\n\t * @param change - The change to be applied.\n\t * @param relevantRemovedRootsFromChild - Delegate for collecting relevant removed roots from child changes.\n\t */\n\treadonly relevantRemovedRoots: (\n\t\tchange: TaggedChange<TChangeset>,\n\t\trelevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,\n\t) => Iterable<DeltaDetachedNodeId>;\n\n\t/**\n\t * Returns whether this change is empty, meaning that it represents no modifications to the field\n\t * and could be removed from the ModularChangeset tree without changing its behavior.\n\t */\n\tisEmpty(change: TChangeset): boolean;\n}\n\nexport interface FieldChangeRebaser<TChangeset> {\n\t/**\n\t * Compose a collection of changesets into a single one.\n\t * Every child included in the composed change must be the result of a call to `composeChild`,\n\t * and should be tagged with the revision of its parent change.\n\t * Children which were the result of an earlier call to `composeChild` should be tagged with\n\t * undefined revision if later passed as an argument to `composeChild`.\n\t * See `ChangeRebaser` for more details.\n\t */\n\tcompose(\n\t\tchanges: TaggedChange<TChangeset>[],\n\t\tcomposeChild: NodeChangeComposer,\n\t\tgenId: IdAllocator,\n\t\tcrossFieldManager: CrossFieldManager,\n\t\trevisionMetadata: RevisionMetadataSource,\n\t): TChangeset;\n\n\t/**\n\t * Amend `composedChange` with respect to new data in `crossFieldManager`.\n\t */\n\tamendCompose(\n\t\tcomposedChange: TChangeset,\n\t\tcomposeChild: NodeChangeComposer,\n\t\tgenId: IdAllocator,\n\t\tcrossFieldManager: CrossFieldManager,\n\t\trevisionMetadata: RevisionMetadataSource,\n\t): TChangeset;\n\n\t/**\n\t * @returns the inverse of `changes`.\n\t * See `ChangeRebaser` for details.\n\t */\n\tinvert(\n\t\tchange: TaggedChange<TChangeset>,\n\t\tinvertChild: NodeChangeInverter,\n\t\tgenId: IdAllocator,\n\t\tcrossFieldManager: CrossFieldManager,\n\t\trevisionMetadata: RevisionMetadataSource,\n\t): TChangeset;\n\n\t/**\n\t * Rebase `change` over `over`.\n\t * See `ChangeRebaser` for details.\n\t */\n\trebase(\n\t\tchange: TChangeset,\n\t\tover: TaggedChange<TChangeset>,\n\t\trebaseChild: NodeChangeRebaser,\n\t\tgenId: IdAllocator,\n\t\tcrossFieldManager: CrossFieldManager,\n\t\trevisionMetadata: RebaseRevisionMetadata,\n\t\texistenceState?: NodeExistenceState,\n\t): TChangeset;\n\n\t/**\n\t * @returns `change` with any empty child node changesets removed.\n\t */\n\tprune(change: TChangeset, pruneChild: NodeChangePruner): TChangeset;\n}\n\n/**\n * Helper for creating a {@link FieldChangeRebaser} which does not need access to revision tags.\n * This should only be used for fields where the child nodes cannot be edited.\n */\nexport function referenceFreeFieldChangeRebaser<TChangeset>(data: {\n\tcompose: (changes: TChangeset[]) => TChangeset;\n\tinvert: (change: TChangeset) => TChangeset;\n\trebase: (change: TChangeset, over: TChangeset) => TChangeset;\n}): FieldChangeRebaser<TChangeset> {\n\treturn isolatedFieldChangeRebaser({\n\t\tcompose: (changes, _composeChild, _genId) => data.compose(changes.map((c) => c.change)),\n\t\tinvert: (change, _invertChild, _genId) => data.invert(change.change),\n\t\trebase: (change, over, _rebaseChild, _genId) => data.rebase(change, over.change),\n\t});\n}\n\nexport function isolatedFieldChangeRebaser<TChangeset>(data: {\n\tcompose: FieldChangeRebaser<TChangeset>[\"compose\"];\n\tinvert: FieldChangeRebaser<TChangeset>[\"invert\"];\n\trebase: FieldChangeRebaser<TChangeset>[\"rebase\"];\n}): FieldChangeRebaser<TChangeset> {\n\treturn {\n\t\t...data,\n\t\tamendCompose: () => fail(\"Not implemented\"),\n\t\tprune: (change) => change,\n\t};\n}\n\nexport interface FieldEditor<TChangeset> {\n\t/**\n\t * Creates a changeset which represents the given `change` to the child at `childIndex` of this editor's field.\n\t */\n\tbuildChildChange(childIndex: number, change: NodeChangeset): TChangeset;\n}\n\n/**\n * The `index` represents the index of the child node in the input context.\n * The `index` should be `undefined` iff the child node does not exist in the input context (e.g., an inserted node).\n * @internal\n */\nexport type ToDelta = (child: NodeChangeset) => DeltaFieldMap;\n\n/**\n * @internal\n */\nexport type NodeChangeInverter = (change: NodeChangeset) => NodeChangeset;\n\n/**\n * @internal\n */\nexport enum NodeExistenceState {\n\tAlive,\n\tDead,\n}\n\n/**\n * @internal\n */\nexport type NodeChangeRebaser = (\n\tchange: NodeChangeset | undefined,\n\tbaseChange: NodeChangeset | undefined,\n\t/**\n\t * Whether or not the node is alive or dead in the input context of change.\n\t * Defaults to Alive if undefined.\n\t */\n\tstate?: NodeExistenceState,\n) => NodeChangeset | undefined;\n\n/**\n * @internal\n */\nexport type NodeChangeComposer = (changes: TaggedChange<NodeChangeset>[]) => NodeChangeset;\n\n/**\n * @internal\n */\nexport type NodeChangePruner = (change: NodeChangeset) => NodeChangeset | undefined;\n\n/**\n * A function that returns the set of removed roots that should be in memory for a given node changeset to be applied.\n *\n * @internal\n */\nexport type RelevantRemovedRootsFromChild = (child: NodeChangeset) => Iterable<DeltaDetachedNodeId>;\n\nexport interface RebaseRevisionMetadata extends RevisionMetadataSource {\n\treadonly getBaseRevisions: () => RevisionTag[];\n}\n\n/**\n * @internal\n */\nexport function getIntention(\n\trev: RevisionTag | undefined,\n\trevisionMetadata: RevisionMetadataSource,\n): RevisionTag | undefined {\n\treturn revisionMetadata.tryGetInfo(rev)?.rollbackOf ?? rev;\n}\n"]}

package/dist/feature-libraries/modular-schema/fieldKind.d.ts

@@ -0,0 +1,94 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { TreeFieldStoredSchema, FieldKindIdentifier, TreeStoredSchema, FieldKindSpecifier, TreeTypeSet } from "../../core";
+import { Multiplicity } from "../multiplicity";
+import { FieldChangeHandler, FieldEditor } from "./fieldChangeHandler";
+/**
+ * Functionality for FieldKinds that is stable,
+ * meaning that it can not change in any measurable way without providing a new identifier.
+ *
+ * It is assumed that this information and policy is available on all clients interacting with a document
+ * using the identifier.
+ *
+ * This must contain enough information to process remote edits to this FieldKind consistently with all clients.
+ * All behavior must be deterministic, and not change across versions of the app/library.
+ *
+ * These policies include the data encoding, change encoding, change rebase and change application.
+ *
+ * @sealed @internal
+ * @privateRemarks
+ * This being @sealed is for users of this package.
+ * This package itself may provide implementations.
+ * This pattern was picked instead of an interface since we do not have a convention for how to mark interfaces as only allowed to be implemented by the package declaring them,
+ * and using a class also gets stronger (nominal) typing for objects which will be down cast.
+ */
+export declare abstract class FieldKind<TName extends string = string, TMultiplicity extends Multiplicity = Multiplicity> implements FieldKindSpecifier {
+    readonly identifier: TName & FieldKindIdentifier;
+    readonly multiplicity: TMultiplicity;
+    /**
+     * @param identifier - Globally scoped identifier.
+     * @param multiplicity - bound on the number of children that fields of this kind may have.
+     * TODO: consider replacing with numeric upper and lower bounds.
+     */
+    protected constructor(identifier: TName & FieldKindIdentifier, multiplicity: TMultiplicity);
+}
+/**
+ * Functionality for FieldKinds that is stable,
+ * meaning that it can not change in any measurable way without providing a new identifier.
+ *
+ * It is assumed that this information and policy is available on all clients interacting with a document
+ * using the identifier.
+ *
+ * This must contain enough information to process remote edits to this FieldKind consistently with all clients.
+ * All behavior must be deterministic, and not change across versions of the app/library.
+ *
+ * These policies include the data encoding, change encoding, change rebase and change application.
+ */
+export declare class FieldKindWithEditor<TEditor extends FieldEditor<any> = FieldEditor<any>, TMultiplicity extends Multiplicity = Multiplicity, TName extends string = string> extends FieldKind<TName, TMultiplicity> {
+    readonly changeHandler: FieldChangeHandler<any, TEditor>;
+    private readonly allowsTreeSupersetOf;
+    readonly handlesEditsFrom: ReadonlySet<FieldKindIdentifier>;
+    /**
+     * @param identifier - Globally scoped identifier.
+     * @param multiplicity - bound on the number of children that fields of this kind may have.
+     * TODO: replace with numeric upper and lower bounds.
+     * @param changeHandler - Change handling policy.
+     * @param allowsTreeSupersetOf - returns true iff `superset` supports all that this does
+     * and `superset` is an allowed upgrade. Does not have to handle the `never` cases.
+     * See {@link isNeverField}.
+     * TODO: when used as a method (instead of a free function like the other superset related functions),
+     * this name is/signature is confusing and seems backwards.
+     * @param handlesEditsFrom - Kinds (in addition to this) whose edits can be processed by changeHandler.
+     * If the kind of a field changes, and edits are rebased across that kind change,
+     * listing the other old kind here can prevent those edits from being conflicted and
+     * provide a chance to handle them.
+     */
+    constructor(identifier: TName, multiplicity: TMultiplicity, changeHandler: FieldChangeHandler<any, TEditor>, allowsTreeSupersetOf: (originalTypes: TreeTypeSet, superset: TreeFieldStoredSchema) => boolean, handlesEditsFrom: ReadonlySet<FieldKindIdentifier>);
+    /**
+     * @returns true iff `superset` permits a (non-strict) superset of the subtrees
+     * allowed by field made from `this` and `originalTypes`.
+     */
+    allowsFieldSuperset(policy: FullSchemaPolicy, originalData: TreeStoredSchema, originalTypes: TreeTypeSet, superset: TreeFieldStoredSchema): boolean;
+}
+/**
+ * Downcasts to FieldKindWithEditor.
+ */
+export declare function withEditor<TName extends string = string, TMultiplicity extends Multiplicity = Multiplicity>(kind: FieldKind<TName, TMultiplicity>): FieldKindWithEditor<FieldEditor<any>, TMultiplicity, TName>;
+/**
+ * Policy from the app for interpreting the stored schema.
+ * The app must ensure consistency for all users of the document.
+ * @internal
+ */
+export interface FullSchemaPolicy {
+    /**
+     * Policy information about FieldKinds:
+     * This is typically stored as code, not in documents, and defines how to handles fields based on their kind.
+     * It is assumed that all users of a document will have exactly the same FieldKind policies,
+     * though older applications might be missing some,
+     * and will be unable to process any changes that use those FieldKinds.
+     */
+    readonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKind>;
+}
+//# sourceMappingURL=fieldKind.d.ts.map

package/dist/feature-libraries/modular-schema/fieldKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldKind.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/fieldKind.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAAsB,SAAS,CAC9B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,aAAa,SAAS,YAAY,GAAG,YAAY,CAChD,YAAW,kBAAkB;aAQb,UAAU,EAAE,KAAK,GAAG,mBAAmB;aACvC,YAAY,EAAE,aAAa;IAP5C;;;;OAIG;IACH,SAAS,aACQ,UAAU,EAAE,KAAK,GAAG,mBAAmB,EACvC,YAAY,EAAE,aAAa;CAE5C;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB,CAC/B,OAAO,SAAS,WAAW,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,EACnD,aAAa,SAAS,YAAY,GAAG,YAAY,EACjD,KAAK,SAAS,MAAM,GAAG,MAAM,CAC5B,SAAQ,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC;aAmBvB,aAAa,EAAE,kBAAkB,CAAC,GAAG,EAAE,OAAO,CAAC;IAC/D,OAAO,CAAC,QAAQ,CAAC,oBAAoB;aAIrB,gBAAgB,EAAE,WAAW,CAAC,mBAAmB,CAAC;IAvBnE;;;;;;;;;;;;;;OAcG;gBAEF,UAAU,EAAE,KAAK,EACjB,YAAY,EAAE,aAAa,EACX,aAAa,EAAE,kBAAkB,CAAC,GAAG,EAAE,OAAO,CAAC,EAC9C,oBAAoB,EAAE,CACtC,aAAa,EAAE,WAAW,EAC1B,QAAQ,EAAE,qBAAqB,KAC3B,OAAO,EACI,gBAAgB,EAAE,WAAW,CAAC,mBAAmB,CAAC;IAKnE;;;OAGG;IACI,mBAAmB,CACzB,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,WAAW,EAC1B,QAAQ,EAAE,qBAAqB,GAC7B,OAAO;CAcV;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,aAAa,SAAS,YAAY,GAAG,YAAY,EAEjD,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,GACnC,mBAAmB,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,CAG7D;AACD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;CACjE"}

package/dist/feature-libraries/modular-schema/fieldKind.js

@@ -0,0 +1,101 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withEditor = exports.FieldKindWithEditor = exports.FieldKind = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const comparison_1 = require("./comparison");
+/**
+ * Functionality for FieldKinds that is stable,
+ * meaning that it can not change in any measurable way without providing a new identifier.
+ *
+ * It is assumed that this information and policy is available on all clients interacting with a document
+ * using the identifier.
+ *
+ * This must contain enough information to process remote edits to this FieldKind consistently with all clients.
+ * All behavior must be deterministic, and not change across versions of the app/library.
+ *
+ * These policies include the data encoding, change encoding, change rebase and change application.
+ *
+ * @sealed @internal
+ * @privateRemarks
+ * This being @sealed is for users of this package.
+ * This package itself may provide implementations.
+ * This pattern was picked instead of an interface since we do not have a convention for how to mark interfaces as only allowed to be implemented by the package declaring them,
+ * and using a class also gets stronger (nominal) typing for objects which will be down cast.
+ */
+class FieldKind {
+    /**
+     * @param identifier - Globally scoped identifier.
+     * @param multiplicity - bound on the number of children that fields of this kind may have.
+     * TODO: consider replacing with numeric upper and lower bounds.
+     */
+    constructor(identifier, multiplicity) {
+        this.identifier = identifier;
+        this.multiplicity = multiplicity;
+    }
+}
+exports.FieldKind = FieldKind;
+/**
+ * Functionality for FieldKinds that is stable,
+ * meaning that it can not change in any measurable way without providing a new identifier.
+ *
+ * It is assumed that this information and policy is available on all clients interacting with a document
+ * using the identifier.
+ *
+ * This must contain enough information to process remote edits to this FieldKind consistently with all clients.
+ * All behavior must be deterministic, and not change across versions of the app/library.
+ *
+ * These policies include the data encoding, change encoding, change rebase and change application.
+ */
+class FieldKindWithEditor extends FieldKind {
+    /**
+     * @param identifier - Globally scoped identifier.
+     * @param multiplicity - bound on the number of children that fields of this kind may have.
+     * TODO: replace with numeric upper and lower bounds.
+     * @param changeHandler - Change handling policy.
+     * @param allowsTreeSupersetOf - returns true iff `superset` supports all that this does
+     * and `superset` is an allowed upgrade. Does not have to handle the `never` cases.
+     * See {@link isNeverField}.
+     * TODO: when used as a method (instead of a free function like the other superset related functions),
+     * this name is/signature is confusing and seems backwards.
+     * @param handlesEditsFrom - Kinds (in addition to this) whose edits can be processed by changeHandler.
+     * If the kind of a field changes, and edits are rebased across that kind change,
+     * listing the other old kind here can prevent those edits from being conflicted and
+     * provide a chance to handle them.
+     */
+    constructor(identifier, multiplicity, changeHandler, allowsTreeSupersetOf, handlesEditsFrom) {
+        super(identifier, multiplicity);
+        this.changeHandler = changeHandler;
+        this.allowsTreeSupersetOf = allowsTreeSupersetOf;
+        this.handlesEditsFrom = handlesEditsFrom;
+    }
+    /**
+     * @returns true iff `superset` permits a (non-strict) superset of the subtrees
+     * allowed by field made from `this` and `originalTypes`.
+     */
+    allowsFieldSuperset(policy, originalData, originalTypes, superset) {
+        if ((0, comparison_1.isNeverField)(policy, originalData, {
+            kind: this,
+            types: originalTypes,
+        })) {
+            return true;
+        }
+        if ((0, comparison_1.isNeverField)(policy, originalData, superset)) {
+            return false;
+        }
+        return this.allowsTreeSupersetOf(originalTypes, superset);
+    }
+}
+exports.FieldKindWithEditor = FieldKindWithEditor;
+/**
+ * Downcasts to FieldKindWithEditor.
+ */
+function withEditor(kind) {
+    (0, core_utils_1.assert)(kind instanceof FieldKindWithEditor, 0x7b5 /* kind must be FieldKindWithEditor */);
+    return kind;
+}
+exports.withEditor = withEditor;
+//# sourceMappingURL=fieldKind.js.map

package/dist/feature-libraries/modular-schema/fieldKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldKind.js","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/fieldKind.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AASpD,6CAA4C;AAG5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAsB,SAAS;IAK9B;;;;OAIG;IACH,YACiB,UAAuC,EACvC,YAA2B;QAD3B,eAAU,GAAV,UAAU,CAA6B;QACvC,iBAAY,GAAZ,YAAY,CAAe;IACzC,CAAC;CACJ;AAdD,8BAcC;AAED;;;;;;;;;;;GAWG;AACH,MAAa,mBAIX,SAAQ,SAA+B;IACxC;;;;;;;;;;;;;;OAcG;IACH,YACC,UAAiB,EACjB,YAA2B,EACX,aAA+C,EAC9C,oBAGL,EACI,gBAAkD;QAElE,KAAK,CAAC,UAAyC,EAAE,YAAY,CAAC,CAAC;QAP/C,kBAAa,GAAb,aAAa,CAAkC;QAC9C,yBAAoB,GAApB,oBAAoB,CAGzB;QACI,qBAAgB,GAAhB,gBAAgB,CAAkC;IAGnE,CAAC;IAED;;;OAGG;IACI,mBAAmB,CACzB,MAAwB,EACxB,YAA8B,EAC9B,aAA0B,EAC1B,QAA+B;QAE/B,IACC,IAAA,yBAAY,EAAC,MAAM,EAAE,YAAY,EAAE;YAClC,IAAI,EAAE,IAAI;YACV,KAAK,EAAE,aAAa;SACpB,CAAC,EACD;YACD,OAAO,IAAI,CAAC;SACZ;QACD,IAAI,IAAA,yBAAY,EAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;YACjD,OAAO,KAAK,CAAC;SACb;QACD,OAAO,IAAI,CAAC,oBAAoB,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC;CACD;AAxDD,kDAwDC;AAED;;GAEG;AACH,SAAgB,UAAU,CAIzB,IAAqC;IAErC,IAAA,mBAAM,EAAC,IAAI,YAAY,mBAAmB,EAAE,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1F,OAAO,IAAmE,CAAC;AAC5E,CAAC;AARD,gCAQC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport {\n\tTreeFieldStoredSchema,\n\tFieldKindIdentifier,\n\tTreeStoredSchema,\n\tFieldKindSpecifier,\n\tTreeTypeSet,\n} from \"../../core\";\nimport { Multiplicity } from \"../multiplicity\";\nimport { isNeverField } from \"./comparison\";\nimport { FieldChangeHandler, FieldEditor } from \"./fieldChangeHandler\";\n\n/**\n * Functionality for FieldKinds that is stable,\n * meaning that it can not change in any measurable way without providing a new identifier.\n *\n * It is assumed that this information and policy is available on all clients interacting with a document\n * using the identifier.\n *\n * This must contain enough information to process remote edits to this FieldKind consistently with all clients.\n * All behavior must be deterministic, and not change across versions of the app/library.\n *\n * These policies include the data encoding, change encoding, change rebase and change application.\n *\n * @sealed @internal\n * @privateRemarks\n * This being @sealed is for users of this package.\n * This package itself may provide implementations.\n * This pattern was picked instead of an interface since we do not have a convention for how to mark interfaces as only allowed to be implemented by the package declaring them,\n * and using a class also gets stronger (nominal) typing for objects which will be down cast.\n */\nexport abstract class FieldKind<\n\tTName extends string = string,\n\tTMultiplicity extends Multiplicity = Multiplicity,\n> implements FieldKindSpecifier\n{\n\t/**\n\t * @param identifier - Globally scoped identifier.\n\t * @param multiplicity - bound on the number of children that fields of this kind may have.\n\t * TODO: consider replacing with numeric upper and lower bounds.\n\t */\n\tprotected constructor(\n\t\tpublic readonly identifier: TName & FieldKindIdentifier,\n\t\tpublic readonly multiplicity: TMultiplicity,\n\t) {}\n}\n\n/**\n * Functionality for FieldKinds that is stable,\n * meaning that it can not change in any measurable way without providing a new identifier.\n *\n * It is assumed that this information and policy is available on all clients interacting with a document\n * using the identifier.\n *\n * This must contain enough information to process remote edits to this FieldKind consistently with all clients.\n * All behavior must be deterministic, and not change across versions of the app/library.\n *\n * These policies include the data encoding, change encoding, change rebase and change application.\n */\nexport class FieldKindWithEditor<\n\tTEditor extends FieldEditor<any> = FieldEditor<any>,\n\tTMultiplicity extends Multiplicity = Multiplicity,\n\tTName extends string = string,\n> extends FieldKind<TName, TMultiplicity> {\n\t/**\n\t * @param identifier - Globally scoped identifier.\n\t * @param multiplicity - bound on the number of children that fields of this kind may have.\n\t * TODO: replace with numeric upper and lower bounds.\n\t * @param changeHandler - Change handling policy.\n\t * @param allowsTreeSupersetOf - returns true iff `superset` supports all that this does\n\t * and `superset` is an allowed upgrade. Does not have to handle the `never` cases.\n\t * See {@link isNeverField}.\n\t * TODO: when used as a method (instead of a free function like the other superset related functions),\n\t * this name is/signature is confusing and seems backwards.\n\t * @param handlesEditsFrom - Kinds (in addition to this) whose edits can be processed by changeHandler.\n\t * If the kind of a field changes, and edits are rebased across that kind change,\n\t * listing the other old kind here can prevent those edits from being conflicted and\n\t * provide a chance to handle them.\n\t */\n\tpublic constructor(\n\t\tidentifier: TName,\n\t\tmultiplicity: TMultiplicity,\n\t\tpublic readonly changeHandler: FieldChangeHandler<any, TEditor>,\n\t\tprivate readonly allowsTreeSupersetOf: (\n\t\t\toriginalTypes: TreeTypeSet,\n\t\t\tsuperset: TreeFieldStoredSchema,\n\t\t) => boolean,\n\t\tpublic readonly handlesEditsFrom: ReadonlySet<FieldKindIdentifier>,\n\t) {\n\t\tsuper(identifier as TName & FieldKindIdentifier, multiplicity);\n\t}\n\n\t/**\n\t * @returns true iff `superset` permits a (non-strict) superset of the subtrees\n\t * allowed by field made from `this` and `originalTypes`.\n\t */\n\tpublic allowsFieldSuperset(\n\t\tpolicy: FullSchemaPolicy,\n\t\toriginalData: TreeStoredSchema,\n\t\toriginalTypes: TreeTypeSet,\n\t\tsuperset: TreeFieldStoredSchema,\n\t): boolean {\n\t\tif (\n\t\t\tisNeverField(policy, originalData, {\n\t\t\t\tkind: this,\n\t\t\t\ttypes: originalTypes,\n\t\t\t})\n\t\t) {\n\t\t\treturn true;\n\t\t}\n\t\tif (isNeverField(policy, originalData, superset)) {\n\t\t\treturn false;\n\t\t}\n\t\treturn this.allowsTreeSupersetOf(originalTypes, superset);\n\t}\n}\n\n/**\n * Downcasts to FieldKindWithEditor.\n */\nexport function withEditor<\n\tTName extends string = string,\n\tTMultiplicity extends Multiplicity = Multiplicity,\n>(\n\tkind: FieldKind<TName, TMultiplicity>,\n): FieldKindWithEditor<FieldEditor<any>, TMultiplicity, TName> {\n\tassert(kind instanceof FieldKindWithEditor, 0x7b5 /* kind must be FieldKindWithEditor */);\n\treturn kind as FieldKindWithEditor<FieldEditor<any>, TMultiplicity, TName>;\n}\n/**\n * Policy from the app for interpreting the stored schema.\n * The app must ensure consistency for all users of the document.\n * @internal\n */\nexport interface FullSchemaPolicy {\n\t/**\n\t * Policy information about FieldKinds:\n\t * This is typically stored as code, not in documents, and defines how to handles fields based on their kind.\n\t * It is assumed that all users of a document will have exactly the same FieldKind policies,\n\t * though older applications might be missing some,\n\t * and will be unable to process any changes that use those FieldKinds.\n\t */\n\treadonly fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKind>;\n}\n"]}

package/dist/feature-libraries/modular-schema/genericFieldKind.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { RevisionMetadataSource } from "../../core";
+import { IdAllocator } from "../../util";
+import { FieldChangeHandler, NodeChangeComposer } from "./fieldChangeHandler";
+import { FieldKindWithEditor } from "./fieldKind";
+import { GenericChangeset } from "./genericFieldKindTypes";
+/**
+ * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.
+ */
+export declare const genericChangeHandler: FieldChangeHandler<GenericChangeset>;
+/**
+ * {@link FieldKind} used to represent changes to elements of a field in a field-kind-agnostic format.
+ */
+export declare const genericFieldKind: FieldKindWithEditor;
+/**
+ * Converts a {@link GenericChangeset} into a field-kind-specific `TChange`.
+ * @param changeset - The generic changeset to convert.
+ * @param target - The {@link FieldChangeHandler} for the `FieldKind` that the returned change should target.
+ * @param composeChild - A delegate to compose {@link NodeChangeset}s.
+ * @returns An equivalent changeset as represented by the `target` field-kind.
+ */
+export declare function convertGenericChange<TChange>(changeset: GenericChangeset, target: FieldChangeHandler<TChange>, composeChild: NodeChangeComposer, genId: IdAllocator, revisionMetadata: RevisionMetadataSource): TChange;
+export declare function newGenericChangeset(): GenericChangeset;
+//# sourceMappingURL=genericFieldKind.d.ts.map

package/dist/feature-libraries/modular-schema/genericFieldKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genericFieldKind.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/genericFieldKind.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAKN,sBAAsB,EAGtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAQ,WAAW,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EACN,kBAAkB,EAElB,kBAAkB,EAKlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAiB,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG1E;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,CAAC,gBAAgB,CAiFrE,CAAC;AA4DF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAM9B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAC3C,SAAS,EAAE,gBAAgB,EAC3B,MAAM,EAAE,kBAAkB,CAAC,OAAO,CAAC,EACnC,YAAY,EAAE,kBAAkB,EAChC,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,sBAAsB,GACtC,OAAO,CAYT;AAQD,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD"}