@fluidframework/react 2.83.0 → 2.90.0

package/src/text/plain/plainUtils.ts

@@ -0,0 +1,68 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TextAsTree } from "@fluidframework/tree/internal";
+
+/**
+ * Sync `newText` into the provided `root` tree.
+ */
+export function syncTextToTree(root: TextAsTree.Tree, newText: string): void {
+	const sync = computeSync(root.charactersCopy(), [...newText]);
+
+	if (sync.remove) {
+		root.removeRange(sync.remove.start, sync.remove.end);
+	}
+	if (sync.insert) {
+		root.insertAt(sync.insert.location, sync.insert.slice.join(""));
+	}
+}
+
+/**
+ * Sync `newText` into the provided `root` tree.
+ */
+export function computeSync<T>(
+	existing: readonly T[],
+	final: readonly T[],
+): { remove?: { start: number; end: number }; insert?: { location: number; slice: T[] } } {
+	// Find common prefix and suffix to minimize changes
+
+	let prefixLength = 0;
+	while (
+		prefixLength < existing.length &&
+		prefixLength < final.length &&
+		existing[prefixLength] === final[prefixLength]
+	) {
+		prefixLength++;
+	}
+
+	let suffixLength = 0;
+	while (
+		suffixLength + prefixLength < existing.length &&
+		suffixLength + prefixLength < final.length &&
+		existing[existing.length - 1 - suffixLength] === final[final.length - 1 - suffixLength]
+	) {
+		suffixLength++;
+	}
+
+	// Locate middle replaced range in existing and final
+	const existingMiddleStart = prefixLength;
+	const existingMiddleEnd = existing.length - suffixLength;
+	const newMiddleStart = prefixLength;
+	const newMiddleEnd = final.length - suffixLength;
+
+	return {
+		remove:
+			existingMiddleStart < existingMiddleEnd
+				? { start: existingMiddleStart, end: existingMiddleEnd }
+				: undefined,
+		insert:
+			newMiddleStart < newMiddleEnd
+				? {
+						location: existingMiddleStart,
+						slice: final.slice(newMiddleStart, newMiddleEnd),
+					}
+				: undefined,
+	};
+}

package/src/text/plain/quillView.tsx

