@udecode/slate-react - npm Package Compare versions

Comparing version 24.0.0 to 24.3.0

dist/index.d.ts

@@ -0,8 +1,159 @@
+import React, { useLayoutEffect } from 'react';
+import { Value, TEditor, TNode, TDescendant } from '@udecode/slate';
+import { ReactEditor } from 'slate-react';
+import * as slate from 'slate';
+import { Path, Location, Point, Range } from 'slate';
+import * as slate_react_dist_utils_key from 'slate-react/dist/utils/key';
+import * as slate_react_dist_utils_dom from 'slate-react/dist/utils/dom';
+import { DOMNode, DOMPoint } from 'slate-react/dist/utils/dom';
+import { Value as Value$1 } from '@udecode/slate/dist';
+import { UnknownObject } from '@udecode/utils';
+
+declare const CAN_USE_DOM: boolean;
 /**
- * @file Automatically generated by barrelsby.
+ * Prevent warning on SSR by falling back to useEffect when DOM isn't available
  */
-export * from './hooks/index';
-export * from './react-editor/index';
-export * from './types/index';
-export * from './utils/index';
-//# sourceMappingURL=index.d.ts.map
+declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+
+type TReactEditor<V extends Value = Value> = TEditor<V> & Pick<ReactEditor, 'insertData' | 'insertFragmentData' | 'insertTextData' | 'setFragmentData' | 'hasRange' | 'hasTarget' | 'hasEditableTarget' | 'hasSelectableTarget' | 'isTargetInsideNonReadonlyVoid'>;
+
+/**
+ * Blur the editor.
+ */
+declare const blurEditor: <V extends Value>(editor: TReactEditor<V>) => void;
+
+/**
+ * Deselect the editor.
+ */
+declare const deselectEditor: <V extends Value>(editor: TReactEditor<V>) => void;
+
+/**
+ * Find the DOM node that implements DocumentOrShadowRoot for the editor.
+ */
+declare const findEditorDocumentOrShadowRoot: <V extends Value>(editor: TReactEditor<V>) => Document | ShadowRoot | undefined;
+
+/**
+ * {@link ReactEditor.findEventRange}
+ */
+declare const findEventRange: <V extends Value>(editor: TReactEditor<V>, event: any) => slate.BaseRange | undefined;
+
+/**
+ * Find a key for a Slate node.
+ */
+declare const findNodeKey: <V extends Value>(editor: TReactEditor<V>, node: TNode) => slate_react_dist_utils_key.Key | undefined;
+
+/**
+ * Find the path of Slate node.
+ */
+declare const findNodePath: <V extends Value>(editor: TReactEditor<V>, node: TNode) => Path | undefined;
+
+/**
+ * Focus the editor. Extension:
+ *
+ * If `target` is defined:
+ * - deselect the editor (otherwise it will focus the start of the editor)
+ * - select the editor
+ * - focus the editor
+ */
+declare const focusEditor: <V extends Value>(editor: TReactEditor<V>, target?: Location) => void;
+
+/**
+ * Return the host window of the current editor.
+ */
+declare const getEditorWindow: <V extends Value>(editor: TReactEditor<V>) => Window | undefined;
+
+/**
+ * Check if a DOM node is within the editor.
+ */
+declare const hasEditorDOMNode: <V extends Value>(editor: TReactEditor<V>, target: DOMNode, options?: Parameters<typeof ReactEditor.hasDOMNode>[2]) => boolean;
+
+/**
+ * Check if the target is editable and in the editor.
+ */
+declare const hasEditorEditableTarget: <V extends Value>(editor: TReactEditor<V>, target: EventTarget | null) => target is Node;
+
+/**
+ * Check if the target can be selectable.
+ */
+declare const hasEditorSelectableTarget: <V extends Value>(editor: TReactEditor<V>, target: EventTarget | null) => boolean;
+
+/**
+ * Check if the target is in the editor.
+ */
+declare const hasEditorTarget: <V extends Value>(editor: TReactEditor<V>, target: EventTarget | null) => target is Node;
+
+/**
+ * Insert data from a `DataTransfer` into the editor.
+ */
+declare const insertData: <V extends Value>(editor: TReactEditor<V>, data: DataTransfer) => void;
+
+/**
+ * Check if the user is currently composing inside the editor.
+ */
+declare const isComposing: <V extends Value>(editor: TReactEditor<V>) => boolean;
+
+/**
+ * Check if the editor is focused.
+ */
+declare const isEditorFocused: <V extends Value>(editor: TReactEditor<V>) => boolean;
+
+/**
+ * Check if the editor is in read-only mode.
+ */
+declare const isEditorReadOnly: <V extends Value>(editor: TReactEditor<V>) => boolean;
+
+/**
+ * Check if the target is inside void and in an non-readonly editor.
+ */
+declare const isTargetInsideNonReadonlyVoid: <V extends Value>(editor: TReactEditor<V>, target: EventTarget | null) => boolean;
+
+/**
+ * Sets data from the currently selected fragment on a `DataTransfer`.
+ */
+declare const setFragmentData: <V extends Value>(editor: TReactEditor<V>, data: DataTransfer) => void;
+
+/**
+ * Find the native DOM element from a Slate node.
+ */
+declare const toDOMNode: <V extends Value>(editor: TReactEditor<V>, node: TNode) => HTMLElement | undefined;
+
+/**
+ * Find a native DOM selection point from a Slate point.
+ */
+declare const toDOMPoint: <V extends Value>(editor: TReactEditor<V>, point: Point) => slate_react_dist_utils_dom.DOMPoint | undefined;
+
+/**
+ * {@link ReactEditor.toDOMRange}
+ */
+declare const toDOMRange: <V extends Value$1>(editor: TReactEditor<V>, range: Range) => globalThis.Range | undefined;
+
+/**
+ * {@link ReactEditor.toSlateNode}
+ */
+declare const toSlateNode: <V extends Value>(editor: TReactEditor<V>, domNode: DOMNode) => TNode | undefined;
+
+/**
+ * {@link ReactEditor.toSlatePoint}
+ */
+declare const toSlatePoint: <V extends Value>(editor: TReactEditor<V>, domPoint: DOMPoint, options: Parameters<typeof ReactEditor.toSlatePoint>[2]) => slate.BasePoint | null | undefined;
+
+/**
+ * {@link ReactEditor.toSlateRange}
+ */
+declare const toSlateRange: <V extends Value>(editor: TReactEditor<V>, domRange: Parameters<typeof ReactEditor.toSlateRange>[1], options: Parameters<typeof ReactEditor.toSlateRange>[2]) => slate.BaseRange | null | undefined;
+
+interface SlateProps extends UnknownObject {
+    editor: ReactEditor;
+    value: TDescendant[];
+    children: React.ReactNode;
+    onChange: (value: SlateProps['value']) => void;
+}
+
+/**
+ * Focus an editor edge.
+ */
+declare const focusEditorEdge: <V extends Value>(editor: TReactEditor<V>, { edge, }?: {
+    edge?: "end" | "start" | undefined;
+}) => void;
+
+export { CAN_USE_DOM, SlateProps, TReactEditor, blurEditor, deselectEditor, findEditorDocumentOrShadowRoot, findEventRange, findNodeKey, findNodePath, focusEditor, focusEditorEdge, getEditorWindow, hasEditorDOMNode, hasEditorEditableTarget, hasEditorSelectableTarget, hasEditorTarget, insertData, isComposing, isEditorFocused, isEditorReadOnly, isTargetInsideNonReadonlyVoid, setFragmentData, toDOMNode, toDOMPoint, toDOMRange, toSlateNode, toSlatePoint, toSlateRange, useIsomorphicLayoutEffect };

