slate-vue3 0.13.7 → 0.13.8

package/dist/hyperscript.js

@@ -2,48 +2,88 @@ import { R as Range, N as Node, T as Text, a as Element, e as isObject } from ".
 import { h as createEditor$1 } from "./create-editor-D66_fXbO.js";
 import "vue";
 import { t as toRawWeakMap } from "./index-Ban80MbP.js";
-const ANCHOR = new toRawWeakMap();
-const FOCUS = new toRawWeakMap();
+const ANCHORS = new toRawWeakMap();
+const FOCI = new toRawWeakMap();
+const POINTS = new toRawWeakMap();
 class Token {
-}
-class AnchorToken extends Token {
   offset;
   path;
+  ref;
   constructor(props = {}) {
-    super();
-    const { offset, path } = props;
+    const { offset, path, ref } = props;
     this.offset = offset;
     this.path = path;
+    if (ref) {
+      if (path != null) {
+        throw new Error(
+          "The ref prop of a token cannot be used with the path prop."
+        );
+      }
+      this.ref = ref;
+    }
   }
 }
+class AnchorToken extends Token {
+}
 class FocusToken extends Token {
-  offset;
-  path;
-  constructor(props = {}) {
-    super();
-    const { offset, path } = props;
-    this.offset = offset;
-    this.path = path;
+}
+class PointToken extends Token {
+}
+function addAnchorToken(text, token) {
+  const offset = text.text.length;
+  let anchors = ANCHORS.get(text);
+  if (!anchors) {
+    anchors = /* @__PURE__ */ new Set();
+    ANCHORS.set(text, anchors);
   }
+  anchors.add([offset, token]);
+}
+function getAnchors(text) {
+  const anchors = ANCHORS.get(text);
+  if (!anchors) return [];
+  return Array.from(
+    anchors.values(),
+    ([offset, token]) => new AnchorToken({ ...token, offset })
+  );
 }
-const addAnchorToken = (text, token) => {
+function addFocusToken(text, token) {
   const offset = text.text.length;
-  ANCHOR.set(text, [offset, token]);
-};
-const getAnchorOffset = (text) => {
-  return ANCHOR.get(text);
-};
-const addFocusToken = (text, token) => {
+  let foci = FOCI.get(text);
+  if (!foci) {
+    foci = /* @__PURE__ */ new Set();
+    FOCI.set(text, foci);
+  }
+  foci.add([offset, token]);
+}
+function getFoci(text) {
+  const foci = FOCI.get(text);
+  if (!foci) return [];
+  return Array.from(
+    foci.values(),
+    ([offset, token]) => new FocusToken({ ...token, offset })
+  );
+}
+function addPointToken(text, token) {
   const offset = text.text.length;
-  FOCUS.set(text, [offset, token]);
-};
-const getFocusOffset = (text) => {
-  return FOCUS.get(text);
-};
+  let points = POINTS.get(text);
+  if (!points) {
+    points = /* @__PURE__ */ new Set();
+    POINTS.set(text, points);
+  }
+  points.add([offset, token]);
+}
+function getPoints(text) {
+  const points = POINTS.get(text);
+  if (!points) return [];
+  return Array.from(
+    points.values(),
+    ([offset, token]) => new PointToken({ ...token, offset })
+  );
+}
 const STRINGS = /* @__PURE__ */ new WeakSet();
-const resolveDescendants = (children) => {
+function resolveDescendants(children) {
   const nodes = [];
-  const addChild = (child) => {
+  function addChild(child) {
     if (child == null) {
       return;
     }
@@ -72,16 +112,18 @@ const resolveDescendants = (children) => {
         addAnchorToken(n, child);
       } else if (child instanceof FocusToken) {
         addFocusToken(n, child);
+      } else if (child instanceof PointToken) {
+        addPointToken(n, child);
       }
     } else {
       throw new Error(`Unexpected hyperscript child object: ${child}`);
     }
-  };
+  }
   for (const child of children.flat(Infinity)) {
     addChild(child);
   }
   return nodes;
-};
+}
 function createAnchor(tagName, attributes, children) {
   return new AnchorToken(attributes);
 }
