@soul-refiner/design-system 2.0.0-alpha.18 → 2.0.0-alpha.19

package/dist/node_modules/@udecode/plate-media/dist/index.js

@@ -0,0 +1,211 @@
+'use strict';
+
+var React = require('react');
+var slateReact = require('slate-react');
+require('../../../js-video-url-parser/lib/base.js');
+require('../../../js-video-url-parser/lib/provider/allocine.js');
+require('../../../js-video-url-parser/lib/provider/canalplus.js');
+require('../../../js-video-url-parser/lib/provider/coub.js');
+require('../../../js-video-url-parser/lib/provider/dailymotion.js');
+require('../../../js-video-url-parser/lib/provider/loom.js');
+require('../../../js-video-url-parser/lib/provider/twitch.js');
+require('../../../js-video-url-parser/lib/provider/vimeo.js');
+require('../../../js-video-url-parser/lib/provider/wistia.js');
+require('../../../js-video-url-parser/lib/provider/youku.js');
+require('../../../js-video-url-parser/lib/provider/youtube.js');
+require('../../../js-video-url-parser/lib/provider/soundcloud.js');
+require('../../../js-video-url-parser/lib/provider/teachertube.js');
+require('../../../js-video-url-parser/lib/provider/tiktok.js');
+require('../../../js-video-url-parser/lib/provider/ted.js');
+require('../../../js-video-url-parser/lib/provider/facebook.js');
+var index = require('../../plate-core/dist/index.js');
+var index$1 = require('../../../zustand-x/dist/index.js');
+var reactHotkeysHook_esm = require('../../../react-hotkeys-hook/dist/react-hotkeys-hook.esm.js');
+var index$3 = require('../../slate/dist/index.js');
+var index$4 = require('../../utils/dist/index.js');
+var reactUtils = require('@udecode/react-utils');
+var index$2 = require('../../slate-react/dist/index.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+// src/image/createImagePlugin.ts
+var ELEMENT_IMAGE = "img";
+var useImage = () => {
+  const { url } = index.useElement();
+  return {
+    props: {
+      src: url,
+      draggable: true
+    }
+  };
+};
+var Image = reactUtils.createPrimitiveComponent("img")({
+  propsHook: useImage
+});
+
+// src/media/types.ts
+var ELEMENT_MEDIA = "media";
+var VIDEO_PROVIDERS = [
+  "youtube",
+  "vimeo",
+  "dailymotion",
+  "youku",
+  "coub"
+];
+
+// src/media/useMediaState.ts
+var useMediaState = ({
+  urlParsers
+} = {}) => {
+  const element = index.useElement();
+  const focused = slateReact.useFocused();
+  const selected = slateReact.useSelected();
+  const readOnly = slateReact.useReadOnly();
+  const { url, align } = element;
+  const embed = React__default.default.useMemo(() => {
+    if (!urlParsers)
+      return;
+    for (const parser of urlParsers) {
+      const data = parser(url);
+      if (data) {
+        return data;
+      }
+    }
+  }, [urlParsers, url]);
+  const isTweet = (embed == null ? void 0 : embed.provider) === "twitter";
+  const isVideo = !!(embed == null ? void 0 : embed.provider) && VIDEO_PROVIDERS.includes(embed.provider);
+  const isYoutube = (embed == null ? void 0 : embed.provider) === "youtube";
+  return {
+    align,
+    focused,
+    selected,
+    readOnly,
+    embed,
+    isTweet,
+    isVideo,
+    isYoutube
+  };
+};
+var floatingMediaStore = index$1.createZustandStore("floatingMedia")({
+  url: "",
+  isEditing: false
+}).extendActions((set) => ({
+  reset: () => {
+    set.url("");
+    set.isEditing(false);
+  }
+}));
+var floatingMediaActions = floatingMediaStore.set;
+var floatingMediaSelectors = floatingMediaStore.get;
+var useFloatingMediaSelectors = () => floatingMediaStore.use;
+
+// src/media/FloatingMedia/FloatingMediaEditButton.tsx
+var useFloatingMediaEditButton = () => {
+  const element = index.useElement();
+  return {
+    props: {
+      onClick: React__default.default.useCallback(() => {
+        floatingMediaActions.url(element.url);
+        floatingMediaActions.isEditing(true);
+      }, [element.url])
+    }
+  };
+};
+reactUtils.createPrimitiveComponent("button")({
+  propsHook: useFloatingMediaEditButton
+});
+var submitFloatingMedia = (editor, {
+  element,
+  pluginKey = ELEMENT_MEDIA
+}) => {
+  let url = floatingMediaSelectors.url();
+  if (url === element.url) {
+    floatingMediaActions.reset();
+    return true;
+  }
+  const { isUrl: _isUrl = index$4.isUrl, transformUrl } = index.getPluginOptions(editor, pluginKey);
+  const isValid = _isUrl(url);
+  if (!isValid)
+    return;
+  if (transformUrl) {
+    url = transformUrl(url);
+  }
+  index$3.setNodes(editor, {
+    url
+  });
+  floatingMediaActions.reset();
+  index$2.focusEditor(editor, editor.selection);
+  return true;
+};
+
+// src/media/FloatingMedia/FloatingMediaUrlInput.tsx
+var useFloatingMediaUrlInputState = ({
+  pluginKey
+} = {}) => {
+  const editor = index.useEditorRef();
+  const element = index.useElement();
+  reactHotkeysHook_esm.useHotkeys(
+    "enter",
+    (e) => {
+      if (submitFloatingMedia(editor, { element, pluginKey })) {
+        e.preventDefault();
+      }
+    },
+    {
+      enableOnFormTags: ["INPUT"]
+    },
+    []
+  );
+  reactHotkeysHook_esm.useHotkeys(
+    "escape",
+    () => {
+      if (floatingMediaSelectors.isEditing()) {
+        floatingMediaActions.reset();
+        index$2.focusEditor(editor, editor.selection);
+      }
+    },
+    {
+      enableOnFormTags: ["INPUT"],
+      enableOnContentEditable: true
+    },
+    []
+  );
+  return {
+    defaultValue: floatingMediaSelectors.url()
+  };
+};
+var useFloatingMediaUrlInput = ({
+  defaultValue
+}) => {
+  const onChange = React__default.default.useCallback((e) => {
+    floatingMediaActions.url(e.target.value);
+  }, []);
+  return {
+    props: {
+      onChange,
+      autoFocus: true,
+      defaultValue
+    }
+  };
+};
+reactUtils.createPrimitiveComponent("input")({
+  stateHook: useFloatingMediaUrlInputState,
+  propsHook: useFloatingMediaUrlInput
+});
+
+exports.ELEMENT_IMAGE = ELEMENT_IMAGE;
+exports.ELEMENT_MEDIA = ELEMENT_MEDIA;
+exports.Image = Image;
+exports.VIDEO_PROVIDERS = VIDEO_PROVIDERS;
+exports.floatingMediaActions = floatingMediaActions;
+exports.floatingMediaSelectors = floatingMediaSelectors;
+exports.floatingMediaStore = floatingMediaStore;
+exports.submitFloatingMedia = submitFloatingMedia;
+exports.useFloatingMediaEditButton = useFloatingMediaEditButton;
+exports.useFloatingMediaSelectors = useFloatingMediaSelectors;
+exports.useFloatingMediaUrlInput = useFloatingMediaUrlInput;
+exports.useFloatingMediaUrlInputState = useFloatingMediaUrlInputState;
+exports.useImage = useImage;
+exports.useMediaState = useMediaState;

package/dist/node_modules/@udecode/plate-normalizers/dist/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var castArray = require('../../../lodash/castArray.js');
+var index = require('../../slate/dist/index.js');
+
+// src/createNormalizeTypesPlugin.ts
+var withRemoveEmptyNodes = (editor, { options: { types: _types } }) => {
+  const types = castArray.default(_types);
+  const { normalizeNode } = editor;
+  editor.normalizeNode = ([node, path]) => {
+    if (index.isElement(node) && node.type && types.includes(node.type) && index.getNodeString(node) === "") {
+      index.removeNodes(editor, { at: path });
+      return;
+    }
+    normalizeNode([node, path]);
+  };
+  return editor;
+};
+
+exports.withRemoveEmptyNodes = withRemoveEmptyNodes;

package/dist/node_modules/@udecode/plate-resizable/dist/index.js

@@ -0,0 +1,334 @@
+'use strict';
+
+var React = require('react');
+var index = require('../../../jotai-x/dist/index.js');
+var index$1 = require('../../plate-core/dist/index.js');
+var index$2 = require('../../slate-react/dist/index.js');
+var index$3 = require('../../slate/dist/index.js');
+var reactUtils = require('@udecode/react-utils');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+var __defProp = Object.defineProperty;
+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 __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;
+};
+
+// src/utils/isTouchEvent.ts
+var isTouchEvent = (event) => "touches" in event;
+
+// src/utils/resizeLengthToRelative.ts
+var resizeLengthToRelative = (length, parentLength) => {
+  if (typeof length === "number") {
+    return `${length / parentLength * 100}%`;
+  }
+  return length;
+};
+
+// src/utils/resizeLengthToStatic.ts
+var resizeLengthToStatic = (length, parentLength) => {
+  if (typeof length === "string") {
+    return parentLength * Number.parseFloat(length) / 100;
+  }
+  return length;
+};
+
+// src/utils/resizeLengthClamp.ts
+var resizeLengthClampStatic = (length, { min, max }) => {
+  if (min !== void 0) {
+    length = Math.max(length, min);
+  }
+  if (max !== void 0) {
+    length = Math.min(length, max);
+  }
+  return length;
+};
+var resizeLengthClamp = (length, parentLength, { min, max }) => {
+  const staticLength = resizeLengthToStatic(length, parentLength);
+  const clampedStaticLength = resizeLengthClampStatic(staticLength, {
+    min: min === void 0 ? void 0 : resizeLengthToStatic(min, parentLength),
+    max: max === void 0 ? void 0 : resizeLengthToStatic(max, parentLength)
+  });
+  switch (typeof length) {
+    case "string": {
+      return resizeLengthToRelative(clampedStaticLength, parentLength);
+    }
+    case "number": {
+      return clampedStaticLength;
+    }
+    default: {
+      throw new Error("Invalid length type");
+    }
+  }
+};
+var initialState = {
+  onResize: null
+};
+var { ResizeHandleProvider, useResizeHandleStore } = index.createAtomStore(
+  initialState,
+  { name: "resizeHandle" }
+);
+var useResizeHandleState = ({
+  direction = "left",
+  initialSize: _initialSize,
+  onResize: onResizeProp,
+  onMouseDown,
+  onTouchStart,
+  onHover,
+  onHoverEnd
+}) => {
+  const onResizeStore = useResizeHandleStore().get.onResize();
+  const onResize = onResizeProp != null ? onResizeProp : onResizeStore;
+  const [isResizing, setIsResizing] = React__default.default.useState(false);
+  const [initialPosition, setInitialPosition] = React__default.default.useState(0);
+  const [initialSizeState, setInitialSize] = React__default.default.useState(0);
+  const initialSize = _initialSize != null ? _initialSize : initialSizeState;
+  const isHorizontal = direction === "left" || direction === "right";
+  React__default.default.useEffect(() => {
+    if (!isResizing)
+      return;
+    const sendResizeEvent = (event, finished) => {
+      const { clientX, clientY } = isTouchEvent(event) ? event.touches[0] || event.changedTouches[0] : event;
+      const currentPosition = isHorizontal ? clientX : clientY;
+      const delta = currentPosition - initialPosition;
+      onResize({
+        initialSize,
+        delta,
+        finished,
+        direction
+      });
+    };
+    const handleMouseMove = (event) => sendResizeEvent(event, false);
+    const handleMouseUp = (event) => {
+      setIsResizing(false);
+      onHoverEnd == null ? void 0 : onHoverEnd();
+      sendResizeEvent(event, true);
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    window.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener("touchmove", handleMouseMove);
+    window.addEventListener("touchend", handleMouseUp);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+      window.removeEventListener("touchmove", handleMouseMove);
+      window.removeEventListener("touchend", handleMouseUp);
+    };
+  }, [
+    isResizing,
+    initialPosition,
+    initialSize,
+    onResize,
+    isHorizontal,
+    onHoverEnd,
+    direction
+  ]);
+  return {
+    isResizing,
+    setIsResizing,
+    initialPosition,
+    setInitialPosition,
+    initialSize,
+    setInitialSize,
+    isHorizontal,
+    direction,
+    onResize,
+    onMouseDown,
+    onTouchStart,
+    onHover,
+    onHoverEnd
+  };
+};
+var useResizeHandle = ({
+  setInitialPosition,
+  setInitialSize,
+  setIsResizing,
+  onMouseDown,
+  onTouchStart,
+  isHorizontal,
+  isResizing,
+  onHover,
+  onHoverEnd
+}) => {
+  const handleMouseDown = (event) => {
+    const { clientX, clientY } = event;
+    setInitialPosition(isHorizontal ? clientX : clientY);
+    const element = event.target.parentElement;
+    setInitialSize(isHorizontal ? element.offsetWidth : element.offsetHeight);
+    setIsResizing(true);
+    onMouseDown == null ? void 0 : onMouseDown(event);
+  };
+  const handleTouchStart = (event) => {
+    const { touches } = event;
+    const touch = touches[0];
+    const { clientX, clientY } = touch;
+    setInitialPosition(isHorizontal ? clientX : clientY);
+    const element = event.target.parentElement;
+    setInitialSize(isHorizontal ? element.offsetWidth : element.offsetHeight);
+    setIsResizing(true);
+    onTouchStart == null ? void 0 : onTouchStart(event);
+  };
+  const handleMouseOver = () => {
+    onHover == null ? void 0 : onHover();
+  };
+  const handleMouseOut = () => {
+    if (!isResizing) {
+      onHoverEnd == null ? void 0 : onHoverEnd();
+    }
+  };
+  return {
+    props: {
+      onMouseDown: handleMouseDown,
+      onTouchStart: handleTouchStart,
+      onMouseOver: handleMouseOver,
+      onMouseOut: handleMouseOut,
+      onTouchMove: handleMouseOver,
+      onTouchEnd: handleMouseOut
+    }
+  };
+};
+var ResizeHandle = reactUtils.createPrimitiveComponent("div")({
+  propsHook: useResizeHandle,
+  stateHook: useResizeHandleState
+});
+var { resizableStore, useResizableStore, ResizableProvider } = index.createAtomStore(
+  {
+    width: 0
+  },
+  { name: "resizable" }
+);
+
+// src/components/Resizable.tsx
+var useResizableState = ({
+  align = "center",
+  minWidth = 92,
+  maxWidth = "100%"
+} = {}) => {
+  var _a;
+  const element = index$1.useElement();
+  const editor = index$1.useEditorRef();
+  const nodeWidth = (_a = element == null ? void 0 : element.width) != null ? _a : "100%";
+  const [width, setWidth] = useResizableStore().use.width();
+  const setNodeWidth = React__default.default.useCallback(
+    (w) => {
+      const path = index$2.findNodePath(editor, element);
+      if (!path)
+        return;
+      if (w === nodeWidth) {
+        index$3.select(editor, path);
+      } else {
+        index$3.setNodes(editor, { width: w }, { at: path });
+      }
+    },
+    [editor, element, nodeWidth]
+  );
+  React__default.default.useEffect(() => {
+    setWidth(nodeWidth);
+  }, [nodeWidth, setWidth]);
+  return {
+    align,
+    minWidth,
+    maxWidth,
+    setNodeWidth,
+    setWidth,
+    width
+  };
+};
+var useResizable = ({
+  align,
+  minWidth,
+  maxWidth,
+  setNodeWidth,
+  setWidth,
+  width
+}) => {
+  const wrapperRef = React__default.default.useRef(null);
+  return {
+    wrapperRef,
+    wrapperProps: {
+      style: {
+        position: "relative"
+      }
+    },
+    props: {
+      style: {
+        width,
+        minWidth,
+        maxWidth,
+        position: "relative"
+      }
+    },
+    context: {
+      onResize: React__default.default.useCallback(
+        ({ initialSize, delta, finished, direction }) => {
+          const wrapperStaticWidth = wrapperRef.current.offsetWidth;
+          const deltaFactor = (align === "center" ? 2 : 1) * (direction === "left" ? -1 : 1);
+          const newWidth = resizeLengthClamp(
+            initialSize + delta * deltaFactor,
+            wrapperStaticWidth,
+            {
+              min: minWidth,
+              max: maxWidth
+            }
+          );
+          if (finished) {
+            setNodeWidth(newWidth);
+          } else {
+            setWidth(newWidth);
+          }
+        },
+        [align, maxWidth, minWidth, setNodeWidth, setWidth]
+      )
+    }
+  };
+};
+var Resizable = React__default.default.forwardRef((_a, ref) => {
+  var _b = _a, { children, options } = _b, rest = __objRest(_b, ["children", "options"]);
+  const state = useResizableState(options);
+  const { wrapperRef, wrapperProps, props, context } = useResizable(state);
+  return /* @__PURE__ */ React__default.default.createElement("div", __spreadValues({ ref: wrapperRef }, wrapperProps), /* @__PURE__ */ React__default.default.createElement("div", __spreadValues(__spreadValues({ ref }, props), rest), /* @__PURE__ */ React__default.default.createElement(ResizeHandleProvider, { onResize: context.onResize }, children)));
+});
+Resizable.displayName = "Resizable";
+
+exports.Resizable = Resizable;
+exports.ResizableProvider = ResizableProvider;
+exports.ResizeHandle = ResizeHandle;
+exports.ResizeHandleProvider = ResizeHandleProvider;
+exports.isTouchEvent = isTouchEvent;
+exports.resizableStore = resizableStore;
+exports.resizeLengthClamp = resizeLengthClamp;
+exports.resizeLengthClampStatic = resizeLengthClampStatic;
+exports.resizeLengthToRelative = resizeLengthToRelative;
+exports.resizeLengthToStatic = resizeLengthToStatic;
+exports.useResizable = useResizable;
+exports.useResizableState = useResizableState;
+exports.useResizableStore = useResizableStore;
+exports.useResizeHandle = useResizeHandle;
+exports.useResizeHandleState = useResizeHandleState;
+exports.useResizeHandleStore = useResizeHandleStore;