@yorkie-js/react 0.6.23 → 0.6.24

package/dist/yorkie-js-react.js

@@ -6,12 +6,6 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const name$1 = "@yorkie-js/react";
-  const version$1 = "0.6.23";
-  const pkg$1 = {
-    name: name$1,
-    version: version$1
-  };
   var Code$1;
   (function(Code2) {
     Code2[Code2["Canceled"] = 1] = "Canceled";
@@ -2325,7 +2319,17 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           }
           switch (m.kind) {
             case "message":
-              return m.T.equals(va, vb);
+              let a2 = va;
+              let b2 = vb;
+              if (m.T.fieldWrapper) {
+                if (a2 !== void 0 && !isMessage(a2)) {
+                  a2 = m.T.fieldWrapper.wrapField(a2);
+                }
+                if (b2 !== void 0 && !isMessage(b2)) {
+                  b2 = m.T.fieldWrapper.wrapField(b2);
+                }
+              }
+              return m.T.equals(a2, b2);
             case "enum":
               return scalarEquals(ScalarType.INT32, va, vb);
             case "scalar":
@@ -7827,7 +7831,41 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         kind: "scalar",
         T: 9
         /* ScalarType.STRING */
-      }
+      },
+      {
+        no: 3,
+        name: "api_service",
+        kind: "scalar",
+        T: 9
+        /* ScalarType.STRING */
+      },
+      {
+        no: 4,
+        name: "quota_metric",
+        kind: "scalar",
+        T: 9
+        /* ScalarType.STRING */
+      },
+      {
+        no: 5,
+        name: "quota_id",
+        kind: "scalar",
+        T: 9
+        /* ScalarType.STRING */
+      },
+      { no: 6, name: "quota_dimensions", kind: "map", K: 9, V: {
+        kind: "scalar",
+        T: 9
+        /* ScalarType.STRING */
+      } },
+      {
+        no: 7,
+        name: "quota_value",
+        kind: "scalar",
+        T: 3
+        /* ScalarType.INT64 */
+      },
+      { no: 8, name: "future_quota_value", kind: "scalar", T: 3, opt: true }
     ],
     { localName: "QuotaFailure_Violation" }
   );
@@ -9474,7 +9512,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (value < 0) return UZERO;
       if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;
     } else {
-      if (value <= -9223372036854776e3) return MIN_VALUE;
+      if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;
       if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;
     }
     if (value < 0) return fromNumber(-value, unsigned).neg();
@@ -10006,13 +10044,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     );
   };
   if (typeof BigInt === "function") {
-    Long.fromBigInt = function fromBigInt2(value, unsigned) {
+    Long.fromBigInt = function fromBigInt(value, unsigned) {
       var lowBits = Number(BigInt.asIntN(32, value));
       var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));
       return fromBits(lowBits, highBits, unsigned);
     };
     Long.fromValue = function fromValueWithBigInt(value, unsigned) {
-      if (typeof value === "bigint") return fromBigInt(value, unsigned);
+      if (typeof value === "bigint") return Long.fromBigInt(value, unsigned);
       return fromValue(value, unsigned);
     };
     LongPrototype.toBigInt = function toBigInt() {
@@ -13197,7 +13235,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "_value", "");
       this.id = id;
       this.removedAt = removedAt;
-      attributes && (this.attrs = attributes);
+      if (attributes) {
+        this.attrs = attributes;
+      }
       if (typeof opts === "string") {
         this.value = opts;
       } else if (Array.isArray(opts)) {
@@ -17520,7 +17560,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               this.reconnectStreamDelay
             );
           });
-        } catch (err) {
+        } catch {
         }
       };
       await doLoop();
@@ -18467,9 +18507,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               );
               return toWrappedElement(context, inserted);
             };
