@makeswift/runtime 0.8.5 → 0.8.7

package/dist/index.cjs5.js

@@ -22,8 +22,7 @@ var slate = require("slate");
 var isHotkey = require("is-hotkey");
 var descriptors = require("./descriptors.cjs.js");
 require("slate-react");
-var leaf = require("./leaf.cjs.js");
-var responsiveStyle = require("./responsive-style.cjs.js");
+var state_breakpoints = require("./state/breakpoints.cjs.js");
 function _interopDefaultLegacy(e) {
   return e && typeof e === "object" && "default" in e ? e : { "default": e };
 }
@@ -31,11 +30,14 @@ var isHotkey__default = /* @__PURE__ */ _interopDefaultLegacy(isHotkey);
 const LIST_ITEM_CHILD_POSITION = 0;
 const LIST_ITEM_LIST_POSITION = 1;
 const ElementUtils = {
+  isRootBlock(node) {
+    return slate.Element.isElement(node) && (slate.Element.isElementType(node, descriptors.BlockType.Paragraph) || slate.Element.isElementType(node, descriptors.BlockType.Heading1) || slate.Element.isElementType(node, descriptors.BlockType.Heading2) || slate.Element.isElementType(node, descriptors.BlockType.Heading3) || slate.Element.isElementType(node, descriptors.BlockType.Heading3) || slate.Element.isElementType(node, descriptors.BlockType.Heading4) || slate.Element.isElementType(node, descriptors.BlockType.Heading5) || slate.Element.isElementType(node, descriptors.BlockType.Heading6) || slate.Element.isElementType(node, descriptors.BlockType.BlockQuote) || slate.Element.isElementType(node, descriptors.BlockType.UnorderedList) || slate.Element.isElementType(node, descriptors.BlockType.OrderedList));
+  },
   isBlock(node) {
-    return slate.Element.isElement(node) && (slate.Element.isElementType(node, descriptors.BlockType.Paragraph) || slate.Element.isElementType(node, descriptors.BlockType.Heading1) || slate.Element.isElementType(node, descriptors.BlockType.Heading2) || slate.Element.isElementType(node, descriptors.BlockType.Heading3) || slate.Element.isElementType(node, descriptors.BlockType.Heading3) || slate.Element.isElementType(node, descriptors.BlockType.Heading4) || slate.Element.isElementType(node, descriptors.BlockType.Heading5) || slate.Element.isElementType(node, descriptors.BlockType.Heading6) || slate.Element.isElementType(node, descriptors.BlockType.BlockQuote) || slate.Element.isElementType(node, descriptors.BlockType.UnorderedList) || slate.Element.isElementType(node, descriptors.BlockType.OrderedList) || slate.Element.isElementType(node, descriptors.BlockType.ListItem) || slate.Element.isElementType(node, descriptors.BlockType.ListItemChild));
+    return slate.Element.isElement(node) && (this.isRootBlock(node) || slate.Element.isElementType(node, descriptors.BlockType.ListItem) || slate.Element.isElementType(node, descriptors.BlockType.ListItemChild));
   },
   isInline(node) {
-    return slate.Element.isElement(node) && (slate.Element.isElementType(node, descriptors.InlineType.Link) || slate.Element.isElementType(node, descriptors.InlineType.Link) || slate.Element.isElementType(node, descriptors.InlineType.SubScript) || slate.Element.isElementType(node, descriptors.InlineType.SuperScript));
+    return slate.Element.isElementType(node, descriptors.InlineType.Code) || slate.Element.isElementType(node, descriptors.InlineType.Link) || slate.Element.isElementType(node, descriptors.InlineType.SubScript) || slate.Element.isElementType(node, descriptors.InlineType.SuperScript);
   },
   isConvertibleToListTextNode(node) {
     return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
@@ -66,7 +68,7 @@ const ElementUtils = {
   },
   createListItem() {
     return {
-      children: [this.createText()],
+      children: [this.createListItemChild()],
       type: descriptors.BlockType.ListItem
     };
   },
@@ -79,18 +81,26 @@ const ElementUtils = {
 };
 const EditorUtils = {
   getFirstAncestorList(editor, path) {
-    const parentList = slate.Editor.above(editor, {
-      at: path,
-      match: (node) => ElementUtils.isList(node)
-    });
-    return parentList != null ? parentList : null;
+    try {
+      const parentList = slate.Editor.above(editor, {
+        at: path,
+        match: (node) => ElementUtils.isList(node)
+      });
+      return parentList != null ? parentList : null;
+    } catch (e) {
+      return null;
+    }
   },
   getFirstAncestorListItem(editor, path) {
-    const parentListItem = slate.Editor.above(editor, {
-      at: path,
-      match: (node) => ElementUtils.isListItem(node)
-    });
-    return parentListItem != null ? parentListItem : null;
+    try {
+      const parentListItem = slate.Editor.above(editor, {
+        at: path,
+        match: (node) => ElementUtils.isListItem(node)
+      });
+      return parentListItem != null ? parentListItem : null;
+    } catch (e) {
+      return null;
+    }
   }
 };
 function filterForSubtreeRoots(entries) {
@@ -214,10 +224,17 @@ function unwrapPath(editor, listItemPath) {
     }
   });
 }