@@ -0,0 +1,149 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TextAsTree } from "@fluidframework/tree/internal";
+import Quill from "quill";
+import * as React from "react";
+
+import type { PropTreeNode } from "../../propNode.js";
+import { withMemoizedTreeObservations } from "../../useTree.js";
+
+import { syncTextToTree } from "./plainUtils.js";
+
+/**
+ * Props for the MainView component.
+ * @input @internal
+ */
+export interface MainViewProps {
+	root: PropTreeNode<TextAsTree.Tree>;
+}
+
+/**
+ * A React component for plain text editing.
+ * @remarks
+ * Uses {@link @fluidframework/tree#TextAsTree.Tree} for the data-model and Quill for the UI.
+ * @internal
+ */
+export const MainView: React.FC<MainViewProps> = ({ root }) => {
+	return <TextEditorView root={root} />;
+};
+
+/**
+ * The text editor view component with Quill integration.
+ * Uses TextAsTree for collaborative plain text storage.
+ *
+ * @remarks
+ * This uses withMemoizedTreeObservations to automatically re-render
+ * when the tree changes.
+ */
+const TextEditorView = withMemoizedTreeObservations(({ root }: { root: TextAsTree.Tree }) => {
+	// DOM element where Quill will mount its editor
+	const editorRef = React.useRef<HTMLDivElement>(null);
+	// Quill instance, persisted across renders to avoid re-initialization
+	const quillRef = React.useRef<Quill | null>(null);
+	// Guards against update loops between Quill and the tree
+	const isUpdatingRef = React.useRef<boolean>(false);
+
+	// Access tree content during render to establish observation.
+	// The HOC will automatically re-render when this content changes.
+	const currentText = root.fullString();
+
+	// Initialize Quill editor
+	React.useEffect(() => {
+		if (editorRef.current && !quillRef.current) {
+			const quill = new Quill(editorRef.current, {
+				placeholder: "Start typing...",
+			});
+
+			// Set initial content from tree (add trailing newline to match Quill's convention)
+			const initialText = root.fullString();
+			if (initialText.length > 0) {
+				const textWithNewline = initialText.endsWith("\n") ? initialText : `${initialText}\n`;
+				quill.setText(textWithNewline);
+			}
+
+			// Listen to local Quill changes
+			quill.on("text-change", (_delta, _oldDelta, source) => {
+				if (source === "user" && !isUpdatingRef.current) {
+					isUpdatingRef.current = true;
+
+					// Get plain text from Quill and preserve trailing newline
+					const newText = quill.getText();
+					// TODO: Consider using delta from Quill to compute a more minimal update,
+					// and maybe add a debugAssert that the delta actually gets the strings synchronized.
+					syncTextToTree(root, newText);
+
+					isUpdatingRef.current = false;
+				}
+			});
+
+			quillRef.current = quill;
+		}
+		// In React strict mode, effects run twice. The `!quillRef.current` check above
+		// makes the second call a no-op, preventing double-initialization of Quill.
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []);
+
+	// Sync Quill when tree changes externally.
+	// We skip this if isUpdatingRef is true, meaning we caused the tree change ourselves
+	// via the text-change handler above - in that case Quill already has the correct content.
+	// No update is lost because isUpdatingRef is only true synchronously during our own
+	// handler execution, so Quill already reflects the change.
+	if (quillRef.current && !isUpdatingRef.current) {
+		const quillText = quillRef.current.getText();
+		// Normalize tree text to match Quill's trailing newline convention
+		const treeTextWithNewline = currentText.endsWith("\n") ? currentText : `${currentText}\n`;
+
+		// Only update if content actually differs (avoids cursor jump on local edits)
+		if (quillText !== treeTextWithNewline) {
+			isUpdatingRef.current = true;
+
+			const selection = quillRef.current.getSelection();
+			quillRef.current.setText(treeTextWithNewline);
+			if (selection) {
+				const length = quillRef.current.getLength();
+				const newPosition = Math.min(selection.index, length - 1);
+				quillRef.current.setSelection(newPosition, 0);
+			}
+
+			isUpdatingRef.current = false;
+		}
+	}
+
+	return (
+		<div
+			className="text-editor-container"
+			style={{ height: "100%", display: "flex", flexDirection: "column" }}
+		>
+			<style>
+				{`
+					.ql-container {
+						height: 100%;
+						font-size: 14px;
+					}
+					.ql-editor {
+						height: 100%;
+						outline: none;
+					}
+					.ql-editor.ql-blank::before {
+						color: #999;
+						font-style: italic;
+					}
+				`}
+			</style>
+			<h2 style={{ margin: "10px 0" }}>Collaborative Text Editor</h2>
+			<div
+				ref={editorRef}
+				style={{
+					flex: 1,
+					minHeight: "300px",
+					border: "1px solid #ccc",
+					borderRadius: "4px",
+					padding: "8px",
+				}}
+			/>
+		</div>
+	);
+});

package/src/undoRedo.ts

@@ -0,0 +1,117 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { Listenable } from "@fluidframework/core-interfaces";
+import {
+	CommitKind,
+	type CommitMetadata,
+	type Revertible,
+	type RevertibleFactory,
+	type TreeViewEvents,
+} from "@fluidframework/tree";
+
+/**
+ * Interface for undo/redo stack operations.
+ * @internal
+ */
+export interface UndoRedo {
+	/**
+	 * Reverts the most recent change. Only valid to call when {@link UndoRedo.canUndo} returns true.
+	 * @throws Error if there is nothing to undo.
+	 */
+	undo(): void;
+	/**
+	 * Reapplies the most recently undone change. Only valid to call when {@link UndoRedo.canRedo} returns true.
+	 * @throws Error if there is nothing to redo.
+	 */
+	redo(): void;
+	dispose(): void;
+	canUndo(): boolean;
+	canRedo(): boolean;
+	/**
+	 * Subscribe to state changes (when canUndo/canRedo may have changed).
+	 * @param callback - Called when the undo/redo stack state changes
+	 * @returns Unsubscribe function
+	 */
+	onStateChange(callback: () => void): () => void;
+}
+
+/**
+ * Manages undo and redo stacks for a TreeView.
+ * Listens to commitApplied events and manages Revertible objects.
+ * @sealed @internal
+ */
+export class UndoRedoStacks implements UndoRedo {
+	private readonly undoStack: Revertible[] = [];
+	private readonly redoStack: Revertible[] = [];
+	private readonly listeners = new Set<() => void>();
+	private readonly unsubscribe: () => void;
+
+	public constructor(events: Listenable<TreeViewEvents>) {
+		this.unsubscribe = events.on(
+			"commitApplied",
+			(commit: CommitMetadata, getRevertible?: RevertibleFactory) => {
+				if (getRevertible === undefined) return;
+				const revertible = getRevertible();
+				if (commit.kind === CommitKind.Undo) {
+					this.redoStack.push(revertible);
+				} else {
+					if (commit.kind === CommitKind.Default) {
+						for (const r of this.redoStack) r.dispose();
+						this.redoStack.length = 0;
+					}
+					this.undoStack.push(revertible);
+				}
+				this.notifyListeners();
+			},
+		);
+	}
+
+	public undo(): void {
+		const revertible = this.undoStack.pop();
+		if (revertible === undefined) {
+			throw new Error("Cannot undo: undo stack is empty.");
+		}
+		revertible.revert();
+		this.notifyListeners();
+	}
+
+	public redo(): void {
+		const revertible = this.redoStack.pop();
+		if (revertible === undefined) {
+			throw new Error("Cannot redo: redo stack is empty.");
+		}
+		revertible.revert();
+		this.notifyListeners();
+	}
+
+	public dispose(): void {
+		this.unsubscribe();
+		this.listeners.clear();
+		for (const r of this.undoStack) r.dispose();
+		for (const r of this.redoStack) r.dispose();
+		this.undoStack.length = 0;
+		this.redoStack.length = 0;
+	}
+
+	public canUndo(): boolean {
+		return this.undoStack.length > 0;
+	}
+
+	public canRedo(): boolean {
+		return this.redoStack.length > 0;
+	}
+
+	public onStateChange(callback: () => void): () => void {
+		this.listeners.add(callback);
+		return () => this.listeners.delete(callback);
+	}
+
+	private notifyListeners(): void {
+		for (const listener of this.listeners) {
+			listener();
+		}
+	}
+}

package/tsconfig.json

@@ -9,5 +9,11 @@
 		"noUnusedLocals": false,
 		// ES2021 needed for FinalizationRegistry
 		"lib": ["ES2021", "DOM", "DOM.Iterable"],
+		// Suppress type errors in Quill's use of quill-delta.
+		// Without this, the quill code gives a lot of errors like:
+		// node_modules/.pnpm/quill@2.0.3/node_modules/quill/blots/block.d.ts:6:17 - error TS2709: Cannot use namespace 'Delta' as a type.
+		// These issues (and others, see imports of quill-delta) are likely related to quill-delta's export style not working well with node16 module resolution.
+		// Quill internally uses `"moduleResolution": "bundler"` which seems to work properly with quill-delta's exports, but would be inconsistent with the rest of this repo.
+		"skipLibCheck": true,
 	},
 }