-          } else if (method === "setInteger") {
+          } else if (method === "setValue") {
             return (index, value) => {
-              const array2 = ArrayProxy.setIntegerInternal(
+              const array2 = ArrayProxy.setValueInternal(
                 context,
                 target,
                 index,
@@ -18565,6 +18605,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           }
           return Reflect.get(target, method, receiver);
         },
+        set: (target, key, value) => {
+          if (isNumericString(key)) {
+            const index = Number(key);
+            ArrayProxy.setValueInternal(context, target, index, value);
+            return true;
+          }
+          return Reflect.set(target, key, value);
+        },
         deleteProperty: (target, key) => {
           if (logger.isEnabled(LogLevel.Trivial)) {
             logger.trivial(`array[${key}]`);
@@ -18741,9 +18789,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       );
     }
     /**
-     * `setIntegerInternal` sets the given integer at the given index.
+     * `setValueInternal` sets the given value at the given index.
      */
-    static setIntegerInternal(context, target, index, value) {
+    static setValueInternal(context, target, index, value) {
       const prev = target.get(index);
       if (!prev) {
         throw new YorkieError(
@@ -20584,10 +20632,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
                   targetOps.push(op);
                 }
               }
-              targetOps.length && callback({
-                ...docEvent,
-                value: { ...docEvent.value, operations: targetOps }
-              });
+              if (targetOps.length) {
+                callback({
+                  ...docEvent,
+                  value: { ...docEvent.value, operations: targetOps }
+                });
+              }
             }
           },
           arg3,
@@ -21523,18 +21573,18 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       setToken
     };
   }
