@fluidframework/react 2.90.0-378676 → 2.91.0

package/src/text/plain/plainTextView.tsx

@@ -0,0 +1,110 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { TextAsTree } from "@fluidframework/tree/internal";
+import { type ChangeEvent, type FC, useCallback, useRef } from "react";
+
+import { withMemoizedTreeObservations } from "../../useTree.js";
+
+import { syncTextToTree } from "./plainUtils.js";
+import type { MainViewProps } from "./quillView.js";
+
+/**
+ * A React component for plain text editing.
+ * @remarks
+ * Uses {@link @fluidframework/tree#TextAsTree.Tree} for the data-model and an HTML textarea for the UI.
+ * @internal
+ */
+export const MainView: FC<MainViewProps> = ({ root }) => {
+	return <PlainTextEditorView root={root} />;
+};
+
+/**
+ * A plain text editor view component using a native HTML textarea.
+ * Uses TextAsTree for collaborative plain text storage.
+ *
+ * @remarks
+ * This uses withMemoizedTreeObservations to automatically re-render
+ * when the tree changes.
+ */
+const PlainTextEditorView = withMemoizedTreeObservations(
+	({ root }: { root: TextAsTree.Tree }) => {
+		// Reference to the textarea element
+		const textareaRef = useRef<HTMLTextAreaElement>(null);
+		// Guards against update loops between textarea and the tree
+		const isUpdatingRef = 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();
+
+		// Handle textarea changes - sync textarea → tree
+		const handleChange = useCallback(
+			(event: ChangeEvent<HTMLTextAreaElement>) => {
+				if (isUpdatingRef.current) {
+					return;
+				}
+
+				isUpdatingRef.current = true;
+
+				const newText = event.target.value;
+				syncTextToTree(root, newText);
+
+				isUpdatingRef.current = false;
+			},
+			[root],
+		);
+
+		// Sync textarea when tree changes externally.
+		// We skip this if isUpdatingRef is true, meaning we caused the tree change ourselves
+		// via the handleChange above - in that case textarea already has the correct content.
+		if (textareaRef.current && !isUpdatingRef.current) {
+			const textareaValue = textareaRef.current.value;
+
+			// Only update if content actually differs (avoids cursor jump on local edits)
+			if (textareaValue !== currentText) {
+				isUpdatingRef.current = true;
+
+				// Preserve cursor position
+				const selectionStart = textareaRef.current.selectionStart;
+				const selectionEnd = textareaRef.current.selectionEnd;
+
+				textareaRef.current.value = currentText;
+
+				// Restore cursor position, clamped to new text length
+				const newPosition = Math.min(selectionStart, currentText.length);
+				const newEnd = Math.min(selectionEnd, currentText.length);
+				textareaRef.current.setSelectionRange(newPosition, newEnd);
+
+				isUpdatingRef.current = false;
+			}
+		}
+
+		return (
+			<div
+				className="text-editor-container"
+				style={{ height: "100%", display: "flex", flexDirection: "column" }}
+			>
+				<h2 style={{ margin: "10px 0" }}>Collaborative Text Editor</h2>
+				<textarea
+					ref={textareaRef}
+					defaultValue={currentText}
+					onChange={handleChange}
+					placeholder="Start typing..."
+					style={{
+						flex: 1,
+						minHeight: "300px",
+						border: "1px solid #ccc",
+						borderRadius: "4px",
+						padding: "8px",
+						fontSize: "14px",
+						fontFamily: "inherit",
+						resize: "vertical",
+					}}
+				/>
+			</div>
+		);
+	},
+);

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 { type FC, useEffect, useRef } 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: 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 = useRef<HTMLDivElement>(null);
+	// Quill instance, persisted across renders to avoid re-initialization
+	const quillRef = useRef<Quill | null>(null);
+	// Guards against update loops between Quill and the tree
+	const isUpdatingRef = 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
+	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/src/useObservation.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import * as React from "react";
+import { useEffect, useState } from "react";
 
 /**
  * Tracks and subscriptions from the latests render of a given instance of the {@link useObservation} hook.
@@ -68,7 +68,7 @@ export function useObservation<TResult>(
 	options?: ObservationOptions,
 ): TResult {
 	// Use a React state hook to invalidate this component something tracked by `trackDuring` changes.
-	const [subscriptions, setSubscriptions] = React.useState<SubscriptionsWrapper>(
+	const [subscriptions, setSubscriptions] = useState<SubscriptionsWrapper>(
 		new SubscriptionsWrapper(),
 	);
 
@@ -115,7 +115,7 @@ export function useObservation<TResult>(
 	// Suppressing that invalidation bug with an extra call to setSubscriptions could work, but would produce incorrect warnings about leaks,
 	// and might cause infinite rerender depending on how StrictMode works.
 	// Such an Effect would look like this:
-	// React.useEffect(
+	// useEffect(
 	// 	() => () => {
 	// 		subscriptions.unsubscribe?.();
 	// 		subscriptions.unsubscribe = undefined;
@@ -179,11 +179,11 @@ function useObservationPure<TResult>(
 	options?: ObservationPureOptions,
 ): TResult {
 	// Dummy state used to trigger invalidations.
-	const [_subscriptions, setSubscriptions] = React.useState(0);
+	const [_subscriptions, setSubscriptions] = useState(0);
 
 	const { result, subscribe } = trackDuring();
 
-	React.useEffect(() => {
+	useEffect(() => {
 		// Subscribe to events from the latest render
 
 		const invalidate = (): void => {
@@ -363,7 +363,7 @@ export function useObservationStrict<TResult>(
 ): TResult {
 	// Used to unsubscribe from the previous render's subscriptions.
 	// See `useObservation` for a more documented explanation of this pattern.
-	const [subscriptions] = React.useState<{
+	const [subscriptions] = useState<{
 		previousTracker: SubscriptionTracker | undefined;
 	}>({ previousTracker: undefined });
 

package/src/useTree.ts

@@ -6,7 +6,14 @@
 import type { TreeLeafValue, TreeNode } from "@fluidframework/tree";
 import { Tree } from "@fluidframework/tree";
 import { TreeAlpha } from "@fluidframework/tree/internal";
-import * as React from "react";
+import {
+	type FC,
+	memo,
+	type MemoExoticComponent,
+	type ReactNode,
+	useEffect,
+	useState,
+} from "react";
 
 import {
 	unwrapPropTreeNode,
@@ -29,10 +36,10 @@ import { useObservation, type ObservationOptions } from "./useObservation.js";
 export function useTree(subtreeRoot: TreeNode): number {
 	// Use a React effect hook to invalidate this component when the subtreeRoot changes.
 	// We do this by incrementing a counter, which is passed as a dependency to the effect hook.
-	const [invalidations, setInvalidations] = React.useState(0);
+	const [invalidations, setInvalidations] = useState(0);
 
 	// React effect hook that increments the 'invalidation' counter whenever subtreeRoot or any of its children change.
-	React.useEffect(() => {
+	useEffect(() => {
 		// Returns the cleanup function to be invoked when the component unmounts.
 		return Tree.on(subtreeRoot, "treeChanged", () => {
 			setInvalidations((i) => i + 1);
@@ -52,31 +59,31 @@ export function useTree(subtreeRoot: TreeNode): number {
  * It is recommended that sub-components which take in TreeNodes, if not defined using this higher order components, take the nodes in as {@link PropTreeNode}s.
  * Components defined using this higher order component can take in either raw TreeNodes or {@link PropTreeNode}s: the latter will be automatically unwrapped.
  * @privateRemarks
- * `React.FC` does not seem to be covariant over its input type, so to make use of this more ergonomic,
+ * `FC` does not seem to be covariant over its input type, so to make use of this more ergonomic,
  * the return type intersects the various ways this could be used (with or without PropTreeNode wrapping).
  * @alpha
  */
 export function withTreeObservations<TIn>(
-	component: React.FC<TIn>,
+	component: FC<TIn>,
 	options?: ObservationOptions,
-): React.FC<TIn> & React.FC<WrapNodes<TIn>> & React.FC<TIn | WrapNodes<TIn>> {
-	return (props: TIn | WrapNodes<TIn>): React.ReactNode =>
+): FC<TIn> & FC<WrapNodes<TIn>> & FC<TIn | WrapNodes<TIn>> {
+	return (props: TIn | WrapNodes<TIn>): ReactNode =>
 		useTreeObservations(() => component(props as TIn), options);
 }
 
 /**
- * {@link withTreeObservations} wrapped with React.memo.
+ * {@link withTreeObservations} wrapped with memo.
  * @remarks
  * There is no special logic here, just a convenience wrapper.
  * @alpha
  */
 export function withMemoizedTreeObservations<TIn>(
-	component: React.FC<TIn>,
+	component: FC<TIn>,
 	options?: ObservationOptions & {
-		readonly propsAreEqual?: Parameters<typeof React.memo>[1];
+		readonly propsAreEqual?: Parameters<typeof memo>[1];
 	},
-): React.MemoExoticComponent<ReturnType<typeof withTreeObservations<TIn>>> {
-	return React.memo(withTreeObservations(component, options), options?.propsAreEqual);
+): MemoExoticComponent<ReturnType<typeof withTreeObservations<TIn>>> {
+	return memo(withTreeObservations(component, options), options?.propsAreEqual);
 }
 
 /**

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"}