-function unwrapList(editor) {
-  if (!editor.selection)
+function unwrapList(editor, options) {
+  var _a;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+  if (!at)
     return;
-  const listItems = getSelectedListItems(editor);
+  const listItems = Array.from(slate.Editor.nodes(editor, {
+    at,
+    match: (node) => {
+      return slate.Element.isElement(node) && ElementUtils.isListItem(node);
+    }
+  }));
   const subRoots = filterForSubtreeRoots(listItems);
   const refs = subRoots.map(([_, path]) => slate.Editor.pathRef(editor, path));
   refs.forEach((ref) => {
@@ -228,10 +245,12 @@ function unwrapList(editor) {
   });
 }
 function wrapList(editor, options = { type: descriptors.BlockType.UnorderedList }) {
-  if (!editor.selection)
+  var _a;
+  const at = (_a = options.at) != null ? _a : editor.selection;
+  if (!at)
     return;
   const nonListEntries = Array.from(slate.Editor.nodes(editor, {
-    at: editor.selection,
+    at,
     match: (node) => {
       return slate.Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node);
     }
@@ -245,6 +264,7 @@ function wrapList(editor, options = { type: descriptors.BlockType.UnorderedList
           at: path
         });
         slate.Transforms.wrapNodes(editor, ElementUtils.createListItem(), {
+          match: (node) => ElementUtils.isListItemChild(node),
           at: path
         });
         slate.Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {
@@ -256,18 +276,20 @@ function wrapList(editor, options = { type: descriptors.BlockType.UnorderedList
   });
 }
 function toggleList(editor, options = { type: descriptors.BlockType.UnorderedList }) {
-  if (!editor.selection)
+  var _a;
+  const at = (_a = options.at) != null ? _a : editor.selection;
+  if (at == null)
     return;
-  const start = LocationUtils.getStartPath(editor.selection);
+  const start = LocationUtils.getStartPath(at);
   const ancestorPath = slate.Path.ancestors(start).at(1);
   if (!ancestorPath || !slate.Node.has(editor, ancestorPath))
     return;
   const ancestor = slate.Node.get(editor, ancestorPath);
   if (!ElementUtils.isList(ancestor)) {
-    return wrapList(editor, { type: options.type });
+    return wrapList(editor, { type: options.type, at });
   }
   if (ancestor.type === options.type) {
-    unwrapList(editor);
+    unwrapList(editor, { at });
   } else {
     slate.Transforms.setNodes(editor, { type: options.type }, { at: ancestorPath });
   }
@@ -378,10 +400,10 @@ function withList(editor) {
           const nodeChildren = Array.from(slate.Node.children(editor, nodePath));
           const childrenToBeMerged = Array.from(slate.Node.children(editor, nodeToBeMergedPath));
           slate.Editor.withoutNormalizing(editor, () => {
-            childrenToBeMerged.forEach(([_, childPath], index) => {
+            childrenToBeMerged.reverse().forEach(([_, childPath]) => {
               slate.Transforms.moveNodes(editor, {
                 at: childPath,
-                to: [...nodePath, nodeChildren.length + index]
+                to: [...nodePath, nodeChildren.length]
               });
             });
             slate.Transforms.removeNodes(editor, { at: nodeToBeMergedPath });
@@ -396,94 +418,168 @@ function withList(editor) {
   };
   return editor;
 }
-function clearActiveTypographyStyle(editor) {
-  if (!editor.selection)
-    return;
-  const textNodes = slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => slate.Text.isText(node)
-  });
-  for (const [node, path] of textNodes) {
-    if (slate.Text.isText(node)) {
-      const typography = __spreadProps(__spreadValues({}, node.typography), {
-        style: []
-      });
+function clearActiveTypographyStyle(editor, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a;
+    const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
       slate.Transforms.setNodes(editor, {
-        typography
-      }, { at: path });
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
     }
-  }
-}
-function clearDeviceActiveTypography(editor, currentDeviceId) {
-  var _a, _b;
-  if (!editor.selection)
-    return;
-  const textNodes = slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => slate.Text.isText(node)
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const typography = __spreadProps(__spreadValues({}, node.typography), {
+            style: []
+          });
+          slate.Transforms.setNodes(editor, {
+            typography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
   });
-  for (const [node, path] of textNodes) {
-    if (slate.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 : []
-      });
+}
+function clearDeviceActiveTypography(editor, currentDeviceId, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a, _b, _c;
+    const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
       slate.Transforms.setNodes(editor, {
-        typography
-      }, { at: path });
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
     }
-  }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const typography = __spreadProps(__spreadValues({}, node.typography), {
+            style: (_c = (_b = node == null ? void 0 : node.typography) == null ? void 0 : _b.style.filter(({ deviceId }) => deviceId !== currentDeviceId)) != null ? _c : []
+          });
+          slate.Transforms.setNodes(editor, {
+            typography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
 }
-function detachActiveTypography(editor, value) {
-  if (!editor.selection)
-    return;
-  const textNodes = Array.from(slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => slate.Text.isText(node)
-  }));
-  textNodes.forEach(([node, path]) => {
-    if (slate.Text.isText(node)) {
+function detachActiveTypography(editor, value, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a;
+    const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
       slate.Transforms.setNodes(editor, {
-        typography: {
-          style: value
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
+    }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          slate.Transforms.setNodes(editor, {
+            typography: {
+              style: value
+            }
+          }, { at: path });
         }
-      }, { at: path });
+      }
     }
+    atRef.unref();
   });
 }
-function setActiveTypographyId(editor, id) {
+function setActiveTypographyId(editor, id, options) {
+  var _a;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+  if (!at)
+    return;
   slate.Transforms.setNodes(editor, {
     typography: {
       id,
       style: []
     }
   }, {
-    match: (node) => slate.Text.isText(node)
+    at,
+    match: (node) => slate.Text.isText(node),
+    split: slate.Range.isExpanded(at)
   });
 }
-function setActiveTypographyStyle(editor, deviceId, prop, value) {
-  var _a, _b;
-  if (!editor.selection)
-    return;
-  const textNodes = slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => slate.Text.isText(node)
-  });
-  for (const [node, path] of textNodes) {
-    if (slate.Text.isText(node)) {
-      const deviceOverrides = (_b = (_a = node == null ? void 0 : node.typography) == null ? void 0 : _a.style.filter(leaf.isDeviceOverride)) != null ? _b : [];
-      const deviceStyle = responsiveStyle.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]
-      });
+function setActiveTypographyStyle(editor, breakpoints, deviceId, prop, value, options) {
+  slate.Editor.withoutNormalizing(editor, () => {
+    var _a, _b, _c;
+    const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+    if (!at)
+      return;
+    const atRef = slate.Editor.rangeRef(editor, at);
+    if (atRef.current) {
       slate.Transforms.setNodes(editor, {
-        typography: nextTypography
-      }, { at: path });
+        slice: true
+      }, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node),
+        split: slate.Range.isExpanded(atRef.current)
+      });
     }
-  }
+    if (atRef.current) {
+      const textNodes = Array.from(slate.Editor.nodes(editor, {
+        at: atRef.current,
+        match: (node) => slate.Text.isText(node) && node.slice === true
+      }));
+      for (const [node, path] of textNodes) {
+        if (slate.Text.isText(node)) {
+          const deviceOverrides = (_c = (_b = node == null ? void 0 : node.typography) == null ? void 0 : _b.style) != null ? _c : [];
+          const deviceStyle = state_breakpoints.findBreakpointOverride(breakpoints, 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]
+          });
+          slate.Transforms.setNodes(editor, {
+            typography: nextTypography
+          }, { at: path });
+        }
+      }
+    }
+    atRef.unref();
+  });
 }
 const Typography = {
   setActiveTypographyId,
@@ -501,22 +597,67 @@ function withTypography(editor) {
       slate.Transforms.unsetNodes(editor, "typography", { at: normalizationPath });
       return;
     }
+    if (slate.Text.isText(normalizationNode) && (normalizationNode == null ? void 0 : normalizationNode.slice) != null) {
+      slate.Transforms.unsetNodes(editor, "slice", { at: normalizationPath });
+      return;
+    }
     normalizeNode(entry);
   };
   return editor;
 }
