@microsoft/live-share-react 1.4.0-preview.0 → 2.0.0-internal.10

package/bin/esm/shared-hooks/useSharedTree.d.ts

@@ -0,0 +1,57 @@
+import { ImplicitFieldSchema, TreeViewConfiguration, InsertableTreeFieldFromImplicitField } from "fluid-framework";
+import { IUseSharedTreeResults } from "../types/index.js";
+/**
+ * Creates a new Fluid `SharedTree` instance if one doesn't already exist.
+ * @remarks
+ * Use the `root` variable from the {@link IUseSharedTreeResults} response from this hook with {@link useTreeNode}.
+ * This makes `root` stateful with React whenever a leaf of `root` changes.
+ *
+ * @param uniqueKey the unique key for the `SharedTree`. If one does not yet exist, a new `SharedTree` will be created.
+ * Otherwise it will use the existing one.
+ * @param treeViewConfiguration the tree view configuration that contains the `SharedTree` field schema.
+ * @param initialData the initial data to load into the `SharedTree` when it is first created.
+ * @returns the {@link IUseSharedTreeResults} with the `root` node.
+ *
+ * @example
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ * class YourObject extends sf.object("YourObject", {
+ *  listChangedCount: sf.number,
+ *  list: sf.array(sf.string),
+ * }) {
+ *  // You can add your own utility functions
+ *  insert() {
+ *      this.list.insertAtEnd("some text");
+ *      this.listChangedCount += 1;
+ *  }
+ * }
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  number: 0,
+ *  list: [],
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Makes root stateful / automatically update when the node changes (e.g., node.count)
+ *  const { node } = useTreeNode(root);
+ *  // node.list is its own TreeNode, so we make it stateful as well
+ *  const { node: list } = useTreeNode(node?.list);
+ *  if (!node || !list) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.listChangedCount}</div>
+ *          <button onClick={() => node.insert()}>Insert</button>
+ *          { list.map((item) => <div key={item}>{item}</div>) }
+ *      </div>
+ *  );
+ * }
+ * ```
+ */
+export declare function useSharedTree<TSchema extends ImplicitFieldSchema = ImplicitFieldSchema>(uniqueKey: string, treeViewConfiguration: TreeViewConfiguration<TSchema>, initialData: InsertableTreeFieldFromImplicitField<TSchema>): IUseSharedTreeResults<TSchema>;
+//# sourceMappingURL=useSharedTree.d.ts.map

package/bin/esm/shared-hooks/useSharedTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSharedTree.d.ts","sourceRoot":"","sources":["../../../src/shared-hooks/useSharedTree.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,mBAAmB,EACnB,qBAAqB,EAIrB,oCAAoC,EAEvC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAI1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,aAAa,CACzB,OAAO,SAAS,mBAAmB,GAAG,mBAAmB,EAEzD,SAAS,EAAE,MAAM,EACjB,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,CAAC,EACrD,WAAW,EAAE,oCAAoC,CAAC,OAAO,CAAC,GAC3D,qBAAqB,CAAC,OAAO,CAAC,CAuEhC"}

package/bin/esm/shared-hooks/useSharedTree.js

