@makeswift/runtime 0.7.12 → 0.7.14

package/dist/index.es2.js

@@ -37,7 +37,7 @@ import "slate";
 import "slate-react";
 import { cx } from "@emotion/css";
 import { jsx, Fragment, jsxs } from "react/jsx-runtime";
-import { l as isNonNullable, z as getBackgroundsFileIds, A as getBackgroundsSwatchIds } from "./constants.es.js";
+import { j as isNonNullable, m as getBackgroundsFileIds, n as getBackgroundsSwatchIds } from "./introspection.es.js";
 import NextImage from "next/image";
 import { u as useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.es.js";
 import ReactPlayer from "react-player";

package/dist/index.es5.js

@@ -10,6 +10,7 @@ import "./actions.es.js";
 import "./rich-text.es.js";
 import "slate";
 import "slate-react";
+import "./introspection.es.js";
 import "@emotion/css";
 import "@emotion/serialize";
 import "@emotion/utils";

package/dist/index.es5.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es5.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.es5.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.es6.js

@@ -30,27 +30,27 @@ var __objRest = (source, exclude) => {
   return target;
 };
 import { useCallback, useState, useEffect, forwardRef, useImperativeHandle, useMemo } from "react";
-import { Element as Element$1, Text, Editor, Transforms, Path, Range, Point, Node, createEditor } from "slate";
+import { Element as Element$1, Editor, Path, Range, Point, Node, Transforms, Text, createEditor } from "slate";
 import { withReact, ReactEditor, Slate, Editable } from "slate-react";
 import { cx } from "@emotion/css";
 import { g as getBox } from "./box-models.es.js";
-import { au as TextType, av as BlockType, aw as InlineType, ar as richTextDTOtoDAO, aq as richTextDTOtoSelection, ax as BuilderEditMode } from "./rich-text.es.js";
-import { T as TypographyLeaf } from "./typography.es.js";
+import { au as BlockType, av as InlineType, ar as richTextDTOtoDAO, aq as richTextDTOtoSelection, ax as BuilderEditMode } from "./rich-text.es.js";
+import { L as Leaf } from "./leaf.es.js";
+import { o as useStyle, r as responsiveStyle, N as deepEqual, V as useBuilderEditMode, W as pollBoxModel } from "./index.es.js";
 import { jsx } from "react/jsx-runtime";
+import { L as Link } from "./index.es3.js";
+import isHotkey from "is-hotkey";
 import "use-sync-external-store/shim";
-import { o as useStyle, r as responsiveStyle, V as useBuilderEditMode } from "./index.es.js";
 import "@emotion/serialize";
 import "@emotion/utils";
-import { L as Link } from "./index.es3.js";
-import { c as compareRichTextDAO, a as compareRichTextSelection } from "./compare.es.js";
-import isHotkey from "is-hotkey";
 import "css-box-model";
 import "./actions.es.js";
+import "./introspection.es.js";
+import "use-sync-external-store/shim/with-selector";
+import "next/dynamic";
 import "./constants.es.js";
 import "redux";
 import "redux-thunk";
-import "use-sync-external-store/shim/with-selector";
-import "next/dynamic";
 import "./text-input.es.js";
 import "./combobox.es.js";
 import "./types.es.js";
@@ -68,23 +68,6 @@ import "set-cookie-parser";
 import "uuid";
 import "corporate-ipsum";
 import "next/link";
-function Leaf(_a) {
-  var _b = _a, {
-    leaf
-  } = _b, props = __objRest(_b, [
-    "leaf"
-  ]);
-  switch (leaf.type) {
-    case TextType.Typography:
-      return /* @__PURE__ */ jsx(TypographyLeaf, __spreadValues({
-        leaf
-      }, props));
-    default:
-      return /* @__PURE__ */ jsx("span", __spreadProps(__spreadValues({}, props.attributes), {
-        children: props.children
-      }));
-  }
-}
 function BlockElement({
   element,
   attributes,
@@ -169,10 +152,10 @@ function BlockElement({
       }));
   }
 }
