@getguru/slate-yjs-react 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# @slate-yjs/react
+
+## 1.1.0
+
+### Minor Changes
+
+- [#412](https://github.com/BitPhinix/slate-yjs/pull/412) [`8ab46c0`](https://github.com/BitPhinix/slate-yjs/commit/8ab46c0bcdacdd18133b60b5fc885c915580c5f5) Thanks [@ilya2204](https://github.com/ilya2204)! - Add error handling to cursor overlay
+
+## 1.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`a6a27c8`](https://github.com/BitPhinix/slate-yjs/commit/a6a27c86678656e55ecbf0ba76852545605a0955), [`a6a27c8`](https://github.com/BitPhinix/slate-yjs/commit/a6a27c86678656e55ecbf0ba76852545605a0955), [`72bbbf3`](https://github.com/BitPhinix/slate-yjs/commit/72bbbf3bb8a3f57762153cbd9a7f689d2b282f0c)]:
+  - @slate-yjs/core@1.0.0
+
+## 0.3.0
+
+### Minor Changes
+
+- [#363](https://github.com/BitPhinix/slate-yjs/pull/363) [`3710c48`](https://github.com/BitPhinix/slate-yjs/commit/3710c4887ee89946ace787ba24436d82d95bc856) Thanks [@BitPhinix](https://github.com/BitPhinix)! - Changed:
+
+  - Rewrite of `useRemoteCursorOverlayPositions` to provide stricter typings, make it react 18 safe and add new `shouldGenerateOverlay` option.
+
+  Added:
+
+  - Remote cursor decorations using the new `useDecorateRemoteCursors` hook
+  - Remote cursor data hooks `useRemoteCursorStatesSelector` and `useRemoteCursorStates`
+  - Utility hooks to un-send the current cursor position on window/editor blur: `useUnsetCursorPositionOnBlur`
+  - `getCursorRange` helper
+
+### Patch Changes
+
+- Updated dependencies [[`3710c48`](https://github.com/BitPhinix/slate-yjs/commit/3710c4887ee89946ace787ba24436d82d95bc856)]:
+  - @slate-yjs/core@0.3.0
+
+## 0.2.4
+
+### Patch Changes
+
+- [#339](https://github.com/BitPhinix/slate-yjs/pull/339) [`042a0a2`](https://github.com/BitPhinix/slate-yjs/commit/042a0a22f57ed7542a4e05840532f16d37629e33) Thanks [@BitPhinix](https://github.com/BitPhinix)! - Replace workspace:^ dependencies with concrete version range
+
+## 0.2.3
+
+### Patch Changes
+
+- Updated dependencies [[`5172e4a`](https://github.com/BitPhinix/slate-yjs/commit/5172e4a0033db41bc3530f227c5371e9ddb22269)]:
+  - @slate-yjs/core@0.2.3

package/README.md

@@ -0,0 +1,3 @@
+This package contains React specific components/utils for slate-yjs. Feel free to poke around to learn more!
+
+Docs: https://docs.slate-yjs.dev/api/slate-yjs-react

package/dist/hooks/useDecorateRemoteCursors.d.ts

@@ -0,0 +1,24 @@
+import { CursorState } from '@getguru/slate-yjs-core';
+import { BaseRange, BaseText, NodeEntry } from 'slate';
+export declare const REMOTE_CURSOR_DECORATION_PREFIX = "remote-cursor-";
+export declare const REMOTE_CURSOR_CARET_DECORATION_PREFIX = "remote-caret-";
+export declare type RemoteCaretDecoration<TCursorData extends Record<string, unknown> = Record<string, unknown>> = {
+    [key: `${typeof REMOTE_CURSOR_CARET_DECORATION_PREFIX}${string}`]: CursorState<TCursorData> & {
+        isBackward: boolean;
+    };
+};
+export declare type RemoteCursorDecoration<TCursorData extends Record<string, unknown> = Record<string, unknown>> = {
+    [key: `${typeof REMOTE_CURSOR_DECORATION_PREFIX}${string}`]: CursorState<TCursorData>;
+};
+export declare type RemoteCursorDecoratedRange<TCursorData extends Record<string, unknown> = Record<string, unknown>> = BaseRange & RemoteCursorDecoration<TCursorData>;
+export declare type RemoteCaretDecoratedRange<TCursorData extends Record<string, unknown> = Record<string, unknown>> = BaseRange & RemoteCaretDecoration<TCursorData>;
+export declare type TextWithRemoteCursors<TCursorData extends Record<string, unknown> = Record<string, unknown>> = BaseText & RemoteCursorDecoration<TCursorData> & RemoteCaretDecoration<TCursorData>;
+export declare function getRemoteCursorsOnLeaf<TCursorData extends Record<string, unknown>, TLeaf extends TextWithRemoteCursors<TCursorData>>(leaf: TLeaf): CursorState<TCursorData>[];
+export declare function getRemoteCaretsOnLeaf<TCursorData extends Record<string, unknown>, TLeaf extends TextWithRemoteCursors<TCursorData>>(leaf: TLeaf): (CursorState<TCursorData> & {
+    isBackward: boolean;
+})[];
+export declare type UseDecorateRemoteCursorsOptions = {
+    carets?: boolean;
+};
+export declare function useDecorateRemoteCursors<TCursorData extends Record<string, unknown> = Record<string, unknown>>({ carets }?: UseDecorateRemoteCursorsOptions): (entry: NodeEntry<import("slate").Node>) => (RemoteCursorDecoratedRange<TCursorData> | RemoteCaretDecoratedRange<TCursorData>)[];
+//# sourceMappingURL=useDecorateRemoteCursors.d.ts.map

package/dist/hooks/useDecorateRemoteCursors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDecorateRemoteCursors.d.ts","sourceRoot":"","sources":["../../src/hooks/useDecorateRemoteCursors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAS,MAAM,OAAO,CAAC;AAK9D,eAAO,MAAM,+BAA+B,mBAAmB,CAAC;AAChE,eAAO,MAAM,qCAAqC,kBAAkB,CAAC;AAErE,oBAAY,qBAAqB,CAC/B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE;IACF,CACE,GAAG,EAAE,GAAG,OAAO,qCAAqC,GAAG,MAAM,EAAE,GAC9D,WAAW,CAAC,WAAW,CAAC,GAAG;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;CACvD,CAAC;AAEF,oBAAY,sBAAsB,CAChC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE;IACF,CACE,GAAG,EAAE,GAAG,OAAO,+BAA+B,GAAG,MAAM,EAAE,GACxD,WAAW,CAAC,WAAW,CAAC,CAAC;CAC7B,CAAC;AAEF,oBAAY,0BAA0B,CACpC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE,SAAS,GAAG,sBAAsB,CAAC,WAAW,CAAC,CAAC;AAEpD,oBAAY,yBAAyB,CACnC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE,SAAS,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAC;AAEnD,oBAAY,qBAAqB,CAC/B,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE,QAAQ,GACV,sBAAsB,CAAC,WAAW,CAAC,GACnC,qBAAqB,CAAC,WAAW,CAAC,CAAC;AAErC,wBAAgB,sBAAsB,CACpC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,KAAK,SAAS,qBAAqB,CAAC,WAAW,CAAC,EAChD,IAAI,EAAE,KAAK,GAAG,WAAW,CAAC,WAAW,CAAC,EAAE,CAIzC;AAED,wBAAgB,qBAAqB,CACnC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,KAAK,SAAS,qBAAqB,CAAC,WAAW,CAAC,EAChD,IAAI,EAAE,KAAK,GAAG,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAIrE;AAED,oBAAY,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA0BF,wBAAgB,wBAAwB,CACtC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,EAAE,MAAa,EAAE,GAAE,+BAAoC,oIAoCxD"}

package/dist/hooks/useRemoteCursorEditor.d.ts

@@ -0,0 +1,4 @@
+import { CursorEditor } from '@getguru/slate-yjs-core';
+import { ReactEditor } from 'slate-react';
+export declare function useRemoteCursorEditor<TCursorData extends Record<string, unknown> = Record<string, unknown>>(): CursorEditor<TCursorData> & ReactEditor;
+//# sourceMappingURL=useRemoteCursorEditor.d.ts.map

package/dist/hooks/useRemoteCursorEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteCursorEditor.d.ts","sourceRoot":"","sources":["../../src/hooks/useRemoteCursorEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE1D,wBAAgB,qBAAqB,CACnC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAClE,YAAY,CAAC,WAAW,CAAC,GAAG,WAAW,CAS3C"}

package/dist/hooks/useRemoteCursorOverlayPositions.d.ts

@@ -0,0 +1,19 @@
+import { CursorState } from '@getguru/slate-yjs-core';
+import { RefObject } from 'react';
+import { BaseRange, NodeMatch, Text } from 'slate';
+import { CaretPosition, SelectionRect } from '../utils/getOverlayPosition';
+export declare type UseRemoteCursorOverlayPositionsOptions<T extends HTMLElement> = {
+    shouldGenerateOverlay?: NodeMatch<Text>;
+} & ({
+    containerRef?: undefined;
+} | {
+    containerRef: RefObject<T>;
+    refreshOnResize?: boolean | 'debounced';
+});
+export declare type CursorOverlayData<TCursorData extends Record<string, unknown>> = CursorState<TCursorData> & {
+    range: BaseRange | null;
+    caretPosition: CaretPosition | null;
+    selectionRects: SelectionRect[];
+};
+export declare function useRemoteCursorOverlayPositions<TCursorData extends Record<string, unknown>, TContainer extends HTMLElement = HTMLDivElement>({ containerRef, shouldGenerateOverlay, ...opts }?: UseRemoteCursorOverlayPositionsOptions<TContainer>): readonly [CursorOverlayData<TCursorData>[], () => void];
+//# sourceMappingURL=useRemoteCursorOverlayPositions.d.ts.map

package/dist/hooks/useRemoteCursorOverlayPositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteCursorOverlayPositions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRemoteCursorOverlayPositions.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EACL,SAAS,EAMV,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAEnD,OAAO,EACL,aAAa,EAGb,aAAa,EACd,MAAM,6BAA6B,CAAC;AAOrC,oBAAY,sCAAsC,CAAC,CAAC,SAAS,WAAW,IAAI;IAC1E,qBAAqB,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;CACzC,GAAG,CACA;IAIE,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B,GACD;IACE,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAK3B,eAAe,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;CACzC,CACJ,CAAC;AAEF,oBAAY,iBAAiB,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACvE,WAAW,CAAC,WAAW,CAAC,GAAG;IACzB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,cAAc,EAAE,aAAa,EAAE,CAAC;CACjC,CAAC;AAEJ,wBAAgB,+BAA+B,CAC7C,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3C,UAAU,SAAS,WAAW,GAAG,cAAc,EAC/C,EACA,YAAY,EACZ,qBAAqB,EACrB,GAAG,IAAI,EACR,GAAE,sCAAsC,CAAC,UAAU,CAAM,2DAuFzD"}

package/dist/hooks/useRemoteCursorStateStore.d.ts

@@ -0,0 +1,5 @@
+import { CursorState } from '@getguru/slate-yjs-core';
+import { Store } from '../types';
+export declare type CursorStore<TCursorData extends Record<string, unknown> = Record<string, unknown>> = Store<Record<string, CursorState<TCursorData>>>;
+export declare function useRemoteCursorStateStore<TCursorData extends Record<string, unknown> = Record<string, unknown>>(): CursorStore<TCursorData>;
+//# sourceMappingURL=useRemoteCursorStateStore.d.ts.map

package/dist/hooks/useRemoteCursorStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteCursorStateStore.d.ts","sourceRoot":"","sources":["../../src/hooks/useRemoteCursorStateStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAEZ,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGjC,oBAAY,WAAW,CACrB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;AAwEpD,wBAAgB,yBAAyB,CACvC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,8BAItE"}

package/dist/hooks/useRemoteCursorStates.d.ts

@@ -0,0 +1,4 @@
+import { CursorState } from '@getguru/slate-yjs-core';
+export declare function useRemoteCursorStates<TCursorData extends Record<string, unknown> = Record<string, unknown>>(): Record<string, CursorState<TCursorData>>;
+export declare function useRemoteCursorStatesSelector<TCursorData extends Record<string, unknown> = Record<string, unknown>, TSelection = unknown>(selector: (cursors: Record<string, CursorState<TCursorData>>) => TSelection, isEqual?: (a: TSelection, b: TSelection) => boolean): TSelection;
+//# sourceMappingURL=useRemoteCursorStates.d.ts.map

package/dist/hooks/useRemoteCursorStates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRemoteCursorStates.d.ts","sourceRoot":"","sources":["../../src/hooks/useRemoteCursorStates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAKtD,wBAAgB,qBAAqB,CACnC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,8CAItE;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,UAAU,GAAG,OAAO,EAEpB,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,KAAK,UAAU,EAC3E,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,KAAK,OAAO,GAClD,UAAU,CASZ"}

package/dist/hooks/useUnsetCursorPositionOnBlur.d.ts

@@ -0,0 +1,2 @@
+export declare function useUnsetCursorPositionOnBlur(): void;
+//# sourceMappingURL=useUnsetCursorPositionOnBlur.d.ts.map

package/dist/hooks/useUnsetCursorPositionOnBlur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnsetCursorPositionOnBlur.d.ts","sourceRoot":"","sources":["../../src/hooks/useUnsetCursorPositionOnBlur.ts"],"names":[],"mappings":"AAKA,wBAAgB,4BAA4B,SA0C3C"}

package/dist/hooks/utils.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from 'react';
+export declare function useRequestRerender(): (immediately?: any) => void;
+export declare function useOnResize<T extends HTMLElement>(ref: RefObject<T> | undefined, onResize: () => void): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/hooks/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/hooks/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAMV,MAAM,OAAO,CAAC;AAEf,wBAAgB,kBAAkB,gCA0BjC;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/C,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,IAAI,QAqBrB"}

package/dist/index.cjs

@@ -0,0 +1,453 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  getCursorRange: () => getCursorRange,
+  getRemoteCaretsOnLeaf: () => getRemoteCaretsOnLeaf,
+  getRemoteCursorsOnLeaf: () => getRemoteCursorsOnLeaf,
+  useDecorateRemoteCursors: () => useDecorateRemoteCursors,
+  useRemoteCursorOverlayPositions: () => useRemoteCursorOverlayPositions,
+  useRemoteCursorStates: () => useRemoteCursorStates,
+  useRemoteCursorStatesSelector: () => useRemoteCursorStatesSelector,
+  useUnsetCursorPositionOnBlur: () => useUnsetCursorPositionOnBlur
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/hooks/useDecorateRemoteCursors.ts
+var import_react = require("react");
+var import_slate = require("slate");
+
+// src/utils/getCursorRange.ts
+var import_slate_yjs_core = require("@getguru/slate-yjs-core");
+var CHILDREN_TO_CURSOR_STATE_TO_RANGE = /* @__PURE__ */ new WeakMap();
+function getCursorRange(editor, cursorState) {
+  if (!cursorState.relativeSelection) {
+    return null;
+  }
+  let cursorStates = CHILDREN_TO_CURSOR_STATE_TO_RANGE.get(editor.children);
+  if (!cursorStates) {
+    cursorStates = /* @__PURE__ */ new WeakMap();
+    CHILDREN_TO_CURSOR_STATE_TO_RANGE.set(editor.children, cursorStates);
+  }
+  let range = cursorStates.get(cursorState);
+  if (range === void 0) {
+    try {
+      range = (0, import_slate_yjs_core.relativeRangeToSlateRange)(editor.sharedRoot, editor, cursorState.relativeSelection);
+      cursorStates.set(cursorState, range);
+    } catch (e) {
+      return null;
+    }
+  }
+  return range;
+}
+
+// src/hooks/useRemoteCursorEditor.ts
+var import_slate_yjs_core2 = require("@getguru/slate-yjs-core");
+var import_slate_react = require("slate-react");
+function useRemoteCursorEditor() {
+  const editor = (0, import_slate_react.useSlateStatic)();
+  if (!import_slate_yjs_core2.CursorEditor.isCursorEditor(editor)) {
+    throw new Error("Cannot use useSyncExternalStore outside the context of a RemoteCursorEditor");
+  }
+  return editor;
+}
+
+// src/hooks/useRemoteCursorStates.ts
+var import_shim = require("use-sync-external-store/shim");
+var import_with_selector = require("use-sync-external-store/shim/with-selector");
+
+// src/hooks/useRemoteCursorStateStore.ts
+var import_slate_yjs_core3 = require("@getguru/slate-yjs-core");
+var EDITOR_TO_CURSOR_STORE = /* @__PURE__ */ new WeakMap();
+function createRemoteCursorStateStore(editor) {
+  let cursors = {};
+  const changed = /* @__PURE__ */ new Set();
+  const addChanged = changed.add.bind(changed);
+  const onStoreChangeListeners = /* @__PURE__ */ new Set();
+  let changeHandler = null;
+  const subscribe = (onStoreChange) => {
+    onStoreChangeListeners.add(onStoreChange);
+    if (!changeHandler) {
+      changeHandler = (event) => {
+        event.added.forEach(addChanged);
+        event.removed.forEach(addChanged);
+        event.updated.forEach(addChanged);
+        onStoreChangeListeners.forEach((listener) => listener());
+      };
+      import_slate_yjs_core3.CursorEditor.on(editor, "change", changeHandler);
+    }
+    return () => {
+      onStoreChangeListeners.delete(onStoreChange);
+      if (changeHandler && onStoreChangeListeners.size === 0) {
+        import_slate_yjs_core3.CursorEditor.off(editor, "change", changeHandler);
+        changeHandler = null;
+      }
+    };
+  };
+  const getSnapshot = () => {
+    if (changed.size === 0) {
+      return cursors;
+    }
+    changed.forEach((clientId) => {
+      const state = import_slate_yjs_core3.CursorEditor.cursorState(editor, clientId);
+      if (state === null) {
+        delete cursors[clientId.toString()];
+        return;
+      }
+      cursors[clientId] = state;
+    });
+    changed.clear();
+    cursors = __spreadValues({}, cursors);
+    return cursors;
+  };
+  return [subscribe, getSnapshot];
+}
+function getCursorStateStore(editor) {
+  const existing = EDITOR_TO_CURSOR_STORE.get(editor);
+  if (existing) {
+    return existing;
+  }
+  const store = createRemoteCursorStateStore(editor);
+  EDITOR_TO_CURSOR_STORE.set(editor, store);
+  return store;
+}
+function useRemoteCursorStateStore() {
+  const editor = useRemoteCursorEditor();
+  return getCursorStateStore(editor);
+}
+
+// src/hooks/useRemoteCursorStates.ts
+function useRemoteCursorStates() {
+  const [subscribe, getSnapshot] = useRemoteCursorStateStore();
+  return (0, import_shim.useSyncExternalStore)(subscribe, getSnapshot);
+}
+function useRemoteCursorStatesSelector(selector, isEqual) {
+  const [subscribe, getSnapshot] = useRemoteCursorStateStore();
+  return (0, import_with_selector.useSyncExternalStoreWithSelector)(subscribe, getSnapshot, null, selector, isEqual);
+}
+
+// src/hooks/useDecorateRemoteCursors.ts
+var REMOTE_CURSOR_DECORATION_PREFIX = "remote-cursor-";
+var REMOTE_CURSOR_CARET_DECORATION_PREFIX = "remote-caret-";
+function getRemoteCursorsOnLeaf(leaf) {
+  return Object.entries(leaf).filter(([key]) => key.startsWith(REMOTE_CURSOR_DECORATION_PREFIX)).map(([, data]) => data);
+}
+function getRemoteCaretsOnLeaf(leaf) {
+  return Object.entries(leaf).filter(([key]) => key.startsWith(REMOTE_CURSOR_CARET_DECORATION_PREFIX)).map(([, data]) => data);
+}
+function getDecoration(clientId, state, range, caret) {
+  if (!caret) {
+    const key2 = `${REMOTE_CURSOR_DECORATION_PREFIX}${clientId}`;
+    return __spreadProps(__spreadValues({}, range), { [key2]: state });
+  }
+  const key = `${REMOTE_CURSOR_CARET_DECORATION_PREFIX}${clientId}`;
+  return __spreadProps(__spreadValues({}, range), {
+    anchor: range.focus,
+    [key]: state
+  });
+}
+function useDecorateRemoteCursors({ carets = true } = {}) {
+  const editor = useRemoteCursorEditor();
+  const cursors = useRemoteCursorStates();
+  const cursorsRef = (0, import_react.useRef)(cursors);
+  cursorsRef.current = cursors;
+  return (0, import_react.useCallback)((entry) => {
+    const [, path] = entry;
+    if (path.length !== 0) {
+      return [];
+    }
+    return Object.entries(cursorsRef.current).flatMap(([clientId, state]) => {
+      const range = getCursorRange(editor, state);
+      if (!range) {
+        return [];
+      }
+      if (carets && import_slate.Range.isCollapsed(range)) {
+        return getDecoration(clientId, state, range, true);
+      }
+      if (!carets) {
+        return getDecoration(clientId, state, range, false);
+      }
+      return [
+        getDecoration(clientId, state, range, false),
+        getDecoration(clientId, state, range, true)
+      ];
+    });
+  }, [carets, editor]);
+}
+
+// src/hooks/useUnsetCursorPositionOnBlur.ts
+var import_slate_yjs_core4 = require("@getguru/slate-yjs-core");
+var import_react2 = require("react");
+var import_slate_react2 = require("slate-react");
+function useUnsetCursorPositionOnBlur() {
+  const editor = useRemoteCursorEditor();
+  const isSlateFocused = (0, import_slate_react2.useFocused)();
+  const sendCursorPosition = (0, import_react2.useCallback)((isFocused) => {
+    if (isFocused && editor.selection) {
+      import_slate_yjs_core4.CursorEditor.sendCursorPosition(editor, editor.selection);
+      return;
+    }
+    if (!isFocused) {
+      import_slate_yjs_core4.CursorEditor.sendCursorPosition(editor, null);
+    }
+  }, [editor]);
+  (0, import_react2.useEffect)(() => {
+    const handleWindowBlur = () => {
+      if (isSlateFocused) {
+        sendCursorPosition(false);
+      }
+    };
+    const handleWindowFocus = () => {
+      if (isSlateFocused) {
+        sendCursorPosition(true);
+      }
+    };
+    window.addEventListener("blur", handleWindowBlur);
+    window.addEventListener("focus", handleWindowFocus);
+    return () => {
+      window.removeEventListener("blur", handleWindowBlur);
+      window.removeEventListener("focus", handleWindowFocus);
+    };
+  }, [isSlateFocused, sendCursorPosition]);
+  (0, import_react2.useEffect)(() => {
+    sendCursorPosition(isSlateFocused);
+  }, [editor, isSlateFocused, sendCursorPosition]);
+}
+
+// src/hooks/useRemoteCursorOverlayPositions.tsx
+var import_react4 = require("react");
+
+// src/utils/getOverlayPosition.ts
+var import_slate2 = require("slate");
+var import_slate_react4 = require("slate-react");
+
+// src/utils/react-editor-to-dom-range-safe.ts
+var import_slate_react3 = require("slate-react");
+function reactEditorToDomRangeSafe(editor, range) {
+  try {
+    return import_slate_react3.ReactEditor.toDOMRange(editor, range);
+  } catch (e) {
+    return null;
+  }
+}
+
+// src/utils/getOverlayPosition.ts
+function getOverlayPosition(editor, range, { yOffset, xOffset, shouldGenerateOverlay }) {
+  const [start, end] = import_slate2.Range.edges(range);
+  const domRange = reactEditorToDomRangeSafe(editor, range);
+  if (!domRange) {
+    return {
+      caretPosition: null,
+      selectionRects: []
+    };
+  }
+  const selectionRects = [];
+  const nodeIterator = import_slate2.Editor.nodes(editor, {
+    at: range,
+    match: (n, p) => import_slate2.Text.isText(n) && (!shouldGenerateOverlay || shouldGenerateOverlay(n, p))
+  });
+  let caretPosition = null;
+  const isBackward = import_slate2.Range.isBackward(range);
+  for (const [node, path] of nodeIterator) {
+    const domNode = import_slate_react4.ReactEditor.toDOMNode(editor, node);
+    const isStartNode = import_slate2.Path.equals(path, start.path);
+    const isEndNode = import_slate2.Path.equals(path, end.path);
+    let clientRects = null;
+    if (isStartNode || isEndNode) {
+      const nodeRange = document.createRange();
+      nodeRange.selectNode(domNode);
+      if (isStartNode) {
+        nodeRange.setStart(domRange.startContainer, domRange.startOffset);
+      }
+      if (isEndNode) {
+        nodeRange.setEnd(domRange.endContainer, domRange.endOffset);
+      }
+      clientRects = nodeRange.getClientRects();
+    } else {
+      clientRects = domNode.getClientRects();
+    }
+    const isCaret = isBackward ? isStartNode : isEndNode;
+    for (let i = 0; i < clientRects.length; i++) {
+      const clientRect = clientRects.item(i);
+      if (!clientRect) {
+        continue;
+      }
+      const isCaretRect = isCaret && (isBackward ? i === 0 : i === clientRects.length - 1);
+      const top = clientRect.top - yOffset;
+      const left = clientRect.left - xOffset;
+      if (isCaretRect) {
+        caretPosition = {
+          height: clientRect.height,
+          top,
+          left: left + (isBackward || import_slate2.Range.isCollapsed(range) ? 0 : clientRect.width)
+        };
+      }
+      selectionRects.push({
+        width: clientRect.width,
+        height: clientRect.height,
+        top,
+        left
+      });
+    }
+  }
+  return {
+    selectionRects,
+    caretPosition
+  };
+}
+
+// src/hooks/utils.ts
+var import_react3 = require("react");
+function useRequestRerender() {
+  const [, rerender] = (0, import_react3.useReducer)((s) => s + 1, 0);
+  const animationFrameIdRef = (0, import_react3.useRef)(null);
+  const clearAnimationFrame = () => {
+    if (animationFrameIdRef.current) {
+      cancelAnimationFrame(animationFrameIdRef.current);
+      animationFrameIdRef.current = 0;
+    }
+  };
+  (0, import_react3.useEffect)(clearAnimationFrame);
+  (0, import_react3.useEffect)(() => clearAnimationFrame, []);
+  return (0, import_react3.useCallback)((immediately = false) => {
+    if (immediately) {
+      rerender();
+      return;
+    }
+    if (animationFrameIdRef.current) {
+      return;
+    }
+    animationFrameIdRef.current = requestAnimationFrame(rerender);
+  }, []);
+}
+function useOnResize(ref, onResize) {
+  const onResizeRef = (0, import_react3.useRef)(onResize);
+  onResizeRef.current = onResize;
+  const [observer] = (0, import_react3.useState)(() => new ResizeObserver(() => {
+    onResizeRef.current();
+  }));
+  (0, import_react3.useEffect)(() => {
+    if (!(ref == null ? void 0 : ref.current)) {
+      return;
+    }
+    const { current: element } = ref;
+    observer.observe(element);
+    return () => observer.unobserve(element);
+  }, [observer, ref]);
+}
+
+// src/hooks/useRemoteCursorOverlayPositions.tsx
+var FROZEN_EMPTY_ARRAY = Object.freeze([]);
+function useRemoteCursorOverlayPositions(_a = {}) {
+  var _b = _a, {
+    containerRef,
+    shouldGenerateOverlay
+  } = _b, opts = __objRest(_b, [
+    "containerRef",
+    "shouldGenerateOverlay"
+  ]);
+  var _a2;
+  const editor = useRemoteCursorEditor();
+  const cursorStates = useRemoteCursorStates();
+  const requestRerender = useRequestRerender();
+  const overlayPositionCache = (0, import_react4.useRef)(/* @__PURE__ */ new WeakMap());
+  const [overlayPositions, setOverlayPositions] = (0, import_react4.useState)({});
+  const refreshOnResize = "refreshOnResize" in opts ? (_a2 = opts.refreshOnResize) != null ? _a2 : true : true;
+  useOnResize(refreshOnResize ? containerRef : void 0, () => {
+    overlayPositionCache.current = /* @__PURE__ */ new WeakMap();
+    requestRerender(refreshOnResize !== "debounced");
+  });
+  (0, import_react4.useLayoutEffect)(() => {
+    var _a3, _b2, _c;
+    if (containerRef && !containerRef.current) {
+      return;
+    }
+    const containerRect = (_a3 = containerRef == null ? void 0 : containerRef.current) == null ? void 0 : _a3.getBoundingClientRect();
+    const xOffset = (_b2 = containerRect == null ? void 0 : containerRect.x) != null ? _b2 : 0;
+    const yOffset = (_c = containerRect == null ? void 0 : containerRect.y) != null ? _c : 0;
+    let overlayPositionsChanged = Object.keys(overlayPositions).length !== Object.keys(cursorStates).length;
+    const updated = Object.fromEntries(Object.entries(cursorStates).map(([key, state]) => {
+      const range = state.relativeSelection && getCursorRange(editor, state);
+      if (!range) {
+        return [key, FROZEN_EMPTY_ARRAY];
+      }
+      const cached = overlayPositionCache.current.get(range);
+      if (cached) {
+        return [key, cached];
+      }
+      const overlayPosition = getOverlayPosition(editor, range, {
+        xOffset,
+        yOffset,
+        shouldGenerateOverlay
+      });
+      overlayPositionsChanged = true;
+      overlayPositionCache.current.set(range, overlayPosition);
+      return [key, overlayPosition];
+    }));
+    if (overlayPositionsChanged) {
+      setOverlayPositions(updated);
+    }
+  });
+  const overlayData = (0, import_react4.useMemo)(() => Object.entries(cursorStates).map(([clientId, state]) => {
+    var _a3, _b2;
+    const range = state.relativeSelection && getCursorRange(editor, state);
+    const overlayPosition = overlayPositions[clientId];
+    return __spreadProps(__spreadValues({}, state), {
+      range,
+      caretPosition: (_a3 = overlayPosition == null ? void 0 : overlayPosition.caretPosition) != null ? _a3 : null,
+      selectionRects: (_b2 = overlayPosition == null ? void 0 : overlayPosition.selectionRects) != null ? _b2 : FROZEN_EMPTY_ARRAY
+    });
+  }), [cursorStates, editor, overlayPositions]);
+  const refresh = (0, import_react4.useCallback)(() => {
+    overlayPositionCache.current = /* @__PURE__ */ new WeakMap();
+    requestRerender(true);
+  }, [requestRerender]);
+  return [overlayData, refresh];
+}
+//# sourceMappingURL=index.cjs.map