dist/index.js

@@ -1,253 +0,286 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
 
-var react = require('react');
-var slateReact = require('slate-react');
-var slate = require('@udecode/slate');
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CAN_USE_DOM: () => CAN_USE_DOM,
+  blurEditor: () => blurEditor,
+  deselectEditor: () => deselectEditor,
+  findEditorDocumentOrShadowRoot: () => findEditorDocumentOrShadowRoot,
+  findEventRange: () => findEventRange,
+  findNodeKey: () => findNodeKey,
+  findNodePath: () => findNodePath,
+  focusEditor: () => focusEditor,
+  focusEditorEdge: () => focusEditorEdge,
+  getEditorWindow: () => getEditorWindow,
+  hasEditorDOMNode: () => hasEditorDOMNode,
+  hasEditorEditableTarget: () => hasEditorEditableTarget,
+  hasEditorSelectableTarget: () => hasEditorSelectableTarget,
+  hasEditorTarget: () => hasEditorTarget,
+  insertData: () => insertData,
+  isComposing: () => isComposing,
+  isEditorFocused: () => isEditorFocused,
+  isEditorReadOnly: () => isEditorReadOnly,
+  isTargetInsideNonReadonlyVoid: () => isTargetInsideNonReadonlyVoid,
+  setFragmentData: () => setFragmentData,
+  toDOMNode: () => toDOMNode,
+  toDOMPoint: () => toDOMPoint,
+  toDOMRange: () => toDOMRange,
+  toSlateNode: () => toSlateNode,
+  toSlatePoint: () => toSlatePoint,
+  toSlateRange: () => toSlateRange,
+  useIsomorphicLayoutEffect: () => useIsomorphicLayoutEffect
+});
+module.exports = __toCommonJS(src_exports);
 