-function StyledLink(_c) {
-  var _d = _c, {
+function StyledLink(_a) {
+  var _b = _a, {
     className
-  } = _d, restOfProps = __objRest(_d, [
+  } = _b, restOfProps = __objRest(_b, [
     "className"
   ]);
   return /* @__PURE__ */ jsx(Link, __spreadProps(__spreadValues({}, restOfProps), {
@@ -206,10 +189,10 @@ function InlineElement({
       }));
   }
 }
-function Element(_e) {
-  var _f = _e, {
+function Element(_c) {
+  var _d = _c, {
     element
-  } = _f, props = __objRest(_f, [
+  } = _d, props = __objRest(_d, [
     "element"
   ]);
   switch (element.type) {
@@ -245,7 +228,7 @@ function useSyncWithBuilder(editor, text) {
     if (shouldCommit && text) {
       const nextValue = richTextDTOtoDAO(text);
       const nextSelection = richTextDTOtoSelection(text);
-      if (!compareRichTextDAO(editor.children, nextValue) || !compareRichTextSelection(editor.selection, nextSelection)) {
+      if (!deepEqual(editor.children, nextValue) || !deepEqual(editor.selection, nextSelection)) {
         editor.children = nextValue;
         editor.selection = nextSelection;
         editor.onChange();
@@ -264,15 +247,17 @@ function useSyncWithBuilder(editor, text) {
   }, [shouldCommit]);
   return useCallback(() => setShouldCommit(false), []);
 }
+const LIST_ITEM_CHILD_POSITION = 0;
+const LIST_ITEM_LIST_POSITION = 1;
 const ElementUtils = {
-  isConvertibleToListTextNode(node) {
-    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node) && !this.isText(node) && !this.isTypography(node);
+  isBlock(node) {
+    return Element$1.isElement(node) && (Element$1.isElementType(node, BlockType.Paragraph) || Element$1.isElementType(node, BlockType.Heading1) || Element$1.isElementType(node, BlockType.Heading2) || Element$1.isElementType(node, BlockType.Heading3) || Element$1.isElementType(node, BlockType.Heading3) || Element$1.isElementType(node, BlockType.Heading4) || Element$1.isElementType(node, BlockType.Heading5) || Element$1.isElementType(node, BlockType.Heading6) || Element$1.isElementType(node, BlockType.BlockQuote) || Element$1.isElementType(node, BlockType.UnorderedList) || Element$1.isElementType(node, BlockType.OrderedList) || Element$1.isElementType(node, BlockType.ListItem) || Element$1.isElementType(node, BlockType.ListItemChild));
   },
-  isText(node) {
-    return Element$1.isElementType(node, TextType.Text) || Text.isText(node);
+  isInline(node) {
+    return Element$1.isElement(node) && (Element$1.isElementType(node, InlineType.Link) || Element$1.isElementType(node, InlineType.Link) || Element$1.isElementType(node, InlineType.SubScript) || Element$1.isElementType(node, InlineType.SuperScript));
   },
-  isTypography(node) {
-    return Element$1.isElementType(node, TextType.Typography);
+  isConvertibleToListTextNode(node) {
+    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
   },
   isParagraph(node) {
     return Element$1.isElementType(node, BlockType.Paragraph);
@@ -287,7 +272,7 @@ const ElementUtils = {
     return Element$1.isElementType(node, BlockType.ListItemChild);
   },
   createText() {
-    return { text: "", type: TextType.Text };
+    return { text: "" };
   },
   createParagraph() {
     return {
@@ -311,36 +296,6 @@ const ElementUtils = {
     };
   }
 };
-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$1.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();
-  });
-}
-const LIST_ITEM_CHILD_POSITION = 0;
-const LIST_ITEM_LIST_POSITION = 1;
 const EditorUtils = {
   getFirstAncestorList(editor, path) {
     const parentList = Editor.above(editor, {
@@ -383,58 +338,6 @@ function getSelectedListItems(editor) {
   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 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 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 });
-  }
-}
 function indentPath(editor, path) {
   const parent = Node.parent(editor, path);
   if (!path || !Path.hasPrevious(path) || !ElementUtils.isList(parent))
@@ -508,6 +411,86 @@ function dedent(editor) {
     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$1.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,
@@ -574,6 +557,7 @@ function onKeyDown(e, editor) {
   }
 }
 function withList(editor) {
+  const { normalizeNode } = editor;
   editor.normalizeNode = (entry) => {
     const [normalizationNode, normalizationPath] = entry;
     if (ElementUtils.isListItem(normalizationNode)) {
@@ -593,18 +577,10 @@ function withList(editor) {
         return;
       }
     }
-    if (ElementUtils.isList(normalizationNode)) {
-      Array.from(Node.children(editor, normalizationPath)).forEach(([node, path]) => {
-        if (ElementUtils.isText(node)) {
-          Transforms.removeNodes(editor, { at: path });
-          return;
-        }
-      });
-    }
-    if (!ElementUtils.isText(normalizationNode) && !ElementUtils.isTypography(normalizationNode)) {
+    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]) || potentialNodeToBeMerged[0].type !== child[0].type) {
+        if (!potentialNodeToBeMerged || !ElementUtils.isList(potentialNodeToBeMerged[0]) || !ElementUtils.isList(child[0]) || potentialNodeToBeMerged[0].type !== child[0].type) {
           return null;
         }
         return [
@@ -635,13 +611,39 @@ function withList(editor) {
         return;
       }
     }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+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 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;
 }
 const defaultText = [{
   type: BlockType.Paragraph,
   children: [{
-    type: TextType.Text,
     text: ""
   }]
 }];
@@ -651,11 +653,20 @@ const EditableText = forwardRef(function EditableText2({
   width,
   margin
 }, ref) {
-  const [editor] = useState(() => withList(withReact(createEditor())));
+  const [editor] = useState(() => withBlock(withTypography(withList(withReact(createEditor())))));
   const delaySync = useSyncWithBuilder(editor, text);
   const editMode = useBuilderEditMode();
   const [propControllers, setPropControllers] = useState(null);
   const controller = propControllers == null ? void 0 : propControllers.text;
+  useEffect(() => {
+    if (controller == null)
+      return;
+    const element = ReactEditor.toDOMNode(editor, editor);
+    return pollBoxModel({
+      element,
+      onBoxModelChange: (boxModel) => controller.changeBoxModel(boxModel)
+    });
+  }, [editor, controller]);
   useImperativeHandle(ref, () => ({
     getDomNode() {
       return ReactEditor.toDOMNode(editor, editor);
@@ -692,7 +703,8 @@ const EditableText = forwardRef(function EditableText2({
       onKeyDown: handleKeyDown,
       onFocus: handleFocus,
       className: cx(width, margin),
-      readOnly: editMode === BuilderEditMode.INTERACT
+      readOnly: editMode === BuilderEditMode.INTERACT,
+      placeholder: "Write some text..."
     })
   });
 });