package/api-extractor/api-extractor-lint-alpha.cjs.json

@@ -1,5 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "<projectFolder>/../../../common/build/build-common/api-extractor-lint.entrypoint.json",
-	"mainEntryPointFilePath": "<projectFolder>/dist/alpha.d.ts"
-}

package/api-extractor/api-extractor-lint-beta.cjs.json

@@ -1,5 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "<projectFolder>/../../../common/build/build-common/api-extractor-lint.entrypoint.json",
-	"mainEntryPointFilePath": "<projectFolder>/dist/beta.d.ts"
-}

package/api-extractor/api-extractor-lint-public.cjs.json

@@ -1,5 +0,0 @@
-{
-	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "<projectFolder>/../../../common/build/build-common/api-extractor-lint.entrypoint.json",
-	"mainEntryPointFilePath": "<projectFolder>/dist/public.d.ts"
-}

package/dist/alpha.d.ts

@@ -1,45 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/*
- * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
- */
-
-/**
- * Utilities for using SharedTree with React.
- * @packageDocumentation
- */
-
-export {
-	// #region @alpha APIs
-	IReactTreeDataObject, 
-	IsMappableObjectType, 
-	NodeRecord, 
-	ObservationOptions, 
-	PropTreeNode, 
-	PropTreeNodeRecord, 
-	PropTreeValue, 
-	SchemaIncompatibleProps, 
-	TreeViewComponent, 
-	TreeViewProps, 
-	UnwrapPropTreeNode, 
-	UnwrapPropTreeNodeRecord, 
-	WrapNodes, 
-	WrapPropTreeNodeRecord, 
-	objectIdNumber, 
-	toPropTreeNode, 
-	toPropTreeRecord, 
-	treeDataObject, 
-	unwrapPropTreeNode, 
-	unwrapPropTreeRecord, 
-	usePropTreeNode, 
-	usePropTreeRecord, 
-	useTree, 
-	useTreeObservations, 
-	withMemoizedTreeObservations, 
-	withTreeObservations
-	// #endregion
-} from "./index.js";