-const CAN_USE_DOM = typeof window !== 'undefined' && window.document !== undefined && window.document.createElement !== undefined;
+// src/hooks/useIsomorphicLayoutEffect.ts
+var import_react = require("react");
+var CAN_USE_DOM = typeof window !== "undefined" && window.document !== void 0 && window.document.createElement !== void 0;
+var useIsomorphicLayoutEffect = CAN_USE_DOM ? import_react.useLayoutEffect : import_react.useEffect;
 
-/**
- * Prevent warning on SSR by falling back to useEffect when DOM isn't available
- */
-const useIsomorphicLayoutEffect = CAN_USE_DOM ? react.useLayoutEffect : react.useEffect;
+// src/react-editor/blurEditor.ts
+var import_slate_react = require("slate-react");
+var blurEditor = (editor) => import_slate_react.ReactEditor.blur(editor);
 
-/**
- * Blur the editor.
- */
-const blurEditor = editor => slateReact.ReactEditor.blur(editor);
+// src/react-editor/deselectEditor.ts
+var import_slate_react2 = require("slate-react");
+var deselectEditor = (editor) => import_slate_react2.ReactEditor.deselect(editor);
 
-/**
- * Deselect the editor.
- */
-const deselectEditor = editor => slateReact.ReactEditor.deselect(editor);
-
-/**
- * Find the DOM node that implements DocumentOrShadowRoot for the editor.
- */
-const findEditorDocumentOrShadowRoot = editor => {
+// src/react-editor/findEditorDocumentOrShadowRoot.ts
+var import_slate_react3 = require("slate-react");
+var findEditorDocumentOrShadowRoot = (editor) => {
   try {
-    return slateReact.ReactEditor.findDocumentOrShadowRoot(editor);
-  } catch (error) {}
+    return import_slate_react3.ReactEditor.findDocumentOrShadowRoot(editor);
+  } catch (error) {
+  }
 };
 
-/**
- * {@link ReactEditor.findEventRange}
- */
-const findEventRange = (editor, event) => {
+// src/react-editor/findEventRange.ts
+var import_slate_react4 = require("slate-react");
+var findEventRange = (editor, event) => {
   try {
-    return slateReact.ReactEditor.findEventRange(editor, event);
-  } catch (error) {}
+    return import_slate_react4.ReactEditor.findEventRange(editor, event);
+  } catch (error) {
+  }
 };
 
-/**
- * Find a key for a Slate node.
- */
-const findNodeKey = (editor, node) => {
+// src/react-editor/findNodeKey.ts
+var import_slate_react5 = require("slate-react");
+var findNodeKey = (editor, node) => {
   try {
-    return slateReact.ReactEditor.findKey(editor, node);
-  } catch (error) {}
+    return import_slate_react5.ReactEditor.findKey(editor, node);
+  } catch (error) {
+  }
 };
 
-/**
- * Find the path of Slate node.
- */
-const findNodePath = (editor, node) => {
+// src/react-editor/findNodePath.ts
+var import_slate_react6 = require("slate-react");
+var findNodePath = (editor, node) => {
   try {
-    return slateReact.ReactEditor.findPath(editor, node);
-  } catch (error) {}
+    return import_slate_react6.ReactEditor.findPath(editor, node);
+  } catch (error) {
+  }
 };
 
