@makeswift/runtime 0.7.15 → 0.7.17

package/dist/index.es5.js

@@ -1,37 +1,560 @@
-export { default } from "./Text.es.js";
-import "next/dynamic";
-import "react";
-import "./index.es.js";
-import "use-sync-external-store/shim/with-selector";
-import "./constants.es.js";
-import "redux";
-import "redux-thunk";
-import "./actions.es.js";
-import "./rich-text.es.js";
-import "slate";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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));
+import { Element, Editor, Path, Range, Point, Node, Transforms, Text } from "slate";
+import isHotkey from "is-hotkey";
+import { au as BlockType, av as InlineType } from "./rich-text.es.js";
 import "slate-react";
-import "./introspection.es.js";
-import "@emotion/css";
-import "@emotion/serialize";
-import "@emotion/utils";
-import "react/jsx-runtime";
-import "./text-input.es.js";
-import "./combobox.es.js";
-import "use-sync-external-store/shim";
-import "./types.es.js";
-import "color";
-import "scroll-into-view-if-needed";
-import "./box-models.es.js";
-import "css-box-model";
-import "react-dom";
-import "html-react-parser";
-import "next/head";
-import "@emotion/server/create-instance";
-import "next/document";
-import "cookie";
-import "cors";
-import "http-proxy";
-import "set-cookie-parser";
-import "uuid";
-import "corporate-ipsum";
+import { i as isDeviceOverride } from "./leaf.es.js";
+import { G as findDeviceOverride } from "./index.es.js";
+const LIST_ITEM_CHILD_POSITION = 0;
+const LIST_ITEM_LIST_POSITION = 1;
+const ElementUtils = {
+  isBlock(node) {
+    return Element.isElement(node) && (Element.isElementType(node, BlockType.Paragraph) || Element.isElementType(node, BlockType.Heading1) || Element.isElementType(node, BlockType.Heading2) || Element.isElementType(node, BlockType.Heading3) || Element.isElementType(node, BlockType.Heading3) || Element.isElementType(node, BlockType.Heading4) || Element.isElementType(node, BlockType.Heading5) || Element.isElementType(node, BlockType.Heading6) || Element.isElementType(node, BlockType.BlockQuote) || Element.isElementType(node, BlockType.UnorderedList) || Element.isElementType(node, BlockType.OrderedList) || Element.isElementType(node, BlockType.ListItem) || Element.isElementType(node, BlockType.ListItemChild));
+  },
+  isInline(node) {
+    return Element.isElement(node) && (Element.isElementType(node, InlineType.Link) || Element.isElementType(node, InlineType.Link) || Element.isElementType(node, InlineType.SubScript) || Element.isElementType(node, InlineType.SuperScript));
+  },
+  isConvertibleToListTextNode(node) {
+    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
+  },
+  isParagraph(node) {
+    return Element.isElementType(node, BlockType.Paragraph);
+  },
+  isList(node) {
+    return Element.isElementType(node, BlockType.OrderedList) || Element.isElementType(node, BlockType.UnorderedList);
+  },
+  isListItem(node) {
+    return Element.isElementType(node, BlockType.ListItem);
+  },
+  isListItemChild(node) {
+    return Element.isElementType(node, BlockType.ListItemChild);
+  },
+  createText() {
+    return { text: "" };
+  },
+  createParagraph() {
+    return {
+      children: [this.createText()],
+      type: BlockType.Paragraph
+    };
+  },
+  createList(type = BlockType.UnorderedList) {
+    return { children: [this.createText()], type };
+  },
+  createListItem() {
+    return {
+      children: [this.createListItemChild()],
+      type: BlockType.ListItem
+    };
+  },
+  createListItemChild() {
+    return {
+      children: [this.createText()],
+      type: BlockType.ListItemChild
+    };
+  }
+};
+const EditorUtils = {
+  getFirstAncestorList(editor, path) {
+    const parentList = Editor.above(editor, {
+      at: path,
+      match: (node) => ElementUtils.isList(node)
+    });
+    return parentList != null ? parentList : null;
+  },
+  getFirstAncestorListItem(editor, path) {
+    const parentListItem = Editor.above(editor, {
+      at: path,
+      match: (node) => ElementUtils.isListItem(node)
+    });
+    return parentListItem != null ? parentListItem : null;
+  }
+};
+function filterForSubtreeRoots(entries) {
+  return entries.filter(([, nodePath]) => !Path.ancestors(nodePath).some((ancestor) => {
+    return entries.some(([, path]) => Path.equals(path, ancestor));
+  }));
+}
+const LocationUtils = {
+  getStartPath(location) {
+    if (Range.isRange(location))
+      return Range.start(location).path;
+    if (Point.isPoint(location))
+      return location.path;
+    return location;
+  }
+};
+function getSelectedListItems(editor) {
+  var _a, _b;
+  if (!editor.selection)
+    return [];
+  const start = LocationUtils.getStartPath(editor.selection);
+  const listItems = Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => ElementUtils.isListItem(node)
+  });
+  const firstAncestorPath = (_b = (_a = EditorUtils.getFirstAncestorListItem(editor, start)) == null ? void 0 : _a[1]) != null ? _b : [];
+  return Array.from(listItems).filter((node) => Path.isDescendant(start, node[1]) ? Path.equals(node[1], firstAncestorPath) : !Path.isAfter(start, node[1]));
+}
+function indentPath(editor, path) {
+  const parent = Node.parent(editor, path);
+  if (!path || !Path.hasPrevious(path) || !ElementUtils.isList(parent))
+    return;
+  const previosPath = Path.previous(path);
+  const previousChildListPath = [...previosPath, LIST_ITEM_LIST_POSITION];
+  const previousHasChildList = Node.has(editor, previousChildListPath);
+  Editor.withoutNormalizing(editor, () => {
+    if (!previousHasChildList) {
+      Transforms.insertNodes(editor, ElementUtils.createList(parent.type), {
+        at: previousChildListPath
+      });
+    }
+    const previousChildList = Node.get(editor, previousChildListPath);
+    if (ElementUtils.isList(previousChildList)) {
+      const index = previousHasChildList ? previousChildList.children.length : 0;
+      Transforms.moveNodes(editor, {
+        at: path,
+        to: [...previousChildListPath, index]
+      });
+    }
+  });
+}
+function indent(editor) {
+  if (!editor.selection)
+    return;
+  const listItems = getSelectedListItems(editor);
+  const subRoots = filterForSubtreeRoots(listItems);
+  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      indentPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function dedentPath(editor, listItemPath) {
+  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
+  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
+  if (!parentList || !listItemContainingParentList)
+    return;
+  const [parentListNode, parentListPath] = parentList;
+  const [_, listItemContainingParentListPath] = listItemContainingParentList;
+  const listItemPosition = listItemPath[listItemPath.length - 1];
+  const previousSiblings = parentListNode.children.slice(0, listItemPosition);
+  const nextSiblings = parentListNode.children.slice(listItemPosition + 1);
+  Editor.withoutNormalizing(editor, () => {
+    nextSiblings.forEach(() => {
+      const nextSiblingPath = [...parentListPath, listItemPosition + 1];
+      indentPath(editor, nextSiblingPath);
+    });
+    Transforms.moveNodes(editor, {
+      at: listItemPath,
+      to: Path.next(listItemContainingParentListPath)
+    });
+    if (previousSiblings.length === 0) {
+      Transforms.removeNodes(editor, { at: parentListPath });
+    }
+  });
+}
+function dedent(editor) {
+  if (!editor.selection)
+    return;
+  const listItems = getSelectedListItems(editor);
+  const subRoots = filterForSubtreeRoots(listItems);
+  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      dedentPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function unwrapPath(editor, listItemPath) {
+  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
+  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
+  if (!parentList || listItemContainingParentList)
+    return;
+  Editor.withoutNormalizing(editor, () => {
+    const listItemTextPath = [...listItemPath, LIST_ITEM_CHILD_POSITION];
+    const listItemNestedListPath = [...listItemPath, LIST_ITEM_LIST_POSITION];
+    if (Node.has(editor, listItemNestedListPath)) {
+      Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath });
+      Transforms.liftNodes(editor, { at: listItemNestedListPath });
+      Transforms.liftNodes(editor, { at: Path.next(listItemPath) });
+    }
+    if (Node.has(editor, listItemTextPath)) {
+      Transforms.setNodes(editor, { type: BlockType.Paragraph }, {
+        at: listItemTextPath
+      });
+      Transforms.liftNodes(editor, { at: listItemTextPath });
+      Transforms.liftNodes(editor, { at: listItemPath });
+    }
+  });
+}
+function unwrapList(editor) {
+  if (!editor.selection)
+    return;
+  const listItems = getSelectedListItems(editor);
+  const subRoots = filterForSubtreeRoots(listItems);
+  const refs = subRoots.map(([_, path]) => Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      unwrapPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function wrapList(editor, options = { type: BlockType.UnorderedList }) {
+  if (!editor.selection)
+    return;
+  const nonListEntries = Array.from(Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => {
+      return Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node);
+    }
+  }));
+  const refs = nonListEntries.map(([_, path]) => Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    const path = ref.current;
+    if (path) {
+      Editor.withoutNormalizing(editor, () => {
+        Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
+          at: path
+        });
+        Transforms.wrapNodes(editor, ElementUtils.createListItem(), {
+          at: path
+        });
+        Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {
+          at: path
+        });
+      });
+    }
+    ref.unref();
+  });
+}
+function toggleList(editor, options = { type: BlockType.UnorderedList }) {
+  if (!editor.selection)
+    return;
+  const start = LocationUtils.getStartPath(editor.selection);
+  const ancestorPath = Path.ancestors(start).at(1);
+  if (!ancestorPath || !Node.has(editor, ancestorPath))
+    return;
+  const ancestor = Node.get(editor, ancestorPath);
+  if (!ElementUtils.isList(ancestor)) {
+    return wrapList(editor, { type: options.type });
+  }
+  if (ancestor.type === options.type) {
+    unwrapList(editor);
+  } else {
+    Transforms.setNodes(editor, { type: options.type }, { at: ancestorPath });
+  }
+}
+const List = {
+  unwrapList,
+  wrapList,
+  indent,
+  dedent,
+  toggleList
+};
+function onKeyDown(e, editor) {
+  if (!editor.selection || Array.from(Editor.nodes(editor, { match: (node) => ElementUtils.isListItem(node) })).length === 0)
+    return;
+  if (isHotkey("shift+tab", e)) {
+    e.preventDefault();
+    List.dedent(editor);
+  }
+  if (isHotkey("tab", e)) {
+    e.preventDefault();
+    List.indent(editor);
+  }
+  if (isHotkey("backspace", e)) {
+    if (!editor.selection)
+      return;
+    if (Range.isExpanded(editor.selection))
+      return;
+    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
+    if (editor.selection.anchor.offset === 0 && listItem) {
+      e.preventDefault();
+      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
+      const list = EditorUtils.getFirstAncestorList(editor, listItem[1]);
+      if (parentListItem) {
+        List.dedent(editor);
+      } else if (list) {
+        List.unwrapList(editor);
+      }
+      return;
+    }
+  }
+  if (isHotkey("enter", e)) {
+    e.preventDefault();
+    if (!editor.selection)
+      return;
+    if (Range.isExpanded(editor.selection)) {
+      Transforms.delete(editor);
+      return;
+    }
+    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
+    if (editor.selection.anchor.offset === 0 && listItem && Editor.string(editor, listItem[1]) === "") {
+      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
+      if (parentListItem) {
+        List.dedent(editor);
+      } else {
+        List.unwrapList(editor);
+      }
+      return;
+    }
+    Transforms.splitNodes(editor, {
+      at: editor.selection,
+      always: true,
+      match: (node) => ElementUtils.isListItem(node)
+    });
+  }
+  if (isHotkey("shift+enter", e)) {
+    e.preventDefault();
+    editor.insertText("\n");
+  }
+}
+function withList(editor) {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    const [normalizationNode, normalizationPath] = entry;
+    if (ElementUtils.isListItem(normalizationNode)) {
+      const pathToListItemText = [...normalizationPath, LIST_ITEM_CHILD_POSITION];
+      if (Node.has(editor, pathToListItemText)) {
+        const nodeInListItemTextPosition = Node.get(editor, pathToListItemText);
+        if (ElementUtils.isParagraph(nodeInListItemTextPosition)) {
+          Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
+            at: pathToListItemText
+          });
+          return;
+        }
+      } else {
+        Transforms.insertNodes(editor, ElementUtils.createListItem(), {
+          at: pathToListItemText
+        });
+        return;
+      }
+    }
+    if (!Text.isText(normalizationNode)) {
+      const mergeableChildren = Array.from(Node.children(editor, normalizationPath)).map((child, index, children) => {
+        const potentialNodeToBeMerged = children.at(index + 1);
+        if (!potentialNodeToBeMerged || !ElementUtils.isList(potentialNodeToBeMerged[0]) || !ElementUtils.isList(child[0]) || potentialNodeToBeMerged[0].type !== child[0].type) {
+          return null;
+        }
+        return [
+          Editor.pathRef(editor, child[1]),
+          Editor.pathRef(editor, potentialNodeToBeMerged[1])
+        ];
+      }).filter((mergeableNodes) => Boolean(mergeableNodes));
+      if (mergeableChildren.length !== 0) {
+        mergeableChildren.reverse().forEach(([nodePathRef, nodeToBeMergedPathRef]) => {
+          const nodePath = nodePathRef.current;
+          const nodeToBeMergedPath = nodeToBeMergedPathRef.current;
+          if (nodePath == null || nodeToBeMergedPath == null)
+            return;
+          const nodeChildren = Array.from(Node.children(editor, nodePath));
+          const childrenToBeMerged = Array.from(Node.children(editor, nodeToBeMergedPath));
+          Editor.withoutNormalizing(editor, () => {
+            childrenToBeMerged.forEach(([_, childPath], index) => {
+              Transforms.moveNodes(editor, {
+                at: childPath,
+                to: [...nodePath, nodeChildren.length + index]
+              });
+            });
+            Transforms.removeNodes(editor, { at: nodeToBeMergedPath });
+          });
+          nodePathRef.unref();
+          nodeToBeMergedPathRef.unref();
+        });
+        return;
+      }
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+function clearActiveTypographyStyle(editor) {
+  if (!editor.selection)
+    return;
+  const textNodes = Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => Text.isText(node)
+  });
+  for (const [node, path] of textNodes) {
+    if (Text.isText(node)) {
+      const typography = __spreadProps(__spreadValues({}, node.typography), {
+        style: []
+      });
+      Transforms.setNodes(editor, {
+        typography
+      }, { at: path });
+    }
+  }
+}
+function clearDeviceActiveTypography(editor, currentDeviceId) {
+  var _a, _b;
+  if (!editor.selection)
+    return;
+  const textNodes = Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => Text.isText(node)
+  });
+  for (const [node, path] of textNodes) {
+    if (Text.isText(node)) {
+      const typography = __spreadProps(__spreadValues({}, node.typography), {
+        style: (_b = (_a = node == null ? void 0 : node.typography) == null ? void 0 : _a.style.filter(({ deviceId }) => deviceId !== currentDeviceId)) != null ? _b : []
+      });
+      Transforms.setNodes(editor, {
+        typography
+      }, { at: path });
+    }
+  }
+}
+function detachActiveTypography(editor, value) {
+  if (!editor.selection)
+    return;
+  const textNodes = Array.from(Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => Text.isText(node)
+  }));
+  textNodes.forEach(([node, path]) => {
+    if (Text.isText(node)) {
+      Transforms.setNodes(editor, {
+        typography: {
+          style: value
+        }
+      }, { at: path });
+    }
+  });
+}
+function setActiveTypographyId(editor, id) {
+  Transforms.setNodes(editor, {
+    typography: {
+      id,
+      style: []
+    }
+  }, {
+    match: (node) => Text.isText(node)
+  });
+}
+function setActiveTypographyStyle(editor, deviceId, prop, value) {
+  var _a, _b;
+  if (!editor.selection)
+    return;
+  const textNodes = Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => Text.isText(node)
+  });
+  for (const [node, path] of textNodes) {
+    if (Text.isText(node)) {
+      const deviceOverrides = (_b = (_a = node == null ? void 0 : node.typography) == null ? void 0 : _a.style.filter(isDeviceOverride)) != null ? _b : [];
+      const deviceStyle = findDeviceOverride(deviceOverrides, deviceId, (v) => v) || { value: {} };
+      const nextDeviceStyle = {
+        deviceId,
+        value: __spreadProps(__spreadValues({}, deviceStyle.value), { [prop]: value })
+      };
+      const nextTypography = __spreadProps(__spreadValues({}, node.typography), {
+        style: [...deviceOverrides.filter((v) => v.deviceId !== deviceId), nextDeviceStyle]
+      });
+      Transforms.setNodes(editor, {
+        typography: nextTypography
+      }, { at: path });
+    }
+  }
+}
+const Typography = {
+  setActiveTypographyId,
+  setActiveTypographyStyle,
+  clearActiveTypographyStyle,
+  clearDeviceActiveTypography,
+  detachActiveTypography
+};
+function withTypography(editor) {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    var _a, _b;
+    const [normalizationNode, normalizationPath] = entry;
+    if (Text.isText(normalizationNode) && ((_a = normalizationNode == null ? void 0 : normalizationNode.typography) == null ? void 0 : _a.id) == null && ((_b = normalizationNode == null ? void 0 : normalizationNode.typography) == null ? void 0 : _b.style.length) === 0) {
+      Transforms.unsetNodes(editor, "typography", { at: normalizationPath });
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+function setBlockKeyForDevice(editor, deviceId, key, value) {
+  var _a;
+  if (!editor.selection)
+    return;
+  const rootElements = Editor.nodes(editor, {
+    match: (_, path) => path.length === 1,
+    at: Editor.unhangRange(editor, editor.selection)
+  });
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceValues = (_a = node[key]) != null ? _a : [];
+      const currentDeviceValue = findDeviceOverride(deviceValues, deviceId, (v) => v);
+      const nextDeviceValue = __spreadProps(__spreadValues({}, currentDeviceValue), {
+        deviceId,
+        value
+      });
+      Transforms.setNodes(editor, {
+        [key]: [...deviceValues.filter((v) => v.deviceId !== deviceId), nextDeviceValue]
+      }, { at: path });
+    }
+  }
+}
+function clearBlockKeyForDevice(editor, deviceId, key) {
+  var _a;
+  if (!editor.selection)
+    return;
+  const rootElements = Editor.nodes(editor, {
+    match: (_, path) => path.length === 1,
+    at: Editor.unhangRange(editor, editor.selection)
+  });
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceOverrides = (_a = node[key]) != null ? _a : [];
+      Transforms.setNodes(editor, {
+        [key]: deviceOverrides.filter((v) => v.deviceId !== deviceId)
+      }, { at: path });
+    }
+  }
+}
+const Block = {
+  setBlockKeyForDevice,
+  clearBlockKeyForDevice
+};
+function withBlock(editor) {
+  const { normalizeNode } = editor;
+  editor.normalizeNode = (entry) => {
+    var _a;
+    const [normalizationNode, normalizationPath] = entry;
+    if (ElementUtils.isBlock(normalizationNode) && ((_a = normalizationNode == null ? void 0 : normalizationNode.textAlign) == null ? void 0 : _a.length) == 0) {
+      Transforms.unsetNodes(editor, "textAlign", { at: normalizationPath });
+      return;
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+export { Block as B, List as L, Typography as T, withTypography as a, withBlock as b, onKeyDown as o, withList as w };
 //# sourceMappingURL=index.es5.js.map