package/dist/beta.d.ts

@@ -1,15 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/*
- * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
- * Generated by "flub generate entrypoints" in @fluid-tools/build-cli.
- */
-
-/**
- * Utilities for using SharedTree with React.
- * @packageDocumentation
- */export {}
-

package/dist/index.d.ts

@@ -1,16 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Utilities for using SharedTree with React.
- * @packageDocumentation
- */
-export type { IReactTreeDataObject, TreeViewProps, SchemaIncompatibleProps, } from "./reactSharedTreeView.js";
-export { treeDataObject, treeDataObjectInternal, TreeViewComponent, } from "./reactSharedTreeView.js";
-export type { ObservationOptions } from "./useObservation.js";
-export type { NodeRecord, PropTreeNode, PropTreeNodeRecord, PropTreeValue, UnwrapPropTreeNode, UnwrapPropTreeNodeRecord, WrapPropTreeNodeRecord, WrapNodes, IsMappableObjectType, } from "./propNode.js";
-export { toPropTreeNode, toPropTreeRecord, unwrapPropTreeNode, unwrapPropTreeRecord, } from "./propNode.js";
-export { useTree, usePropTreeNode, usePropTreeRecord, useTreeObservations, withTreeObservations, withMemoizedTreeObservations, } from "./useTree.js";
-export { objectIdNumber } from "./simpleIdentifier.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AAEH,YAAY,EACX,oBAAoB,EACpB,aAAa,EACb,uBAAuB,GACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACN,cAAc,EACd,sBAAsB,EACtB,iBAAiB,GACjB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,YAAY,EACX,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,SAAS,EACT,oBAAoB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,OAAO,EACP,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,4BAA4B,GAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,26 +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.objectIdNumber = exports.withMemoizedTreeObservations = exports.withTreeObservations = exports.useTreeObservations = exports.usePropTreeRecord = exports.usePropTreeNode = exports.useTree = exports.unwrapPropTreeRecord = exports.unwrapPropTreeNode = exports.toPropTreeRecord = exports.toPropTreeNode = exports.TreeViewComponent = exports.treeDataObjectInternal = exports.treeDataObject = void 0;
-var reactSharedTreeView_js_1 = require("./reactSharedTreeView.js");
-Object.defineProperty(exports, "treeDataObject", { enumerable: true, get: function () { return reactSharedTreeView_js_1.treeDataObject; } });
-Object.defineProperty(exports, "treeDataObjectInternal", { enumerable: true, get: function () { return reactSharedTreeView_js_1.treeDataObjectInternal; } });
-Object.defineProperty(exports, "TreeViewComponent", { enumerable: true, get: function () { return reactSharedTreeView_js_1.TreeViewComponent; } });
-var propNode_js_1 = require("./propNode.js");
-Object.defineProperty(exports, "toPropTreeNode", { enumerable: true, get: function () { return propNode_js_1.toPropTreeNode; } });
-Object.defineProperty(exports, "toPropTreeRecord", { enumerable: true, get: function () { return propNode_js_1.toPropTreeRecord; } });
-Object.defineProperty(exports, "unwrapPropTreeNode", { enumerable: true, get: function () { return propNode_js_1.unwrapPropTreeNode; } });
-Object.defineProperty(exports, "unwrapPropTreeRecord", { enumerable: true, get: function () { return propNode_js_1.unwrapPropTreeRecord; } });
-var useTree_js_1 = require("./useTree.js");
-Object.defineProperty(exports, "useTree", { enumerable: true, get: function () { return useTree_js_1.useTree; } });
-Object.defineProperty(exports, "usePropTreeNode", { enumerable: true, get: function () { return useTree_js_1.usePropTreeNode; } });
-Object.defineProperty(exports, "usePropTreeRecord", { enumerable: true, get: function () { return useTree_js_1.usePropTreeRecord; } });
-Object.defineProperty(exports, "useTreeObservations", { enumerable: true, get: function () { return useTree_js_1.useTreeObservations; } });
-Object.defineProperty(exports, "withTreeObservations", { enumerable: true, get: function () { return useTree_js_1.withTreeObservations; } });
-Object.defineProperty(exports, "withMemoizedTreeObservations", { enumerable: true, get: function () { return useTree_js_1.withMemoizedTreeObservations; } });
-var simpleIdentifier_js_1 = require("./simpleIdentifier.js");
-Object.defineProperty(exports, "objectIdNumber", { enumerable: true, get: function () { return simpleIdentifier_js_1.objectIdNumber; } });
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAYH,mEAIkC;AAHjC,wHAAA,cAAc,OAAA;AACd,gIAAA,sBAAsB,OAAA;AACtB,2HAAA,iBAAiB,OAAA;AAclB,6CAKuB;AAJtB,6GAAA,cAAc,OAAA;AACd,+GAAA,gBAAgB,OAAA;AAChB,iHAAA,kBAAkB,OAAA;AAClB,mHAAA,oBAAoB,OAAA;AAErB,2CAOsB;AANrB,qGAAA,OAAO,OAAA;AACP,6GAAA,eAAe,OAAA;AACf,+GAAA,iBAAiB,OAAA;AACjB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,0HAAA,4BAA4B,OAAA;AAE7B,6DAAuD;AAA9C,qHAAA,cAAc,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Utilities for using SharedTree with React.\n * @packageDocumentation\n */\n\nexport type {\n\tIReactTreeDataObject,\n\tTreeViewProps,\n\tSchemaIncompatibleProps,\n} from \"./reactSharedTreeView.js\";\nexport {\n\ttreeDataObject,\n\ttreeDataObjectInternal,\n\tTreeViewComponent,\n} from \"./reactSharedTreeView.js\";\nexport type { ObservationOptions } from \"./useObservation.js\";\nexport type {\n\tNodeRecord,\n\tPropTreeNode,\n\tPropTreeNodeRecord,\n\tPropTreeValue,\n\tUnwrapPropTreeNode,\n\tUnwrapPropTreeNodeRecord,\n\tWrapPropTreeNodeRecord,\n\tWrapNodes,\n\tIsMappableObjectType,\n} from \"./propNode.js\";\nexport {\n\ttoPropTreeNode,\n\ttoPropTreeRecord,\n\tunwrapPropTreeNode,\n\tunwrapPropTreeRecord,\n} from \"./propNode.js\";\nexport {\n\tuseTree,\n\tusePropTreeNode,\n\tusePropTreeRecord,\n\tuseTreeObservations,\n\twithTreeObservations,\n\twithMemoizedTreeObservations,\n} from \"./useTree.js\";\nexport { objectIdNumber } from \"./simpleIdentifier.js\";\n"]}