-function setBlockKeyForDevice(editor, deviceId, key, value) {
-  var _a;
-  if (!editor.selection)
-    return;
-  const rootElements = slate.Editor.nodes(editor, {
-    match: (_, path) => path.length === 1,
-    at: slate.Editor.unhangRange(editor, editor.selection)
+function unhangRange(editor, range) {
+  let [start, end] = slate.Range.edges(range);
+  if (start.offset !== 0 || end.offset !== 0 || slate.Range.isCollapsed(range)) {
+    return range;
+  }
+  const endBlock = slate.Editor.above(editor, {
+    at: end,
+    match: (n) => slate.Element.isElement(n) && slate.Editor.isBlock(editor, n)
   });
+  const blockPath = endBlock ? endBlock[1] : [];
+  const first = slate.Editor.start(editor, start);
+  const before = { anchor: first, focus: end };
+  let skip = true;
+  for (const [node, path] of slate.Editor.nodes(editor, {
+    at: before,
+    match: slate.Text.isText,
+    reverse: true
+  })) {
+    if (skip) {
+      skip = false;
+      continue;
+    }
+    if (node.text !== "" || slate.Path.isBefore(path, blockPath)) {
+      end = { path, offset: node.text.length };
+      break;
+    }
+  }
+  return { anchor: start, focus: end };
+}
+function getSelection(editor) {
+  if (editor.selection)
+    return unhangRange(editor, editor.selection);
+  return {
+    anchor: slate.Editor.start(editor, []),
+    focus: slate.Editor.end(editor, [])
+  };
+}
+function getBlocksInSelection(editor) {
+  return Array.from(slate.Editor.nodes(editor, {
+    at: getSelection(editor),
+    match: (node) => ElementUtils.isRootBlock(node)
+  })).filter((entry) => ElementUtils.isRootBlock(entry[0]));
+}
+function setBlockKeyForDevice(editor, breakpoints, deviceId, key, value, options) {
+  var _a, _b;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+  if (!at)
+    return;
+  const rootElements = getBlocksInSelection(editor);
   for (const [node, path] of rootElements) {
     if (ElementUtils.isBlock(node)) {
-      const deviceValues = (_a = node[key]) != null ? _a : [];
-      const currentDeviceValue = responsiveStyle.findDeviceOverride(deviceValues, deviceId, (v) => v);
+      const deviceValues = (_b = node[key]) != null ? _b : [];
+      const currentDeviceValue = state_breakpoints.findBreakpointOverride(breakpoints, deviceValues, deviceId, (v) => v);
       const nextDeviceValue = __spreadProps(__spreadValues({}, currentDeviceValue), {
         deviceId,
         value
@@ -529,12 +670,7 @@ function setBlockKeyForDevice(editor, deviceId, key, value) {
 }
 function clearBlockKeyForDevice(editor, deviceId, key) {
   var _a;
-  if (!editor.selection)
-    return;
-  const rootElements = slate.Editor.nodes(editor, {
-    match: (_, path) => path.length === 1,
-    at: slate.Editor.unhangRange(editor, editor.selection)
-  });
+  const rootElements = getBlocksInSelection(editor);
   for (const [node, path] of rootElements) {
     if (ElementUtils.isBlock(node)) {
       const deviceOverrides = (_a = node[key]) != null ? _a : [];
@@ -544,12 +680,29 @@ function clearBlockKeyForDevice(editor, deviceId, key) {
     }
   }
 }
+function wrapInline(editor, inline) {
+  slate.Transforms.wrapNodes(editor, inline, {
+    at: getSelection(editor),
+    split: true
+  });
+}
+function unwrapInline(editor, type) {
+  slate.Transforms.unwrapNodes(editor, {
+    match: (node) => ElementUtils.isInline(node) && node.type === type,
+    at: getSelection(editor)
+  });
+}
 const Block = {
   setBlockKeyForDevice,
-  clearBlockKeyForDevice
+  clearBlockKeyForDevice,
+  wrapInline,
+  unwrapInline
 };
 function withBlock(editor) {
   const { normalizeNode } = editor;
+  editor.isInline = (entry) => {
+    return ElementUtils.isInline(entry);
+  };
   editor.normalizeNode = (entry) => {
     var _a;
     const [normalizationNode, normalizationPath] = entry;