-  const name = "@yorkie-js/sdk";
-  const version = "0.6.23";
-  const pkg = {
-    name,
-    version
+  const name$1 = "@yorkie-js/sdk";
+  const version$1 = "0.6.24";
+  const pkg$1 = {
+    name: name$1,
+    version: version$1
   };
   function createMetricInterceptor(userAgent) {
     return (next) => async (req) => {
       if (userAgent) {
         req.header.set("x-yorkie-user-agent", userAgent);
       } else {
-        req.header.set("x-yorkie-user-agent", pkg.name + "/" + pkg.version);
+        req.header.set("x-yorkie-user-agent", pkg$1.name + "/" + pkg$1.version);
       }
       return await next(req);
     };
@@ -21545,7 +21595,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (serialized === void 0) {
         return false;
       }
-    } catch (error) {
+    } catch {
       return false;
     }
     return true;
@@ -22096,7 +22146,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * the server and pulls remote changes from the server.
      */
     runSyncLoop() {
-      const doLoop = () => {
+      const doLoop = async () => {
         if (!this.isActive()) {
           logger.debug(`[SL] c:"${this.getKey()}" exit sync loop`);
           this.conditions[
@@ -22105,31 +22155,37 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           ] = false;
           return;
         }
-        const syncJobs = [];
-        for (const [, attachment] of this.attachmentMap) {
-          if (attachment.needRealtimeSync()) {
-            attachment.remoteChangeEventReceived = false;
-            syncJobs.push(
-              this.syncInternal(attachment, attachment.syncMode).catch(
-                async (err) => {
-                  if (err instanceof ConnectError && errorCodeOf(err) === Code.ErrUnauthenticated) {
-                    attachment.doc.publish([
-                      {
-                        type: DocEventType.AuthError,
-                        value: {
-                          reason: errorMetadataOf(err).reason,
-                          method: "PushPull"
+        try {
+          await this.enqueueTask(async () => {
+            const syncs = [];
+            for (const [, attachment] of this.attachmentMap) {
+              if (!attachment.needRealtimeSync()) {
+                continue;
+              }
+              attachment.remoteChangeEventReceived = false;
+              syncs.push(
+                this.syncInternal(attachment, attachment.syncMode).catch(
+                  async (err) => {
+                    if (err instanceof ConnectError && errorCodeOf(err) === Code.ErrUnauthenticated) {
+                      attachment.doc.publish([
+                        {
+                          type: DocEventType.AuthError,
+                          value: {
+                            reason: errorMetadataOf(err).reason,
+                            method: "PushPull"
+                          }
                         }
-                      }
-                    ]);
+                      ]);
+                    }
+                    throw err;
                   }
-                  throw err;
-                }
-              )
-            );
-          }
-        }
-        Promise.all(syncJobs).then(() => setTimeout(doLoop, this.syncLoopDuration)).catch(async (err) => {
+                )
+              );
+            }
+            await Promise.all(syncs);
+            setTimeout(doLoop, this.syncLoopDuration);
+          });
+        } catch (err) {
           logger.error(`[SL] c:"${this.getKey()}" sync failed:`, err);
           if (await this.handleConnectError(err)) {
             setTimeout(doLoop, this.retrySyncLoopDelay);
@@ -22139,7 +22195,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               /* SyncLoop */
             ] = false;
           }
-        });
+        }
       };
       logger.debug(`[SL] c:"${this.getKey()}" run sync loop`);
       this.conditions[
@@ -22178,6 +22234,18 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               )
             );
           }
+          if (!this.attachmentMap.has(docKey)) {
+            this.conditions[
+              "WatchLoop"
+              /* WatchLoop */
+            ] = false;
+            return Promise.reject(
+              new YorkieError(
+                Code.ErrDocumentNotAttached,
+                `${docKey} is not attached`
+              )
+            );
+          }
           const ac = new AbortController();
           const stream = this.rpcClient.watchDocument(
             {
@@ -22196,6 +22264,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             }
           ]);
           logger.info(`[WD] c:"${this.getKey()}" watches d:"${docKey}"`);
+          attachment.remoteChangeEventReceived = true;
           return new Promise((resolve, reject) => {
             const handleStream = async () => {
               try {
@@ -22370,7 +22439,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         this.processing = true;
         const task = this.taskQueue.shift();
         await task();
-      } catch (error) {
+      } catch {
         logger.error(`[TQ] c:"${this.getKey()}" process failed, id:"${this.id}"`);
       }
       this.processNext();
@@ -22394,6 +22463,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       LongType: CounterType.Long
     };
   }
+  const name = "@yorkie-js/react";
+  const version = "0.6.24";
+  const pkg = {
+    name,
+    version
+  };
   const YorkieContext = react.createContext({
     client: void 0,
     loading: true,
@@ -22441,7 +22516,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   }) => {
     const clientOpts = react.useMemo(() => {
       return {
-        userAgent: pkg$1.name + "/" + pkg$1.version,
+        userAgent: pkg.name + "/" + pkg.version,
         ...opts
       };
     }, [opts.apiKey, opts.rpcAddr]);
@@ -22459,59 +22534,213 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       error: context.error
     };
   };
-  function useYorkieDocument(client, clientLoading, clientError, docKey, initialRoot, initialPresence) {
-    const [doc, setDoc] = react.useState();
-    const [loading, setLoading] = react.useState(true);
-    const [error, setError] = react.useState();
-    const [root, setRoot] = react.useState(initialRoot);
-    const [presences, setPresences] = react.useState([]);
-    const [connection, setConnection] = react.useState(
-      StreamConnectionStatus.Disconnected
+  function createStore(initialState) {
+    const subscribers = /* @__PURE__ */ new Set();
+    let currentState = initialState;
+    const notify = () => {
+      subscribers.forEach((callback) => callback(currentState));
+    };
+    const setState = (newState) => {
+      const prevState = currentState;
+      currentState = typeof newState === "function" ? newState(prevState) : newState;
+      if (prevState !== currentState) {
+        notify();
+      }
+    };
+    const subscribe = (callback) => {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    };
+    const getSnapshot = () => currentState;
+    const destroy = () => {
+      subscribers.clear();
+    };
+    return {
+      subscribe,
+      getSnapshot,
+      setState,
+      destroy
+    };
+  }
+  const createDocumentStore = (initialState) => {
+    return createStore(initialState);
+  };
+  function useSelector(store, selector, equalityFn = Object.is) {
+    const selectorRef = react.useRef(selector);
+    const equalityFnRef = react.useRef(equalityFn);
+    const currentSliceRef = react.useRef(void 0);
+    selectorRef.current = selector;
+    equalityFnRef.current = equalityFn;
+    const getSelection = () => {
+      const state = store.getSnapshot();
+      const nextSlice = selectorRef.current ? selectorRef.current(state) : state;
+      if (currentSliceRef.current !== void 0 && equalityFnRef.current(currentSliceRef.current, nextSlice)) {
+        return currentSliceRef.current;
+      }
+      currentSliceRef.current = nextSlice;
+      return nextSlice;
+    };
+    return react.useSyncExternalStore(store.subscribe, getSelection, getSelection);
+  }
+  function isIterable(obj) {
+    return obj != null && typeof obj[Symbol.iterator] === "function";
+  }
+  function hasIterableEntries(value) {
+    return "entries" in value && typeof value.entries === "function";
+  }
+  function compareEntries(valueA, valueB) {
+    const mapA = valueA instanceof Map ? valueA : new Map(valueA.entries());
+    const mapB = valueB instanceof Map ? valueB : new Map(valueB.entries());
+    if (mapA.size !== mapB.size) {
+      return false;
+    }
+    for (const [key, value] of mapA) {
+      if (!mapB.has(key) || !Object.is(value, mapB.get(key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function compareIterables(valueA, valueB) {
+    const iteratorA = valueA[Symbol.iterator]();
+    const iteratorB = valueB[Symbol.iterator]();
+    let nextA = iteratorA.next();
+    let nextB = iteratorB.next();
+    while (!nextA.done && !nextB.done) {
+      if (!Object.is(nextA.value, nextB.value)) {
+        return false;
+      }
+      nextA = iteratorA.next();
+      nextB = iteratorB.next();
+    }
+    return nextA.done === nextB.done;
+  }
+  function comparePlainObjects(valueA, valueB) {
+    const keysA = Object.keys(valueA);
+    const keysB = Object.keys(valueB);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(valueB, key) || !Object.is(valueA[key], valueB[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function shallowEqual(valueA, valueB) {
+    if (Object.is(valueA, valueB)) {
+      return true;
+    }
+    if (typeof valueA !== "object" || valueA === null || typeof valueB !== "object" || valueB === null) {
+      return false;
+    }
+    if (Object.getPrototypeOf(valueA) !== Object.getPrototypeOf(valueB)) {
+      return false;
+    }
+    const isIterableA = isIterable(valueA);
+    const isIterableB = isIterable(valueB);
+    if (isIterableA !== isIterableB) {
+      return false;
+    }
+    if (isIterableA && isIterableB) {
+      if (hasIterableEntries(valueA) && hasIterableEntries(valueB)) {
+        return compareEntries(valueA, valueB);
+      }
+      return compareIterables(valueA, valueB);
+    }
+    return comparePlainObjects(
+      valueA,
+      valueB
     );
+  }
+  function useYorkieDocument(client, clientLoading, clientError, docKey, initialRoot, initialPresence, documentStore) {
+    const initialRootRef = react.useRef(initialRoot);
+    const initialPresenceRef = react.useRef(initialPresence);
+    const [didMount, setDidMount] = react.useState(false);
+    react.useEffect(() => {
+      setDidMount(true);
+    }, []);
     react.useEffect(() => {
       if (clientError) {
-        setLoading(false);
-        setError(clientError);
+        documentStore.setState((state) => ({
+          ...state,
+          loading: false,
+          error: clientError
+        }));
         return;
       }
-      if (!client || clientLoading) {
-        setLoading(true);
+      if (!client || clientLoading || !didMount) {
+        documentStore.setState((state) => ({
+          ...state,
+          loading: true
+        }));
         return;
       }
-      setLoading(true);
-      setError(void 0);
+      documentStore.setState((state) => ({
+        ...state,
+        loading: true,
+        error: void 0
+      }));
       const newDoc = new Document(docKey);
       const unsubs = [];
       unsubs.push(
         newDoc.subscribe(() => {
-          setRoot(newDoc.getRoot());
+          documentStore.setState((state) => ({
+            ...state,
+            root: newDoc.getRoot()
+          }));
         })
       );
       unsubs.push(
         newDoc.subscribe("presence", () => {
-          setPresences(newDoc.getPresences());
+          documentStore.setState((state) => ({
+            ...state,
+            presences: newDoc.getPresences()
+          }));
         })
       );
       unsubs.push(
         newDoc.subscribe("connection", (event) => {
-          setConnection(event.value);
+          documentStore.setState((state) => ({
+            ...state,
+            connection: event.value
+          }));
         })
       );
       async function attachDocument() {
         try {
           await (client == null ? void 0 : client.attach(newDoc, {
-            initialRoot,
-            initialPresence
+            initialRoot: initialRootRef.current,
+            initialPresence: initialPresenceRef.current
+          }));
+          const update = (callback) => {
+            try {
+              newDoc.update(callback);
+            } catch (err) {
+              documentStore.setState((state) => ({
+                ...state,
+                error: err instanceof Error ? err : new Error("Failed to update document")
+              }));
+            }
+          };
+          documentStore.setState((state) => ({
+            ...state,
+            doc: newDoc,
+            root: newDoc.getRoot(),
+            presences: newDoc.getPresences(),
+            update
           }));
-          setDoc(newDoc);
-          setRoot(newDoc.getRoot());
-          setPresences(newDoc.getPresences());
         } catch (err) {
-          setError(
-            err instanceof Error ? err : new Error("Failed to attach document")
-          );
+          documentStore.setState((state) => ({
+            ...state,
+            error: err instanceof Error ? err : new Error("Failed to attach document")
+          }));
         } finally {
-          setLoading(false);
+          documentStore.setState((state) => ({
+            ...state,
+            loading: false
+          }));
         }
       }
       attachDocument();
@@ -22523,35 +22752,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           unsub();
         }
       };
-    }, [client, clientLoading, clientError, docKey]);
-    const update = react.useCallback(
-      (callback) => {
-        if (!doc) {
-          return;
-        }
-        try {
-          doc.update(callback);
-        } catch (err) {
-          setError(
-            err instanceof Error ? err : new Error("Failed to update document")
-          );
-        }
-      },
-      [doc]
-    );
-    return {
-      doc,
-      root,
-      presences,
-      connection,
-      update,
-      loading,
-      error
-    };
+    }, [client, clientLoading, clientError, docKey, documentStore, didMount]);
   }
-  const DocumentContext = react.createContext(
-    null
-  );
+  const DocumentContext = react.createContext(void 0);
   const DocumentProvider = ({
     docKey,
     initialRoot = {},
@@ -22559,98 +22762,117 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     children
   }) => {
     const { client, loading: clientLoading, error: clientError } = useYorkie();
-    const { doc, root, presences, connection, update, loading, error } = useYorkieDocument(
+    const documentStoreRef = react.useRef(void 0);
+    if (!documentStoreRef.current) {
+      documentStoreRef.current = createDocumentStore({
+        doc: void 0,
+        root: initialRoot,
+        presences: [],
+        connection: StreamConnectionStatus.Disconnected,
+        update: () => {
+        },
+        loading: true,
+        error: void 0
+      });
+    }
+    const documentStore = documentStoreRef.current;
+    useYorkieDocument(
       client,
       clientLoading,
       clientError,
       docKey,
       initialRoot,
-      initialPresence
-    );
-    return /* @__PURE__ */ jsxRuntime.jsx(
-      DocumentContext.Provider,
-      {
-        value: {
-          doc,
-          root,
-          presences,
-          connection,
-          update,
-          loading,
-          error
-        },
-        children
-      }
+      initialPresence,
+      documentStore
     );
+    return /* @__PURE__ */ jsxRuntime.jsx(DocumentContext.Provider, { value: documentStore, children });
   };
-  const useDocument = () => {
-    const context = react.useContext(DocumentContext);
-    if (!context) {
+  function useDocument() {
+    const documentStore = react.useContext(DocumentContext);
+    if (!documentStore) {
       throw new Error("useDocument must be used within a DocumentProvider");
     }
-    return {
-      doc: context.doc,
-      root: context.root,
-      presences: context.presences,
-      connection: context.connection,
-      update: context.update,
-      loading: context.loading,
-      error: context.error
+    return useSelector(documentStore);
+  }
+  const createDocumentSelector = () => {
+    return (selector, equalityFn = shallowEqual) => {
+      const documentStore = react.useContext(DocumentContext);
+      if (!documentStore) {
+        throw new Error("useDocument must be used within a DocumentProvider");
+      }
+      return useSelector(documentStore, selector, equalityFn);
     };
   };
   const useRoot = () => {
-    const context = react.useContext(DocumentContext);
-    if (!context) {
-      throw new Error("useRoot must be used within a DocumentProvider");
-    }
-    return { root: context.root };
+    const documentStore = useDocumentStore("useRoot");
+    const root = useSelector(documentStore, (store) => store.root);
+    return { root };
   };
   const usePresences = () => {
-    const context = react.useContext(DocumentContext);
-    if (!context) {
-      throw new Error("usePresences must be used within a DocumentProvider");
-    }
-    return context.presences;
+    const documentStore = useDocumentStore("usePresences");
+    return useSelector(documentStore, (store) => store.presences);
   };
   const useConnection = () => {
-    const context = react.useContext(DocumentContext);
-    if (!context) {
-      throw new Error("useConnection must be used within a DocumentProvider");
+    const documentStore = useDocumentStore("useConnection");
+    return useSelector(documentStore, (store) => store.connection);
+  };
+  const useDocumentStore = (hookName) => {
+    const documentStore = react.useContext(DocumentContext);
+    if (!documentStore) {
+      throw new Error(`${hookName} must be used within a DocumentProvider`);
     }
-    return context.connection;
+    return documentStore;
   };
   function useYorkieDoc(apiKey, docKey, opts) {
+    const documentStoreRef = react.useRef(void 0);
+    if (!documentStoreRef.current) {
+      documentStoreRef.current = createDocumentStore({
+        doc: void 0,
+        root: (opts == null ? void 0 : opts.initialRoot) ?? {},
+        presences: [],
+        connection: StreamConnectionStatus.Disconnected,
+        update: () => {
+        },
+        loading: true,
+        error: void 0
+      });
+    }
+    const documentStore = documentStoreRef.current;
     const clientOpts = react.useMemo(() => {
       return {
         apiKey,
-        userAgent: pkg$1.name + "/" + pkg$1.version,
+        userAgent: pkg.name + "/" + pkg.version,
         ...opts
       };
-    }, [apiKey]);
+    }, [apiKey, opts]);
     const {
       client,
       loading: clientLoading,
       error: clientError
     } = useYorkieClient(clientOpts);
-    const { root, presences, connection, update, loading, error } = useYorkieDocument(
+    useYorkieDocument(
       client,
       clientLoading,
       clientError,
       docKey,
-      opts == null ? void 0 : opts.initialRoot,
-      opts == null ? void 0 : opts.initialPresence
+      (opts == null ? void 0 : opts.initialRoot) ?? {},
+      (opts == null ? void 0 : opts.initialPresence) ?? {},
+      documentStore
     );
+    const documentState = useSelector(documentStore);
     return {
-      root,
-      presences,
-      connection,
-      update,
-      loading,
-      error
+      root: documentState.root,
+      presences: documentState.presences,
+      connection: documentState.connection,
+      update: documentState.update,
+      loading: documentState.loading,
+      error: documentState.error
     };
   }
   exports2.DocumentProvider = DocumentProvider;
   exports2.YorkieProvider = YorkieProvider;
+  exports2.createDocumentSelector = createDocumentSelector;
+  exports2.shallowEqual = shallowEqual;
   exports2.useConnection = useConnection;
   exports2.useDocument = useDocument;
   exports2.usePresences = usePresences;