package/dist/package.json

@@ -1,4 +0,0 @@
-{
-	"type": "commonjs",
-	"sideEffects": false
-}

package/dist/propNode.d.ts

@@ -1,114 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ErasedType } from "@fluidframework/core-interfaces";
-import type { TreeNode, TreeLeafValue } from "@fluidframework/tree";
-/**
- * A type erased TreeNode for use in react props.
- * @remarks
- * Read content from the node using {@link usePropTreeNode} or {@link usePropTreeRecord}.
- *
- * In events where tracking dependencies is not required, the node can be unwrapped using {@link unwrapPropTreeNode}.
- *
- * To convert a TreeNode to this type use {@link toPropTreeNode} or {@link toPropTreeRecord}.
- * @alpha
- */
-export interface PropTreeNode<T extends TreeNode> extends ErasedType<[T, "PropTreeNode"]> {
-}
-/**
- * Type TreeNodes in T as {@link PropTreeNode}s.
- * @remarks
- * This only handles a few cases (TreeNode, structurally typed objects fields and arrays) and leaves other types as is.
- * Users which provide other types (e.g. maps) which contain TreeNodes will need to handle wrapping those themselves if the wrapping is desired.
- *
- * Users of this should not rely on a given use of TreeNode not being wrapped:
- * future changes to this API may add more cases which are wrapped, and this will be considered a non-breaking change.
- * @privateRemarks
- * Covering all cases is impossible, and trying to cover more with recursive mapped types can break some of the types by losing methods, private members, etc.
- * To mitigate this IsMappableObjectType is used for objects, and only mappable types, where the mapping actually impacted the type are modified.
- *
- * This is intended to cover the common cases, and users can handle other cases manually.
- * See the tests for this for more details.
- * @alpha
- */
-export type WrapNodes<T> = T extends TreeNode ? PropTreeNode<T> : T extends readonly (infer U)[] ? readonly WrapNodes<U>[] : T extends infer U ? IsMappableObjectType<U, {
-    [P in keyof U]: WrapNodes<U[P]>;
-} extends U ? U : {
-    [P in keyof U]: WrapNodes<U[P]>;
-}, T> : T;
-/**
- * Detect if a type is a simple structural object.
- * @remarks
- * This returns the true case if the type is entirely defined by its set of public properties.
- * More concretely, this indicates if creating a mapped type based on `T`
- * will be lossy due to details mapped types cannot access.
- *
- * This is shallow, and distributes over unions.
- *
- * This also returns the true case for primitive types since mapping over them leaves them unchanged if doing so in a generic context:
- * Mapping over a primitive does not leave them unchanged if done directly (not to a generic type parameter), but this can not detect that behavior.
- * This is fine as the use for this is to detect when making a mapped type from a generic type parameter would be lossy.
- * @system @alpha
- */
-export type IsMappableObjectType<T, True = true, False = false, Mapped = {
-    [P in keyof T]: T[P];
-}> = [Mapped] extends [T] ? ([T] extends [Mapped] ? True : False) : False;
-/**
- * Casts a node from a {@link PropTreeNode} back to a TreeNode.
- * @remarks
- * This should only be done in scenarios where tracking observations is not required (such as event handlers),
- * or when taking care to handle invalidation manually.
- * @alpha
- */
-export declare function unwrapPropTreeNode<T extends TreeNode | TreeLeafValue>(propNode: PropTreeValue<T> | T): T;
-/**
- * {@link unwrapPropTreeNode} but for a {@link PropTreeNodeRecord}.
- * @alpha
- */
-export declare function unwrapPropTreeRecord<T extends PropTreeNodeRecord>(props: T): UnwrapPropTreeNodeRecord<T>;
-/**
- * {@inheritdoc unwrapPropTreeNode}
- * @alpha
- */
-export type UnwrapPropTreeNode<T extends TreeLeafValue | PropTreeNode<TreeNode> | undefined> = T extends PropTreeNode<infer Node> ? Node : T;
-/**
- * Record that can contain TreeNodes.
- * @alpha
- */
-export type NodeRecord = Record<string, TreeNode | TreeLeafValue>;
-/**
- * Type erase `TreeNode`s from a {@link NodeRecord} as a {@link PropTreeNode}.
- * @alpha
- */
-export type WrapPropTreeNodeRecord<T extends NodeRecord> = {
-    readonly [P in keyof T]: PropTreeValue<T[P]>;
-};
-/**
- * Type erase `TreeNode`s from a {@link NodeRecord} as a {@link PropTreeNode}.
- * @alpha
- */
-export type UnwrapPropTreeNodeRecord<T extends PropTreeNodeRecord> = {
-    readonly [P in keyof T]: UnwrapPropTreeNode<T[P]>;
-};
-/**
- * Type erase `TreeNode`s from a {@link NodeRecord} as a {@link PropTreeNode}.
- * @alpha
- */
-export type PropTreeNodeRecord = Record<string, TreeLeafValue | PropTreeNode<TreeNode> | undefined>;
-/**
- * Type erase a `TreeNode` from a `TreeNode | TreeLeafValue` as a {@link PropTreeNode}.
- * @alpha
- */
-export type PropTreeValue<T extends TreeNode | TreeLeafValue | undefined> = T extends TreeNode ? PropTreeNode<T> : T;
-/**
- * Type erase a TreeNode as a {@link PropTreeNode}.
- * @alpha
- */
-export declare function toPropTreeNode<T extends TreeNode | TreeLeafValue>(node: T): PropTreeValue<T>;
-/**
- * Type erase a {@link NodeRecord} as a {@link PropTreeNodeRecord}.
- * @alpha
- */
-export declare function toPropTreeRecord<T extends NodeRecord>(node: T): WrapPropTreeNodeRecord<T>;
-//# sourceMappingURL=propNode.d.ts.map