@@ -97,6 +139,9 @@ function createFocus(tagName, attributes, children) {
 function createFragment(tagName, attributes, children) {
   return resolveDescendants(children);
 }
+function createPoint(tagName, attributes, children) {
+  return new PointToken(attributes);
+}
 function createSelection(tagName, attributes, children) {
   const anchor = children.find(
     (c) => c instanceof AnchorToken
@@ -161,15 +206,21 @@ const createEditor = (makeEditor) => (tagName, attributes, children) => {
   Object.assign(editor, attributes);
   editor.children = descendants;
   for (const [node, path] of Node.texts(editor)) {
-    const anchor = getAnchorOffset(node);
-    const focus = getFocusOffset(node);
-    if (anchor != null) {
-      const [offset] = anchor;
-      selection.anchor = { path, offset };
+    for (const { ref = selection, offset } of getAnchors(node)) {
+      if (offset != null) {
+        ref.anchor = { path, offset };
+      }
+    }
+    for (const { ref = selection, offset } of getFoci(node)) {
+      if (offset != null) {
+        ref.focus = { path, offset };
+      }
     }
-    if (focus != null) {
-      const [offset] = focus;
-      selection.focus = { path, offset };
+    for (const { ref, offset } of getPoints(node)) {
+      if (ref) {
+        ref.offset = offset;
+        ref.path = path;
+      }
     }
   }
   if (selection.anchor && !selection.focus) {
@@ -196,6 +247,7 @@ const DEFAULT_CREATORS = {
   element: createElement,
   focus: createFocus,
   fragment: createFragment,
+  point: createPoint,
   selection: createSelection,
   text: createText
 };
@@ -244,8 +296,41 @@ const normalizeElements = (elements) => {
   }
   return creators;
 };
+class HyperscriptPointRef {
+  path;
+  offset;
+  point() {
+    const { path, offset } = this;
+    if (path == null || offset == null) {
+      throw new Error(
+        "A HyperscriptPointRef must be passed as the ref prop of a <point /> tag that is used inside an <editor>."
+      );
+    }
+    return { path, offset };
+  }
+}
+class HyperscriptRangeRef {
+  anchor;
+  focus;
+  range() {
+    const { anchor, focus } = this;
+    if (anchor == null) {
+      throw new Error(
+        "A HyperscriptRangeRef must be passed as the ref prop of an <anchor /> tag that is used inside an <editor>."
+      );
+    }
+    if (focus == null) {
+      throw new Error(
+        "A HyperscriptRangeRef must be passed as the ref prop of a <focus /> tag that is used inside an <editor>."
+      );
+    }
+    return { anchor, focus };
+  }
+}
 const jsx = createHyperscript();
 export {
+  HyperscriptPointRef,
+  HyperscriptRangeRef,
   createEditor,
   createHyperscript,
   createText,

package/dist/slate-hyperscript/creators.d.ts

@@ -1,5 +1,5 @@
 import { Element, Descendant, Range, Text, Editor } from '../slate/index.ts';
-import { AnchorToken, FocusToken, Token } from './tokens';
+import { AnchorToken, FocusToken, PointToken, Token } from './tokens';
 /**
  * Create an anchor token.
  */
@@ -30,6 +30,12 @@ export declare function createFocus(tagName: string, attributes: {
 export declare function createFragment(tagName: string, attributes: {
     [key: string]: any;
 }, children: any[]): Descendant[];
+/**
+ * Create a point token.
+ */
+export declare function createPoint(tagName: string, attributes: {
+    [key: string]: any;
+}, children: any[]): PointToken;
 /**
  * Create a `Selection` object.
  */

package/dist/slate-hyperscript/hyperscript.d.ts

@@ -1,4 +1,4 @@
-import { createAnchor, createCursor, createElement, createFocus, createFragment, createSelection, createText } from './creators';
+import { createAnchor, createCursor, createElement, createFocus, createPoint, createFragment, createSelection, createText } from './creators';
 /**
  * `HyperscriptCreators` are dictionaries of `HyperscriptCreator` functions
  * keyed by tag name.
@@ -18,7 +18,7 @@ type HyperscriptShorthands = Record<string, Record<string, any>>;
 declare const createHyperscript: (options?: {
     creators?: HyperscriptCreators;
     elements?: HyperscriptShorthands;
-}) => <S extends "anchor" | "focus" | "text" | "selection" | "fragment" | "element" | "editor" | "cursor">(tagName: S, attributes?: object, ...children: any[]) => ReturnType<{
+}) => <S extends "anchor" | "focus" | "text" | "point" | "selection" | "fragment" | "element" | "editor" | "cursor">(tagName: S, attributes?: object, ...children: any[]) => ReturnType<{
     anchor: typeof createAnchor;
     cursor: typeof createCursor;
     editor: (tagName: string, attributes: {
@@ -27,6 +27,7 @@ declare const createHyperscript: (options?: {
     element: typeof createElement;
     focus: typeof createFocus;
     fragment: typeof createFragment;
+    point: typeof createPoint;
     selection: typeof createSelection;
     text: typeof createText;
 }[S]>;

package/dist/slate-hyperscript/index.d.ts

@@ -1,9 +1,10 @@
 import { createHyperscript, HyperscriptCreators, HyperscriptShorthands } from './hyperscript';
 import { createEditor, createText } from './creators';
+import { HyperscriptPointRef, HyperscriptRangeRef } from './refs';
 /**
  * The default hyperscript factory that ships with Slate, without custom tags.
  */
-declare const jsx: <S extends "anchor" | "focus" | "text" | "selection" | "fragment" | "element" | "editor" | "cursor">(tagName: S, attributes?: object, ...children: any[]) => ReturnType<{
+declare const jsx: <S extends "anchor" | "focus" | "text" | "point" | "selection" | "fragment" | "element" | "editor" | "cursor">(tagName: S, attributes?: object, ...children: any[]) => ReturnType<{
     anchor: typeof import('./creators').createAnchor;
     cursor: typeof import('./creators').createCursor;
     editor: (tagName: string, attributes: {
@@ -12,7 +13,8 @@ declare const jsx: <S extends "anchor" | "focus" | "text" | "selection" | "fragm
     element: typeof import('./creators').createElement;
     focus: typeof import('./creators').createFocus;
     fragment: typeof import('./creators').createFragment;
+    point: typeof import('./creators').createPoint;
     selection: typeof import('./creators').createSelection;
     text: typeof createText;
 }[S]>;
-export { jsx, createHyperscript, createEditor, createText, HyperscriptCreators, HyperscriptShorthands, };
+export { jsx, createHyperscript, createEditor, createText, HyperscriptCreators, HyperscriptPointRef, HyperscriptRangeRef, HyperscriptShorthands, };

package/dist/slate-hyperscript/refs.d.ts

@@ -0,0 +1,19 @@
+import { Path, Point, Range } from '../slate/index.ts';
+/**
+ * Hyperscript point refs can be used to construct arbitrary points using the
+ * ref prop of a <point /> tag.
+ */
+export declare class HyperscriptPointRef {
+    path?: Path;
+    offset?: number;
+    point(): Point;
+}
+/**
+ * Hyperscript range refs can be used to construct arbitrary range using the ref
+ * props of <anchor /> and <focus /> tags.
+ */
+export declare class HyperscriptRangeRef {
+    anchor?: Point;
+    focus?: Point;
+    range(): Range;
+}

package/dist/slate-hyperscript/tokens.d.ts

@@ -1,44 +1,54 @@
 import { Path, Text } from '../slate/index.ts';
+import { HyperscriptPointRef, HyperscriptRangeRef } from './refs';
 /**
  * All tokens inherit from a single constructor for `instanceof` checking.
  */
-export declare class Token {
-}
-/**
- * Anchor tokens represent the selection's anchor point.
- */
-export declare class AnchorToken extends Token {
+export declare class Token<Ref = unknown> {
     offset?: number;
     path?: Path;
+    ref?: Ref;
     constructor(props?: {
         offset?: number;
         path?: Path;
+        ref?: Ref;
     });
 }
+/**
+ * Anchor tokens represent the selection's anchor point.
+ */
+export declare class AnchorToken extends Token<HyperscriptRangeRef> {
+}
 /**
  * Focus tokens represent the selection's focus point.
  */
-export declare class FocusToken extends Token {
-    offset?: number;
-    path?: Path;
-    constructor(props?: {
-        offset?: number;
-        path?: Path;
-    });
+export declare class FocusToken extends Token<HyperscriptRangeRef> {
+}
+/**
+ * A weak map to hold point tokens.
+ */
+export declare class PointToken extends Token<HyperscriptPointRef> {
 }
 /**
  * Add an anchor token to the end of a text node.
  */
-export declare const addAnchorToken: (text: Text, token: AnchorToken) => void;
+export declare function addAnchorToken(text: Text, token: AnchorToken): void;
 /**
- * Get the offset if a text node has an associated anchor token.
+ * Get the associated anchor tokens for a text node.
  */
-export declare const getAnchorOffset: (text: Text) => [number, AnchorToken] | undefined;
+export declare function getAnchors(text: Text): AnchorToken[];
 /**
  * Add a focus token to the end of a text node.
  */
-export declare const addFocusToken: (text: Text, token: FocusToken) => void;
+export declare function addFocusToken(text: Text, token: FocusToken): void;
+/**
+ * Get the associated focus tokens for a text node.
+ */
+export declare function getFoci(text: Text): FocusToken[];
+/**
+ * Add a point token to the end of a text node.
+ */
+export declare function addPointToken(text: Text, token: PointToken): void;
 /**
- * Get the offset if a text node has an associated focus token.
+ * Get the associated point tokens for a text node.
  */
-export declare const getFocusOffset: (text: Text) => [number, FocusToken] | undefined;
+export declare function getPoints(text: Text): PointToken[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slate-vue3",
-  "version": "0.13.7",
+  "version": "0.13.8",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -82,7 +82,7 @@
     "@faker-js/faker": "^10.4.0",
     "@liveblocks/client": "^3.18.2",
     "@liveblocks/yjs": "^3.18.2",
-    "@playwright/test": "^1.59.1",
+    "@playwright/test": "^1.60.0",
     "@testing-library/vue": "^8.1.0",
     "@types/is-hotkey": "^0.1.10",
     "@types/is-url": "^1.2.32",