@@ -0,0 +1,117 @@
+import { SharedTree, } from "fluid-framework";
+import { useDynamicDDS } from "../shared-hooks/index.js";
+import React from "react";
+/**
+ * Creates a new Fluid `SharedTree` instance if one doesn't already exist.
+ * @remarks
+ * Use the `root` variable from the {@link IUseSharedTreeResults} response from this hook with {@link useTreeNode}.
+ * This makes `root` stateful with React whenever a leaf of `root` changes.
+ *
+ * @param uniqueKey the unique key for the `SharedTree`. If one does not yet exist, a new `SharedTree` will be created.
+ * Otherwise it will use the existing one.
+ * @param treeViewConfiguration the tree view configuration that contains the `SharedTree` field schema.
+ * @param initialData the initial data to load into the `SharedTree` when it is first created.
+ * @returns the {@link IUseSharedTreeResults} with the `root` node.
+ *
+ * @example
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ * class YourObject extends sf.object("YourObject", {
+ *  listChangedCount: sf.number,
+ *  list: sf.array(sf.string),
+ * }) {
+ *  // You can add your own utility functions
+ *  insert() {
+ *      this.list.insertAtEnd("some text");
+ *      this.listChangedCount += 1;
+ *  }
+ * }
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  number: 0,
+ *  list: [],
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Makes root stateful / automatically update when the node changes (e.g., node.count)
+ *  const { node } = useTreeNode(root);
+ *  // node.list is its own TreeNode, so we make it stateful as well
+ *  const { node: list } = useTreeNode(node?.list);
+ *  if (!node || !list) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.listChangedCount}</div>
+ *          <button onClick={() => node.insert()}>Insert</button>
+ *          { list.map((item) => <div key={item}>{item}</div>) }
+ *      </div>
+ *  );
+ * }
+ * ```
+ */
+export function useSharedTree(uniqueKey, treeViewConfiguration, initialData) {
+    const [treeView, setTreeView] = React.useState();
+    const [root, setRoot] = React.useState();
+    const onFirstInitialize = React.useCallback((newDDS) => {
+        try {
+            // Create a `treeView` with the provided `treeViewConfiguration`
+            const _treeView = newDDS.viewWith(treeViewConfiguration);
+            if (_treeView.compatibility.canInitialize) {
+                // Set initial data
+                _treeView.initialize(initialData);
+            }
+            // `onFirstInitialize` is only called for the user that created the tree, but we need this object for all clients.
+            // Dispose, since we will call `sharedTree.viewWith` in a `useEffect` down below and set it to state.
+            _treeView.dispose();
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }, [treeViewConfiguration, initialData]);
+    /**
+     * User facing: dynamically load the `SharedTree` DDS for the given unique key.
+     */
+    const { dds: sharedTree } = useDynamicDDS(uniqueKey, SharedTree, onFirstInitialize);
+    /**
+     * Sets the tree view and root view
+     */
+    React.useEffect(() => {
+        if (!sharedTree)
+            return;
+        let _treeView = undefined;
+        try {
+            // Create a `treeView` with the provided `treeViewConfiguration`
+            _treeView = sharedTree.viewWith(treeViewConfiguration);
+            setTreeView(_treeView);
+        }
+        catch (err) {
+            console.error(err);
+        }
+        // Listen for changes to root view
+        const updateRoot = () => {
+            if (_treeView === null || _treeView === void 0 ? void 0 : _treeView.compatibility.canView) {
+                setRoot(_treeView.root);
+            }
+            else {
+                setRoot(undefined);
+            }
+        };
+        updateRoot();
+        const unsubscribeToRoot = _treeView === null || _treeView === void 0 ? void 0 : _treeView.events.on("rootChanged", updateRoot);
+        return () => {
+            _treeView === null || _treeView === void 0 ? void 0 : _treeView.dispose();
+            unsubscribeToRoot === null || unsubscribeToRoot === void 0 ? void 0 : unsubscribeToRoot();
+        };
+    }, [sharedTree, treeViewConfiguration]);
+    return {
+        treeView,
+        sharedTree,
+        root,
+    };
+}
+//# sourceMappingURL=useSharedTree.js.map

package/bin/esm/shared-hooks/useSharedTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSharedTree.js","sourceRoot":"","sources":["../../../src/shared-hooks/useSharedTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,UAAU,GAKb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAe,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,UAAU,aAAa,CAGzB,SAAiB,EACjB,qBAAqD,EACrD,WAA0D;IAE1D,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAqB,CAAC;IACpE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GACjB,KAAK,CAAC,QAAQ,EAAuC,CAAC;IAE1D,MAAM,iBAAiB,GAAG,KAAK,CAAC,WAAW,CACvC,CAAC,MAAa,EAAQ,EAAE;QACpB,IAAI,CAAC;YACD,gEAAgE;YAChE,MAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;YACzD,IAAI,SAAS,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;gBACxC,mBAAmB;gBACnB,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;YACtC,CAAC;YACD,kHAAkH;YAClH,qGAAqG;YACrG,SAAS,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;IACL,CAAC,EACD,CAAC,qBAAqB,EAAE,WAAW,CAAC,CACvC,CAAC;IACF;;OAEG;IACH,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,aAAa,CACrC,SAAS,EACT,UAAU,EACV,iBAAiB,CACpB,CAAC;IAEF;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;QACjB,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,IAAI,SAAS,GAAkC,SAAS,CAAC;QACzD,IAAI,CAAC;YACD,gEAAgE;YAChE,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;YACvD,WAAW,CAAC,SAAS,CAAC,CAAC;QAC3B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;QAED,kCAAkC;QAClC,MAAM,UAAU,GAAG,GAAS,EAAE;YAC1B,IAAI,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,aAAa,CAAC,OAAO,EAAE,CAAC;gBACnC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACJ,OAAO,CAAC,SAAS,CAAC,CAAC;YACvB,CAAC;QACL,CAAC,CAAC;QAEF,UAAU,EAAE,CAAC;QACb,MAAM,iBAAiB,GAAG,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,MAAM,CAAC,EAAE,CAC1C,aAAa,EACb,UAAU,CACb,CAAC;QACF,OAAO,GAAG,EAAE;YACR,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,OAAO,EAAE,CAAC;YACrB,iBAAiB,aAAjB,iBAAiB,uBAAjB,iBAAiB,EAAI,CAAC;QAC1B,CAAC,CAAC;IACN,CAAC,EAAE,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAExC,OAAO;QACH,QAAQ;QACR,UAAU;QACV,IAAI;KACP,CAAC;AACN,CAAC"}

package/bin/esm/shared-hooks/useTreeNode.d.ts

@@ -0,0 +1,96 @@
+import { TreeChangeEvents, TreeNode } from "fluid-framework";
+import { IUseTreeNodeResults } from "../types/index.js";
+/**
+ * Makes a provided Fluid `TreeNode` stateful in React.
+ *
+ * @param node the Fluid `SharedTree` `TreeNode` instance to make stateful.
+ * @param stateChangeType listener type to apply changes for. Default value is "nodeChanged", which has the most optimal performance.
+ * Provide "treeChanged" to make all children nodes stateful as well when those child nodes change.
+ * When using the default, you must pass all child `TreeNode` values into `useTreeNode` for them to be stateful as well.
+ * @returns a stateful version `node`
+ *
+ * @example
+ * Example using default `"nodeChanged"` `stateChangeType`
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ * class YourObject extends sf.object("YourObject", {
+ *  listChangedCount: sf.number,
+ *  list: sf.array(sf.string),
+ * }) {
+ *  // You can add your own utility functions
+ *  insert() {
+ *      this.list.insertAtEnd("some text");
+ *      this.listChangedCount += 1;
+ *  }
+ * }
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  number: 0,
+ *  list: [],
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Makes root stateful / automatically update when the node changes (e.g., node.count)
+ *  const { node } = useTreeNode(root);
+ *  // node.list is its own TreeNode, so we make it stateful as well
+ *  const { node: list } = useTreeNode(node?.list);
+ *  if (!node || !list) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.listChangedCount}</div>
+ *          <button onClick={() => node.insert()}>Insert</button>
+ *          { list.map((item) => <div key={item}>{item}</div>) }
+ *      </div>
+ *  );
+ * }
+ * ```
+ *
+ * @example
+ * Example using `"treeChanged"` `stateChangeType`
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ *
+ * class ChildObject extends sf.object("ChildObject", {
+ *  count: sf.number,
+ * }) {
+ *  increment() {
+ *      this.count += 1;
+ *  }
+ * }
+ *
+ * class YourObject extends sf.object("YourObject", {
+ *  child: ChildObject,
+ * }) {}
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  child: new ChildObject({ count: 0 }),
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Using "treeChanged" prop makes all children nodes stateful as well.
+ *  // Use with caution / measure render performance with React dev tools.
+ *  const { node } = useTreeNode(root, "treeChanged");
+ *  if (!node) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.child.count}</div>
+ *          <button onClick={() => node.increment()}>Insert</button>
+ *      </div>
+ *  );
+ * }
+ * ```
+ */
+export declare function useTreeNode<TNode extends TreeNode | undefined = TreeNode>(node: TNode, stateChangeType?: keyof TreeChangeEvents): IUseTreeNodeResults<TNode>;
+//# sourceMappingURL=useTreeNode.d.ts.map

package/bin/esm/shared-hooks/useTreeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeNode.d.ts","sourceRoot":"","sources":["../../../src/shared-hooks/useTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAQxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,GAAG,QAAQ,EACrE,IAAI,EAAE,KAAK,EACX,eAAe,GAAE,MAAM,gBAAgC,GACxD,mBAAmB,CAAC,KAAK,CAAC,CA0C5B"}

package/bin/esm/shared-hooks/useTreeNode.js

@@ -0,0 +1,132 @@
+import { Tree } from "fluid-framework";
+import { useEffect, useRef, useState } from "react";
+import { getRawNode, buildProxy, setUpListenersForNodeChildren, } from "./internals/tree-node-utils.js";
+/**
+ * Makes a provided Fluid `TreeNode` stateful in React.
+ *
+ * @param node the Fluid `SharedTree` `TreeNode` instance to make stateful.
+ * @param stateChangeType listener type to apply changes for. Default value is "nodeChanged", which has the most optimal performance.
+ * Provide "treeChanged" to make all children nodes stateful as well when those child nodes change.
+ * When using the default, you must pass all child `TreeNode` values into `useTreeNode` for them to be stateful as well.
+ * @returns a stateful version `node`
+ *
+ * @example
+ * Example using default `"nodeChanged"` `stateChangeType`
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ * class YourObject extends sf.object("YourObject", {
+ *  listChangedCount: sf.number,
+ *  list: sf.array(sf.string),
+ * }) {
+ *  // You can add your own utility functions
+ *  insert() {
+ *      this.list.insertAtEnd("some text");
+ *      this.listChangedCount += 1;
+ *  }
+ * }
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  number: 0,
+ *  list: [],
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Makes root stateful / automatically update when the node changes (e.g., node.count)
+ *  const { node } = useTreeNode(root);
+ *  // node.list is its own TreeNode, so we make it stateful as well
+ *  const { node: list } = useTreeNode(node?.list);
+ *  if (!node || !list) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.listChangedCount}</div>
+ *          <button onClick={() => node.insert()}>Insert</button>
+ *          { list.map((item) => <div key={item}>{item}</div>) }
+ *      </div>
+ *  );
+ * }
+ * ```
+ *
+ * @example
+ * Example using `"treeChanged"` `stateChangeType`
+ * ```tsx
+ * import { SchemaFactory, TreeViewConfiguration } from "fluid-framework";
+ * import { useSharedTree, useTreeNode } from "@microsoft/live-share-react";
+ * // Declare a schema factory with your unique uuid
+ * const sf = new SchemaFactory("fc1db2e8-0000-11ee-be57-0242ac120002");
+ *
+ * class ChildObject extends sf.object("ChildObject", {
+ *  count: sf.number,
+ * }) {
+ *  increment() {
+ *      this.count += 1;
+ *  }
+ * }
+ *
+ * class YourObject extends sf.object("YourObject", {
+ *  child: ChildObject,
+ * }) {}
+ * const config = new TreeViewConfiguration({ schema: YourObject });
+ * const initialData = new YourObject({
+ *  child: new ChildObject({ count: 0 }),
+ * });
+ *
+ * // Must be child component of <LiveShareProvider> or <AzureProvider>
+ * export const YourComponent = () => {
+ *  // Get the root node of the `SharedTree` mapped to "some-unique-key"
+ *  const { root } = useSharedTree("some-unique-key", config, initialData);
+ *  // Using "treeChanged" prop makes all children nodes stateful as well.
+ *  // Use with caution / measure render performance with React dev tools.
+ *  const { node } = useTreeNode(root, "treeChanged");
+ *  if (!node) return (<>"Loading"</>);
+ *  return (
+ *      <div>
+ *          <div>Changed: {node.child.count}</div>
+ *          <button onClick={() => node.increment()}>Insert</button>
+ *      </div>
+ *  );
+ * }
+ * ```
+ */
+export function useTreeNode(node, stateChangeType = "nodeChanged") {
+    // When we return a proxied node to a developer, it's possible they will pass it back to us in this hook.
+    // We can't listen using Tree.on using a proxy node though...
+    // Thus, if we are already listening to a node from another instance of this hook, we look for the unproxied node.
+    const rawNode = getRawNode(node);
+    const [proxyNode, setProxyNode] = useState(rawNode);
+    const treeProxyMapRef = useRef(new WeakMap());
+    useEffect(() => {
+        if (!rawNode)
+            return;
+        // Set default value
+        setProxyNode(rawNode);
+        function onNodeChanged() {
+            if (!rawNode)
+                return;
+            const proxyNode = buildProxy(rawNode, treeProxyMapRef.current);
+            setProxyNode(proxyNode);
+        }
+        // Listen to Fluid's base node from their TreeView so Fluid flex nodes continue to work
+        const unsubscribeListeners = [
+            Tree.on(rawNode, "nodeChanged", onNodeChanged),
+        ];
+        if (stateChangeType === "treeChanged") {
+            // Recursively for all child nodes of this node in the tree
+            setUpListenersForNodeChildren(rawNode, rawNode, treeProxyMapRef.current, unsubscribeListeners, 
+            // TODO: fix typing so casting isn't necessary
+            setProxyNode);
+        }
+        return () => {
+            unsubscribeListeners.forEach((unsubscribe) => unsubscribe());
+        };
+    }, [rawNode, stateChangeType]);
+    return {
+        node: proxyNode,
+    };
+}
+//# sourceMappingURL=useTreeNode.js.map

package/bin/esm/shared-hooks/useTreeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeNode.js","sourceRoot":"","sources":["../../../src/shared-hooks/useTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA8B,MAAM,iBAAiB,CAAC;AAEnE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EACH,UAAU,EACV,UAAU,EACV,6BAA6B,GAChC,MAAM,gCAAgC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,UAAU,WAAW,CACvB,IAAW,EACX,kBAA0C,aAAa;IAEvD,yGAAyG;IACzG,6DAA6D;IAC7D,kHAAkH;IAClH,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAQ,OAAO,CAAC,CAAC;IAC3D,MAAM,eAAe,GAAG,MAAM,CAA8B,IAAI,OAAO,EAAE,CAAC,CAAC;IAE3E,SAAS,CAAC,GAAG,EAAE;QACX,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,oBAAoB;QACpB,YAAY,CAAC,OAAO,CAAC,CAAC;QACtB,SAAS,aAAa;YAClB,IAAI,CAAC,OAAO;gBAAE,OAAO;YAErB,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;YAC/D,YAAY,CAAC,SAAS,CAAC,CAAC;QAC5B,CAAC;QACD,uFAAuF;QACvF,MAAM,oBAAoB,GAAmB;YACzC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,aAAa,CAAC;SACjD,CAAC;QACF,IAAI,eAAe,KAAK,aAAa,EAAE,CAAC;YACpC,2DAA2D;YAC3D,6BAA6B,CACzB,OAAO,EACP,OAAO,EACP,eAAe,CAAC,OAAO,EACvB,oBAAoB;YACpB,8CAA8C;YAC9C,YAAmB,CACtB,CAAC;QACN,CAAC;QACD,OAAO,GAAG,EAAE;YACR,oBAAoB,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;QACjE,CAAC,CAAC;IACN,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC;IAE/B,OAAO;QACH,IAAI,EAAE,SAAS;KAClB,CAAC;AACN,CAAC"}

package/bin/esm/types/ActionTypes.d.ts

@@ -0,0 +1,112 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+import React from "react";
+import { IFluidLoadable } from "@fluidframework/core-interfaces";
+import { ITimerConfig, ILiveEvent, LivePresenceData } from "@microsoft/live-share";
+import { SharedObjectKind } from "fluid-framework";
+/**
+ * Callback to set shared state
+ */
+export type SetSharedStateAction<TState> = (state: TState | ((prevState: TState) => TState)) => void;
+/**
+ * Callback to set local state
+ */
+export type SetLocalStateAction = React.Dispatch<React.SetStateAction<any>>;
+/**
+ * Callback for UnregisterDDSSetStateAction.
+ * <T extends IFluidLoadable>(uniqueKey: string, componentId: string, objectClass: SharedObjectKind<T>, setLocalStateAction: SetLocalStateAction, onDidFirstInitialize?: (dds: T) => void) => void
+ */
+export type RegisterDDSSetStateAction = <T extends IFluidLoadable>(uniqueKey: string, componentId: string, objectClass: SharedObjectKind<T>, setLocalStateAction: SetLocalStateAction, onDidFirstInitialize?: (dds: T) => void) => void;
+/**
+ * Callback for UnregisterDDSSetStateAction.
+ * (uniqueKey: string, componentId: string) => void
+ */
+export type UnregisterDDSSetStateAction = (uniqueKey: string, componentId: string) => void;
+/**
+ * Callback for RegisterSharedSetStateAction.
+ * (uniqueKey: string, componentId: string, setLocalStateAction: SetLocalStateAction) => void
+ */
+export type RegisterSharedSetStateAction = (uniqueKey: string, componentId: string, setLocalStateAction: SetLocalStateAction) => void;
+/**
+ * Callback for UnregisterSharedSetStateAction.
+ * (uniqueKey: string, componentId: string) => void
+ */
+export type UnregisterSharedSetStateAction = (uniqueKey: string, componentId: string) => void;
+/**
+ * Callback for UpdateSharedStateAction.
+ * (uniqueKey: string, value: any) => void
+ */
+export type UpdateSharedStateAction = (uniqueKey: string, value: any) => void;
+/**
+ * Callback for DeleteSharedStateAction.
+ * (uniqueKey: string) => void
+ */
+export type DeleteSharedStateAction = (uniqueKey: string) => void;
+/**
+ * Callback for DisposeSharedStateAction.
+ * () => void
+ */
+export type DisposeSharedStateAction = () => void;
+/**
+ * Callback for SetLiveStateAction<TState = undefined>.
+ * (state: TState) => Promise<void>
+ */
+export type SetLiveStateAction<TState = undefined> = (state: TState | ((prevState: TState) => TState)) => Promise<void>;
+/**
+ * Callback for SendLiveEventAction<TEvent>.
+ * (event: TEvent, targetClientId?: string) => Promise<void>
+ */
+export type SendLiveEventAction<TEvent> = (event: TEvent, targetClientId?: string) => Promise<ILiveEvent<TEvent>>;
+/**
+ * Callback for OnReceivedLiveEventAction<TEvent>.
+ * (event: TEvent, local: boolean) => void
+ */
+export type OnReceivedLiveEventAction<TEvent> = (event: TEvent, local: boolean) => void;
+/**
+ * Callback for OnUpdateLivePresenceAction<TData extends object = object>.
+ * (data?: TData | undefined, state?: PresenceState | undefined) => Promise<void>
+ */
+export type OnUpdateLivePresenceAction<TData extends LivePresenceData = any> = (data: TData) => Promise<void>;
+/**
+ * Callback for OnStartTimerAction.
+ * (duration: number) => Promise<void>
+ */
+export type OnStartTimerAction = (duration: number) => Promise<void>;
+/**
+ * Callback for OnPlayTimerAction.
+ * () => Promise<void>
+ */
+export type OnPlayTimerAction = () => Promise<void>;
+/**
+ * Callback for OnPauseTimerAction.
+ * () => Promise<void>
+ */
+export type OnPauseTimerAction = () => Promise<void>;
+/**
+ * Callback for OnTimerTickAction.
+ * (milliRemaining: number) => void
+ */
+export type OnTimerTickAction = (milliRemaining: number) => void;
+/**
+ * Callback for OnTimerDidStartAction.
+ * (timerConfig: ITimerConfig) => void
+ */
+export type OnTimerDidStartAction = (timerConfig: ITimerConfig) => void;
+/**
+ * Callback for OnTimerDidPauseAction.
+ * (timerConfig: ITimerConfig) => void
+ */
+export type OnTimerDidPauseAction = (timerConfig: ITimerConfig) => void;
+/**
+ * Callback for OnTimerDidPlayAction.
+ * (timerConfig: ITimerConfig) => void
+ */
+export type OnTimerDidPlayAction = (timerConfig: ITimerConfig) => void;
+/**
+ * Callback for OnTimerDidFinishAction.
+ * (timerConfig: ITimerConfig) => void
+ */
+export type OnTimerDidFinishAction = (timerConfig: ITimerConfig) => void;
+//# sourceMappingURL=ActionTypes.d.ts.map

package/bin/esm/types/ActionTypes.d.ts.map

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

package/bin/esm/types/ActionTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionTypes.js","sourceRoot":"","sources":["../../../src/types/ActionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/bin/esm/types/PropTypes.d.ts

@@ -0,0 +1,56 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+import { UserMeetingRole } from "@microsoft/live-share";
+import { CanvasReferencePoint, IBrush, IPoint, InkingTool, LiveCanvasTreeNode } from "@microsoft/live-share-canvas";
+export type SharedMapInitialData<T> = Map<string, T> | readonly (readonly [string, T])[] | {
+    [key: string]: T;
+} | undefined;
+/**
+ * Optional props for {@link useLiveCanvas}
+ */
+export interface IUseLiveCanvasOptionalProps {
+    /**
+     * Optional. Stateful boolean that will activate/de-activate `InkingManager` accordingly.
+     */
+    active?: boolean;
+    /**
+     * Optional. Stateful enum for what tool to use in the `InkingManager`.
+     */
+    tool?: InkingTool;
+    /**
+     * Optional. Stateful lineBrush object for the selected lineBrush options to use in `InkingManager`.
+     */
+    lineBrush?: IBrush;
+    /**
+     * Optional. Stateful offset point to use in the `InkingManager`. Gets the viewport offset. Defaults to 0,0.
+     */
+    offset?: IPoint;
+    /**
+     * Optional. Stateful scale number to use in the `InkingManager`. Defaults to 1 and must be greater than 0.
+     */
+    scale?: number;
+    /**
+     * Optional. Stateful reference point enum to use in the `InkingManger`. Defaults to "center".
+     */
+    referencePoint?: CanvasReferencePoint;
+    /**
+     * Optional. Stateful boolean flag for whether cursor should be shared in `LiveCanvas`. Defaults to false.
+     */
+    isCursorShared?: boolean;
+    /**
+     * Optional. url string for the local user to display alongside their cursor. Defaults to undefined.
+     */
+    localUserPictureUrl?: string;
+    /**
+     * Optional. A Fluid `LiveCanvasTree` `TreeNode` instance to swap out the underlying storage solution for strokes.
+     * To learn more, look at Fluid's [SharedTree](https://fluidframework.com/docs/data-structures/tree/) documentation.
+     */
+    node?: LiveCanvasTreeNode;
+    /**
+     * Optional. The user roles that are allowed to start/stop/pause the timer.
+     */
+    allowedRoles?: UserMeetingRole[];
+}
+//# sourceMappingURL=PropTypes.d.ts.map

package/bin/esm/types/PropTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropTypes.d.ts","sourceRoot":"","sources":["../../../src/types/PropTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACH,oBAAoB,EACpB,MAAM,EACN,MAAM,EACN,UAAU,EACV,kBAAkB,EACrB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAC5B,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,GACd,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,GACjC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;CAAE,GACpB,SAAS,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,2BAA2B;IACxC;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B;;OAEG;IACH,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;CACpC"}

package/bin/esm/types/PropTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropTypes.js","sourceRoot":"","sources":["../../../src/types/PropTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG"}