package/dist/propNode.d.ts.map

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

package/dist/propNode.js

@@ -1,43 +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.toPropTreeRecord = exports.toPropTreeNode = exports.unwrapPropTreeRecord = exports.unwrapPropTreeNode = void 0;
-/**
- * Casts a node from a {@link PropTreeNode} back to a TreeNode.
- * @remarks
- * This should only be done in scenarios where tracking observations is not required (such as event handlers),
- * or when taking care to handle invalidation manually.
- * @alpha
- */
-function unwrapPropTreeNode(propNode) {
-    return propNode;
-}
-exports.unwrapPropTreeNode = unwrapPropTreeNode;
-/**
- * {@link unwrapPropTreeNode} but for a {@link PropTreeNodeRecord}.
- * @alpha
- */
-function unwrapPropTreeRecord(props) {
-    return props;
-}
-exports.unwrapPropTreeRecord = unwrapPropTreeRecord;
-/**
- * Type erase a TreeNode as a {@link PropTreeNode}.
- * @alpha
- */
-function toPropTreeNode(node) {
-    return node;
-}
-exports.toPropTreeNode = toPropTreeNode;
-/**
- * Type erase a {@link NodeRecord} as a {@link PropTreeNodeRecord}.
- * @alpha
- */
-function toPropTreeRecord(node) {
-    return node;
-}
-exports.toPropTreeRecord = toPropTreeRecord;
-//# sourceMappingURL=propNode.js.map