-/**
- * Focus the editor. Extension:
- *
- * If `target` is defined:
- * - deselect the editor (otherwise it will focus the start of the editor)
- * - select the editor
- * - focus the editor
- */
-const focusEditor = (editor, target) => {
+// src/react-editor/focusEditor.ts
+var import_slate = require("@udecode/slate");
+var import_slate_react7 = require("slate-react");
+var focusEditor = (editor, target) => {
   if (target) {
-    slate.withoutNormalizing(editor, () => {
-      slate.deselect(editor);
-      slate.select(editor, target);
+    (0, import_slate.withoutNormalizing)(editor, () => {
+      (0, import_slate.deselect)(editor);
+      (0, import_slate.select)(editor, target);
     });
   }
-  slateReact.ReactEditor.focus(editor);
+  import_slate_react7.ReactEditor.focus(editor);
 };
 
-/**
- * Return the host window of the current editor.
- */
-const getEditorWindow = editor => {
+// src/react-editor/getEditorWindow.ts
+var import_slate_react8 = require("slate-react");
+var getEditorWindow = (editor) => {
   try {
-    return slateReact.ReactEditor.getWindow(editor);
-  } catch (error) {}
+    return import_slate_react8.ReactEditor.getWindow(editor);
+  } catch (error) {
+  }
 };
 
-/**
- * Check if a DOM node is within the editor.
- */
-const hasEditorDOMNode = (editor, target, options) => {
+// src/react-editor/hasEditorDOMNode.ts
+var import_slate_react9 = require("slate-react");
+var hasEditorDOMNode = (editor, target, options) => {
   try {
-    return slateReact.ReactEditor.hasDOMNode(editor, target, options);
-  } catch (error) {}
+    return import_slate_react9.ReactEditor.hasDOMNode(editor, target, options);
+  } catch (error) {
+  }
   return false;
 };
 
-/**
- * Check if the target is editable and in the editor.
- */
-const hasEditorEditableTarget = (editor, target) => {
+// src/react-editor/hasEditorEditableTarget.ts
+var import_slate_react10 = require("slate-react");
+var hasEditorEditableTarget = (editor, target) => {
   try {
-    return slateReact.ReactEditor.hasEditableTarget(editor, target);
-  } catch (error) {}
+    return import_slate_react10.ReactEditor.hasEditableTarget(editor, target);
+  } catch (error) {
+  }
   return false;
 };
 
-/**
- * Check if the target can be selectable.
- */
-const hasEditorSelectableTarget = (editor, target) => {
+// src/react-editor/hasEditorSelectableTarget.ts
+var import_slate_react11 = require("slate-react");
+var hasEditorSelectableTarget = (editor, target) => {
   try {
-    return slateReact.ReactEditor.hasSelectableTarget(editor, target);
-  } catch (error) {}
+    return import_slate_react11.ReactEditor.hasSelectableTarget(editor, target);
+  } catch (error) {
+  }
   return false;
 };
 
-/**
- * Check if the target is in the editor.
- */
-const hasEditorTarget = (editor, target) => {
+// src/react-editor/hasEditorTarget.ts
+var import_slate_react12 = require("slate-react");
+var hasEditorTarget = (editor, target) => {
   try {
-    return slateReact.ReactEditor.hasTarget(editor, target);
-  } catch (error) {}
+    return import_slate_react12.ReactEditor.hasTarget(editor, target);
+  } catch (error) {
+  }
   return false;
 };
 
-/**
- * Insert data from a `DataTransfer` into the editor.
- */
-const insertData = (editor, data) => slateReact.ReactEditor.insertData(editor, data);
+// src/react-editor/insertData.ts
+var import_slate_react13 = require("slate-react");
+var insertData = (editor, data) => import_slate_react13.ReactEditor.insertData(editor, data);
 
-/**
- * Check if the user is currently composing inside the editor.
- */
-const isComposing = editor => slateReact.ReactEditor.isComposing(editor);
+// src/react-editor/isComposing.ts
+var import_slate_react14 = require("slate-react");
+var isComposing = (editor) => import_slate_react14.ReactEditor.isComposing(editor);
 
-/**
- * Check if the editor is focused.
- */
-const isEditorFocused = editor => slateReact.ReactEditor.isFocused(editor);
+// src/react-editor/isEditorFocused.ts
+var import_slate_react15 = require("slate-react");
+var isEditorFocused = (editor) => import_slate_react15.ReactEditor.isFocused(editor);
 
-/**
- * Check if the editor is in read-only mode.
- */
-const isEditorReadOnly = editor => slateReact.ReactEditor.isReadOnly(editor);
+// src/react-editor/isEditorReadOnly.ts
+var import_slate_react16 = require("slate-react");
+var isEditorReadOnly = (editor) => import_slate_react16.ReactEditor.isReadOnly(editor);
 
-/**
- * Check if the target is inside void and in an non-readonly editor.
- */
-const isTargetInsideNonReadonlyVoid = (editor, target) => {
+// src/react-editor/isTargetInsideNonReadonlyVoidEditor.ts
+var import_slate_react17 = require("slate-react");
+var isTargetInsideNonReadonlyVoid = (editor, target) => {
   try {
-    return slateReact.ReactEditor.isTargetInsideNonReadonlyVoid(editor, target);
-  } catch (error) {}
+    return import_slate_react17.ReactEditor.isTargetInsideNonReadonlyVoid(editor, target);
+  } catch (error) {
+  }
   return false;
 };
 
-/**
- * Sets data from the currently selected fragment on a `DataTransfer`.
- */
-const setFragmentData = (editor, data) => slateReact.ReactEditor.setFragmentData(editor, data);
+// src/react-editor/setFragmentData.ts
+var import_slate_react18 = require("slate-react");
+var setFragmentData = (editor, data) => import_slate_react18.ReactEditor.setFragmentData(editor, data);
 
-/**
- * Find the native DOM element from a Slate node.
- */
-const toDOMNode = (editor, node) => {
+// src/react-editor/toDOMNode.ts
+var import_slate_react19 = require("slate-react");
+var toDOMNode = (editor, node) => {
   try {
-    return slateReact.ReactEditor.toDOMNode(editor, node);
-  } catch (error) {}
+    return import_slate_react19.ReactEditor.toDOMNode(editor, node);
+  } catch (error) {
+  }
 };
 
-/**
- * Find a native DOM selection point from a Slate point.
- */
-const toDOMPoint = (editor, point) => {
+// src/react-editor/toDOMPoint.ts
+var import_slate_react20 = require("slate-react");
+var toDOMPoint = (editor, point) => {
   try {
-    return slateReact.ReactEditor.toDOMPoint(editor, point);
-  } catch (error) {}
+    return import_slate_react20.ReactEditor.toDOMPoint(editor, point);
+  } catch (error) {
+  }
 };
 
-/**
- * {@link ReactEditor.toDOMRange}
- */
-const toDOMRange = (editor, range) => {
+// src/react-editor/toDOMRange.ts
+var import_slate_react21 = require("slate-react");
+var toDOMRange = (editor, range) => {
   try {
-    return slateReact.ReactEditor.toDOMRange(editor, range);
-  } catch (error) {}
+    return import_slate_react21.ReactEditor.toDOMRange(editor, range);
+  } catch (error) {
+  }
 };
 
-/**
- * {@link ReactEditor.toSlateNode}
- */
-const toSlateNode = (editor, domNode) => {
+// src/react-editor/toSlateNode.ts
+var import_slate_react22 = require("slate-react");
+var toSlateNode = (editor, domNode) => {
   try {
-    return slateReact.ReactEditor.toSlateNode(editor, domNode);
-  } catch (error) {}
+    return import_slate_react22.ReactEditor.toSlateNode(editor, domNode);
+  } catch (error) {
+  }
 };
 
-/**
- * {@link ReactEditor.toSlatePoint}
- */
-const toSlatePoint = (editor, domPoint, options) => {
+// src/react-editor/toSlatePoint.ts
+var import_slate_react23 = require("slate-react");
+var toSlatePoint = (editor, domPoint, options) => {
   try {
-    return slateReact.ReactEditor.toSlatePoint(editor, domPoint, options);
-  } catch (error) {}
+    return import_slate_react23.ReactEditor.toSlatePoint(editor, domPoint, options);
+  } catch (error) {
+  }
 };
 
-/**
- * {@link ReactEditor.toSlateRange}
- */
-const toSlateRange = (editor, domRange, options) => {
+// src/react-editor/toSlateRange.ts
+var import_slate_react24 = require("slate-react");
+var toSlateRange = (editor, domRange, options) => {
   try {
-    return slateReact.ReactEditor.toSlateRange(editor, domRange, options);
-  } catch (error) {}
+    return import_slate_react24.ReactEditor.toSlateRange(editor, domRange, options);
+  } catch (error) {
+  }
 };
 
-/**
- * Focus an editor edge.
- */
-const focusEditorEdge = (editor, {
-  edge = 'start'
+// src/utils/focusEditorEdge.ts
+var import_slate2 = require("@udecode/slate");
+var focusEditorEdge = (editor, {
+  edge = "start"
 } = {}) => {
-  const target = edge === 'start' ? slate.getStartPoint(editor, []) : slate.getEndPoint(editor, []);
+  const target = edge === "start" ? (0, import_slate2.getStartPoint)(editor, []) : (0, import_slate2.getEndPoint)(editor, []);
   focusEditor(editor, target);
 };
-
-exports.CAN_USE_DOM = CAN_USE_DOM;
-exports.blurEditor = blurEditor;
-exports.deselectEditor = deselectEditor;
-exports.findEditorDocumentOrShadowRoot = findEditorDocumentOrShadowRoot;
-exports.findEventRange = findEventRange;
-exports.findNodeKey = findNodeKey;
-exports.findNodePath = findNodePath;
-exports.focusEditor = focusEditor;
-exports.focusEditorEdge = focusEditorEdge;
-exports.getEditorWindow = getEditorWindow;
-exports.hasEditorDOMNode = hasEditorDOMNode;
-exports.hasEditorEditableTarget = hasEditorEditableTarget;
-exports.hasEditorSelectableTarget = hasEditorSelectableTarget;
-exports.hasEditorTarget = hasEditorTarget;
-exports.insertData = insertData;
-exports.isComposing = isComposing;
-exports.isEditorFocused = isEditorFocused;
-exports.isEditorReadOnly = isEditorReadOnly;
-exports.isTargetInsideNonReadonlyVoid = isTargetInsideNonReadonlyVoid;
-exports.setFragmentData = setFragmentData;
-exports.toDOMNode = toDOMNode;
-exports.toDOMPoint = toDOMPoint;
-exports.toDOMRange = toDOMRange;
-exports.toSlateNode = toSlateNode;
-exports.toSlatePoint = toSlatePoint;
-exports.toSlateRange = toSlateRange;
-exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CAN_USE_DOM,
+  blurEditor,
+  deselectEditor,
+  findEditorDocumentOrShadowRoot,
+  findEventRange,
+  findNodeKey,
+  findNodePath,
+  focusEditor,
+  focusEditorEdge,
+  getEditorWindow,
+  hasEditorDOMNode,
+  hasEditorEditableTarget,
+  hasEditorSelectableTarget,
+  hasEditorTarget,
+  insertData,
+  isComposing,
+  isEditorFocused,
+  isEditorReadOnly,
+  isTargetInsideNonReadonlyVoid,
+  setFragmentData,
+  toDOMNode,
+  toDOMPoint,
+  toDOMRange,
+  toSlateNode,
+  toSlatePoint,
+  toSlateRange,
+  useIsomorphicLayoutEffect
+});
+//# sourceMappingURL=index.js.map

package.json

 {
   "name": "@udecode/slate-react",
-  "version": "24.0.0",
+  "version": "24.3.0",
   "description": "Slate extension",
@@ -15,8 +15,17 @@ "license": "MIT",
   },
+  "sideEffects": false,
   "main": "dist/index.js",
-  "module": "dist/index.es.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist/**/*"
   ],
-  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "module": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
   "scripts": {
@@ -34,4 +43,4 @@ "build": "yarn p:build",
   "dependencies": {
-    "@udecode/slate": "23.7.4",
-    "@udecode/utils": "19.7.1"
+    "@udecode/slate": "24.3.0",
+    "@udecode/utils": "24.3.0"
   },
@@ -38,0 +47,0 @@ "peerDependencies": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

62349

decreased by-12.43%

Number of package files

9

decreased by-87.67%

Lines of code

596

decreased by-9.01%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Added@udecode/slate@24.3.0(transitive)

• + Added@udecode/utils@24.3.0(transitive)

• - Removed@udecode/slate@23.7.4(transitive)

• - Removed@udecode/utils@19.7.1(transitive)

• Updated@udecode/slate@24.3.0

• Updated@udecode/utils@24.3.0