@makeswift/runtime 0.8.11 → 0.9.0

package/dist/react-page.cjs.js

@@ -26,13 +26,59 @@ var redux = require("redux");
 var thunk = require("redux-thunk");
 var actions = require("./actions.cjs.js");
 var state_breakpoints = require("./state/breakpoints.cjs.js");
-require("slate");
-require("is-hotkey");
+var slate = require("slate");
+var isHotkey = require("is-hotkey");
 require("slate-react");
 function _interopDefaultLegacy(e) {
   return e && typeof e === "object" && "default" in e ? e : { "default": e };
 }
 var thunk__default = /* @__PURE__ */ _interopDefaultLegacy(thunk);
+var isHotkey__default = /* @__PURE__ */ _interopDefaultLegacy(isHotkey);
+const ComponentIcon = {
+  Billing: "billing",
+  Bolt: "bolt",
+  Button: "button",
+  Carousel: "carousel",
+  Chats: "chats",
+  Code: "code",
+  Countdown: "countdown",
+  Cube: "cube",
+  Database: "database",
+  Divider: "divider",
+  Form: "form",
+  Gallery: "gallery",
+  Help: "help",
+  Image: "image",
+  Layout: "layout",
+  Lock: "lock",
+  Navigation: "navigation",
+  SocialLinks: "social-links",
+  Star: "star",
+  Text: "text",
+  Users: "users",
+  Video: "video"
+};
+function getInitialState$8({
+  componentsMeta = /* @__PURE__ */ new Map()
+} = {}) {
+  return componentsMeta;
+}
+function getComponentsMeta(state) {
+  return state;
+}
+function reducer$9(state = getInitialState$8(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.REGISTER_COMPONENT:
+      return new Map(state).set(action.payload.type, action.payload.meta);
+    case actions.ActionTypes.UNREGISTER_COMPONENT: {
+      const nextState = new Map(state);
+      const deleted = nextState.delete(action.payload.type);
+      return deleted ? nextState : state;
+    }
+    default:
+      return state;
+  }
+}
 function isElementReference(element) {
   return !("props" in element);
 }
@@ -97,27 +143,6 @@ function reducer$7(state = getInitialState$6(), action) {
   }
 }
 function getInitialState$5({
-  componentsMeta = /* @__PURE__ */ new Map()
-} = {}) {
-  return componentsMeta;
-}
-function getComponentsMeta(state) {
-  return state;
-}
-function reducer$6(state = getInitialState$5(), action) {
-  switch (action.type) {
-    case actions.ActionTypes.REGISTER_COMPONENT:
-      return new Map(state).set(action.payload.type, action.payload.meta);
-    case actions.ActionTypes.UNREGISTER_COMPONENT: {
-      const nextState = new Map(state);
-      const deleted = nextState.delete(action.payload.type);
-      return deleted ? nextState : state;
-    }
-    default:
-      return state;
-  }
-}
-function getInitialState$4({
   propControllerDescriptors = /* @__PURE__ */ new Map()
 } = {}) {
   return propControllerDescriptors;
@@ -129,7 +154,7 @@ function getComponentPropControllerDescriptors$1(state, componentType) {
   var _a;
   return (_a = getPropControllerDescriptors$1(state).get(componentType)) != null ? _a : null;
 }
-function reducer$5(state = getInitialState$4(), action) {
+function reducer$6(state = getInitialState$5(), action) {
   switch (action.type) {
     case actions.ActionTypes.REGISTER_COMPONENT:
       return new Map(state).set(action.payload.type, action.payload.propControllerDescriptors);
@@ -148,7 +173,7 @@ function isPropControllersHandle(value) {
   }
   return false;
 }
-function getInitialState$3() {
+function getInitialState$4() {
   return { handles: /* @__PURE__ */ new Map(), instances: /* @__PURE__ */ new Map() };
 }
 function getPropControllersHandle(state, documentKey, elementKey) {
@@ -163,7 +188,7 @@ function getPropController(state, documentKey, elementKey, propName) {
   var _a, _b;
   return (_b = (_a = getPropControllers$1(state, documentKey, elementKey)) == null ? void 0 : _a[propName]) != null ? _b : null;
 }
-function reducer$4(state = getInitialState$3(), action) {
+function reducer$5(state = getInitialState$4(), action) {
   var _a, _b, _c, _d;
   switch (action.type) {
     case actions.ActionTypes.REGISTER_PROP_CONTROLLERS_HANDLE: {
@@ -194,10 +219,10 @@ function reducer$4(state = getInitialState$3(), action) {
       return state;
   }
 }
-function getInitialState$2() {
+function getInitialState$3() {
   return false;
 }
-function reducer$3(state = getInitialState$2(), action) {
+function reducer$4(state = getInitialState$3(), action) {
   switch (action.type) {
     case actions.ActionTypes.SET_IS_IN_BUILDER:
       return action.payload;
@@ -205,13 +230,13 @@ function reducer$3(state = getInitialState$2(), action) {
       return state;
   }
 }
-function getInitialState$1(isPreview = false) {
+function getInitialState$2(isPreview = false) {
   return isPreview;
 }
 function getIsPreview$1(state) {
   return state;
 }
-function reducer$2(state = getInitialState$1(), action) {
+function reducer$3(state = getInitialState$2(), action) {
   switch (action.type) {
     default:
       return state;
@@ -222,10 +247,10 @@ const BuilderEditMode = {
   CONTENT: "content",
   INTERACT: "interact"
 };
-function getInitialState() {
+function getInitialState$1() {
   return null;
 }
-function reducer$1(state = getInitialState(), action) {
+function reducer$2(state = getInitialState$1(), action) {
   switch (action.type) {
     case actions.ActionTypes.SET_BUILDER_EDIT_MODE:
       return action.payload.editMode;
@@ -233,6 +258,34 @@ function reducer$1(state = getInitialState(), action) {
       return state;
   }
 }
+function getInitialState(initialState) {
+  var _a, _b, _c;
+  return {
+    locales: (_a = initialState == null ? void 0 : initialState.locales) != null ? _a : [],
+    locale: (_b = initialState == null ? void 0 : initialState.locale) != null ? _b : null,
+    defaultLocale: (_c = initialState == null ? void 0 : initialState.defaultLocale) != null ? _c : null
+  };
+}
+function reducer$1(state = getInitialState(), action) {
+  switch (action.type) {
+    case actions.ActionTypes.SET_LOCALES: {
+      const locales = action.payload.locales;
+      return __spreadProps(__spreadValues({}, state), { locales });
+    }
+    case actions.ActionTypes.SET_LOCALE: {
+      if (action.payload.locale === state.locale)
+        return state;
+      return __spreadProps(__spreadValues({}, state), { locale: action.payload.locale });
+    }
+    case actions.ActionTypes.SET_DEFAULT_LOCALE: {
+      if (action.payload.defaultLocale === state.defaultLocale)
+        return state;
+      return __spreadProps(__spreadValues({}, state), { defaultLocale: action.payload.defaultLocale });
+    }
+    default:
+      return state;
+  }
+}
 const ColorControlType = "makeswift::controls::color";
 function Color(config = {}) {
   return { type: ColorControlType, config };
@@ -508,11 +561,11 @@ class ListControl extends PropController {
     this.controls = /* @__PURE__ */ new Map();
   }
 }
-function copyListData(definition, value, context) {
+function copyListData(definition2, value, context) {
   if (value == null)
     return value;
   return value && value.map((item) => __spreadProps(__spreadValues({}, item), {
-    value: copy(definition.config.type, item.value, context)
+    value: copy(definition2.config.type, item.value, context)
   }));
 }
 const ShapeControlType = "makeswift::controls::shape";
@@ -558,11 +611,11 @@ class ShapeControl extends PropController {
     this.setControls();
   }
 }
-function copyShapeData(definition, value, context) {
+function copyShapeData(definition2, value, context) {
   if (value == null)
     return value;
   const newValue = {};
-  for (const [key, itemDefinition] of Object.entries(definition.config.type)) {
+  for (const [key, itemDefinition] of Object.entries(definition2.config.type)) {
     const prop = value[key];
     newValue[key] = copy(itemDefinition, prop, context);
   }
@@ -1558,8 +1611,8 @@ function copy$1(descriptor, value, context) {
 function copyElementReference(value, context) {
   return context.replacementContext.globalElementIds.get(value) || value;
 }
-function copy(definition, value, context) {
-  switch (definition.type) {
+function copy(definition2, value, context) {
+  switch (definition2.type) {
     case Types.Backgrounds:
     case Types.Grid:
     case Types.NavigationLinks:
@@ -1573,7 +1626,7 @@ function copy(definition, value, context) {
     case Types.Border:
     case Types.RichText:
     case Types.ElementID:
-      return copy$1(definition, value, context);
+      return copy$1(definition2, value, context);
     case ColorControlType:
       return copyColorData(value, context);
     case ImageControlType:
@@ -1581,9 +1634,9 @@ function copy(definition, value, context) {
     case LinkControlType:
       return copyLinkData(value, context);
     case ShapeControlType:
-      return copyShapeData(definition, value, context);
+      return copyShapeData(definition2, value, context);
     case ListControlType:
-      return copyListData(definition, value, context);
+      return copyListData(definition2, value, context);
     case StyleControlType:
       return copyStyleData(value, context);
     case SlotControlType:
@@ -1592,14 +1645,18 @@ function copy(definition, value, context) {
       return value;
   }
 }
-function merge(definition, a, b = a, context) {
-  switch (definition.type) {
+function merge(definition2, a, b = a, context) {
+  switch (definition2.type) {
     case SlotControlType:
       return mergeSlotData(a, b, context);
     default:
       return b;
   }
 }
+const SelectControlType = "makeswift::controls::select";
+function Select(config) {
+  return { type: SelectControlType, config };
+}
 const ObjectType = {
   Value: "value",
   Text: "text",
@@ -1645,6 +1702,582 @@ const BlockTextAlignment = {
   Right: "right",
   Justify: "justify"
 };
+const ElementUtils = {
+  isRootBlock(node) {
+    return slate.Element.isElement(node) && (slate.Element.isElementType(node, BlockType.Paragraph) || slate.Element.isElementType(node, BlockType.Heading1) || slate.Element.isElementType(node, BlockType.Heading2) || slate.Element.isElementType(node, BlockType.Heading3) || slate.Element.isElementType(node, BlockType.Heading3) || slate.Element.isElementType(node, BlockType.Heading4) || slate.Element.isElementType(node, BlockType.Heading5) || slate.Element.isElementType(node, BlockType.Heading6) || slate.Element.isElementType(node, BlockType.BlockQuote) || slate.Element.isElementType(node, BlockType.UnorderedList) || slate.Element.isElementType(node, BlockType.OrderedList) || slate.Element.isElementType(node, BlockType.Text) || slate.Element.isElementType(node, BlockType.Default));
+  },
+  isBlock(node) {
+    return slate.Element.isElement(node) && (this.isRootBlock(node) || slate.Element.isElementType(node, BlockType.ListItem) || slate.Element.isElementType(node, BlockType.ListItemChild));
+  },
+  isInline(node) {
+    return slate.Element.isElementType(node, InlineType.Code) || slate.Element.isElementType(node, InlineType.Link) || slate.Element.isElementType(node, InlineType.SubScript) || slate.Element.isElementType(node, InlineType.SuperScript);
+  },
+  isConvertibleToListTextNode(node) {
+    return !this.isList(node) && !this.isListItem(node) && !this.isListItemChild(node);
+  },
+  isList(node) {
+    return slate.Element.isElementType(node, BlockType.OrderedList) || slate.Element.isElementType(node, BlockType.UnorderedList);
+  },
+  isListItem(node) {
+    return slate.Element.isElementType(node, BlockType.ListItem);
+  },
+  isListItemChild(node) {
+    return slate.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
+    };
+  }
+};
+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 getActiveBlockType(editor) {
+  var _a;
+  const rootBlocks = getBlocksInSelection(editor).map(([node]) => node.type);
+  return rootBlocks.reduce((a, b) => a === b ? b : null, (_a = rootBlocks.at(0)) != null ? _a : null);
+}
+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 = (_b = node[key]) != null ? _b : [];
+      const currentDeviceValue = state_breakpoints.findBreakpointOverride(breakpoints, deviceValues, deviceId, (v) => v);
+      const nextDeviceValue = __spreadProps(__spreadValues({}, currentDeviceValue), {
+        deviceId,
+        value
+      });
+      slate.Transforms.setNodes(editor, {
+        [key]: [...deviceValues.filter((v) => v.deviceId !== deviceId), nextDeviceValue]
+      }, { at: path });
+    }
+  }
+}
+function clearBlockKeyForDevice(editor, deviceId, key) {
+  var _a;
+  const rootElements = getBlocksInSelection(editor);
+  for (const [node, path] of rootElements) {
+    if (ElementUtils.isBlock(node)) {
+      const deviceOverrides = (_a = node[key]) != null ? _a : [];
+      slate.Transforms.setNodes(editor, {
+        [key]: deviceOverrides.filter((v) => v.deviceId !== deviceId)
+      }, { at: path });
+    }
+  }
+}
+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 EditorUtils = {
+  getFirstAncestorList(editor, path) {
+    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) {
+    try {
+      const parentListItem = slate.Editor.above(editor, {
+        at: path,
+        match: (node) => ElementUtils.isListItem(node)
+      });
+      return parentListItem != null ? parentListItem : null;
+    } catch (e) {
+      return null;
+    }
+  }
+};
+const LIST_ITEM_CHILD_POSITION = 0;
+const LIST_ITEM_LIST_POSITION = 1;
+function filterForSubtreeRoots(entries) {
+  return entries.filter(([, nodePath]) => !slate.Path.ancestors(nodePath).some((ancestor) => {
+    return entries.some(([, path]) => slate.Path.equals(path, ancestor));
+  }));
+}
+function unwrapPath(editor, listItemPath) {
+  const parentList = EditorUtils.getFirstAncestorList(editor, listItemPath);
+  const listItemContainingParentList = EditorUtils.getFirstAncestorListItem(editor, listItemPath);
+  if (!parentList || listItemContainingParentList)
+    return;
+  slate.Editor.withoutNormalizing(editor, () => {
+    const listItemTextPath = [...listItemPath, LIST_ITEM_CHILD_POSITION];
+    const listItemNestedListPath = [...listItemPath, LIST_ITEM_LIST_POSITION];
+    if (slate.Node.has(editor, listItemNestedListPath)) {
+      slate.Transforms.setNodes(editor, { type: parentList[0].type }, { at: listItemNestedListPath });
+      slate.Transforms.liftNodes(editor, { at: listItemNestedListPath });
+      slate.Transforms.liftNodes(editor, { at: slate.Path.next(listItemPath) });
+    }
+    if (slate.Node.has(editor, listItemTextPath)) {
+      slate.Transforms.setNodes(editor, { type: BlockType.Paragraph }, {
+        at: listItemTextPath
+      });
+      slate.Transforms.liftNodes(editor, { at: listItemTextPath });
+      slate.Transforms.liftNodes(editor, { at: listItemPath });
+    }
+  });
+}
+function unwrapList(editor, options) {
+  var _a;
+  const at = (_a = options == null ? void 0 : options.at) != null ? _a : editor.selection;
+  if (!at)
+    return;
+  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) => {
+    if (ref.current) {
+      unwrapPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function wrapList(editor, options = { type: BlockType.UnorderedList }) {
+  var _a;
+  const at = (_a = options.at) != null ? _a : editor.selection;
+  if (!at)
+    return;
+  const nonListEntries = Array.from(slate.Editor.nodes(editor, {
+    at,
+    match: (node) => {
+      return slate.Element.isElement(node) && ElementUtils.isConvertibleToListTextNode(node);
+    }
+  }));
+  const refs = nonListEntries.map(([_, path]) => slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    const path = ref.current;
+    if (path) {
+      slate.Editor.withoutNormalizing(editor, () => {
+        slate.Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
+          at: path
+        });
+        slate.Transforms.wrapNodes(editor, ElementUtils.createListItem(), {
+          match: (node) => ElementUtils.isListItemChild(node),
+          at: path
+        });
+        slate.Transforms.wrapNodes(editor, ElementUtils.createList(options.type), {
+          at: path
+        });
+      });
+    }
+    ref.unref();
+  });
+}
+const LocationUtils = {
+  getStartPath(location) {
+    if (slate.Range.isRange(location))
+      return slate.Range.start(location).path;
+    if (slate.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 = slate.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) => slate.Path.isDescendant(start, node[1]) ? slate.Path.equals(node[1], firstAncestorPath) : !slate.Path.isAfter(start, node[1]));
+}
+function indentPath(editor, path) {
+  const parent = slate.Node.parent(editor, path);
+  if (!path || !slate.Path.hasPrevious(path) || !ElementUtils.isList(parent))
+    return;
+  const previosPath = slate.Path.previous(path);
+  const previousChildListPath = [...previosPath, LIST_ITEM_LIST_POSITION];
+  const previousHasChildList = slate.Node.has(editor, previousChildListPath);
+  slate.Editor.withoutNormalizing(editor, () => {
+    if (!previousHasChildList) {
+      slate.Transforms.insertNodes(editor, ElementUtils.createList(parent.type), {
+        at: previousChildListPath
+      });
+    }
+    const previousChildList = slate.Node.get(editor, previousChildListPath);
+    if (ElementUtils.isList(previousChildList)) {
+      const index = previousHasChildList ? previousChildList.children.length : 0;
+      slate.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]) => slate.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);
+  slate.Editor.withoutNormalizing(editor, () => {
+    nextSiblings.forEach(() => {
+      const nextSiblingPath = [...parentListPath, listItemPosition + 1];
+      indentPath(editor, nextSiblingPath);
+    });
+    slate.Transforms.moveNodes(editor, {
+      at: listItemPath,
+      to: slate.Path.next(listItemContainingParentListPath)
+    });
+    if (previousSiblings.length === 0) {
+      slate.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]) => slate.Editor.pathRef(editor, path));
+  refs.forEach((ref) => {
+    if (ref.current) {
+      dedentPath(editor, ref.current);
+    }
+    ref.unref();
+  });
+}
+function toggleList(editor, options = { type: BlockType.UnorderedList }) {
+  var _a;
+  const at = (_a = options.at) != null ? _a : editor.selection;
+  if (at == null)
+    return;
+  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, at });
+  }
+  if (ancestor.type === options.type) {
+    unwrapList(editor, { at });
+  } else {
+    slate.Transforms.setNodes(editor, { type: options.type }, { at: ancestorPath });
+  }
+}
+const BlockActions = {
+  setBlockKeyForDevice,
+  clearBlockKeyForDevice,
+  wrapInline,
+  unwrapInline
+};
+const ListActions = {
+  unwrapList,
+  wrapList,
+  indent,
+  dedent,
+  toggleList
+};
+function onKeyDown(e, editor) {
+  if (!editor.selection || Array.from(slate.Editor.nodes(editor, { match: (node) => ElementUtils.isListItem(node) })).length === 0)
+    return;
+  if (isHotkey__default["default"]("shift+tab", e)) {
+    e.preventDefault();
+    ListActions.dedent(editor);
+  }
+  if (isHotkey__default["default"]("tab", e)) {
+    e.preventDefault();
+    ListActions.indent(editor);
+  }
+  if (isHotkey__default["default"]("backspace", e)) {
+    if (!editor.selection)
+      return;
+    if (slate.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) {
+        ListActions.dedent(editor);
+      } else if (list) {
+        ListActions.unwrapList(editor);
+      }
+      return;
+    }
+  }
+  if (isHotkey__default["default"]("enter", e)) {
+    e.preventDefault();
+    if (!editor.selection)
+      return;
+    if (slate.Range.isExpanded(editor.selection)) {
+      slate.Transforms.delete(editor);
+      return;
+    }
+    const listItem = EditorUtils.getFirstAncestorListItem(editor, editor.selection.anchor.path);
+    if (editor.selection.anchor.offset === 0 && listItem && slate.Editor.string(editor, listItem[1]) === "") {
+      const parentListItem = EditorUtils.getFirstAncestorListItem(editor, listItem[1]);
+      if (parentListItem) {
+        ListActions.dedent(editor);
+      } else {
+        ListActions.unwrapList(editor);
+      }
+      return;
+    }
+    slate.Transforms.splitNodes(editor, {
+      at: editor.selection,
+      always: true,
+      match: (node) => ElementUtils.isListItem(node)
+    });
+  }
+  if (isHotkey__default["default"]("shift+enter", e)) {
+    e.preventDefault();
+    editor.insertText("\n");
+  }
+}
+function withBlock(editor) {
+  const { normalizeNode } = editor;
+  editor.isInline = (entry) => {
+    return ElementUtils.isInline(entry);
+  };
+  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) {
+      slate.Transforms.unsetNodes(editor, "textAlign", { at: normalizationPath });
+      return;
+    }
+    if (ElementUtils.isListItem(normalizationNode)) {
+      const pathToListItemText = [...normalizationPath, LIST_ITEM_CHILD_POSITION];
+      if (slate.Node.has(editor, pathToListItemText)) {
+        const nodeInListItemTextPosition = slate.Node.get(editor, pathToListItemText);
+        if (ElementUtils.isRootBlock(nodeInListItemTextPosition)) {
+          slate.Transforms.setNodes(editor, { type: BlockType.ListItemChild }, {
+            at: pathToListItemText
+          });
+          return;
+        }
+      } else {
+        slate.Transforms.insertNodes(editor, ElementUtils.createListItem(), {
+          at: pathToListItemText
+        });
+        return;
+      }
+    }
+    if (!slate.Text.isText(normalizationNode)) {
+      const mergeableChildren = Array.from(slate.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 [
+          slate.Editor.pathRef(editor, child[1]),
+          slate.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(slate.Node.children(editor, nodePath));
+          const childrenToBeMerged = Array.from(slate.Node.children(editor, nodeToBeMergedPath));
+          slate.Editor.withoutNormalizing(editor, () => {
+            childrenToBeMerged.reverse().forEach(([_, childPath]) => {
+              slate.Transforms.moveNodes(editor, {
+                at: childPath,
+                to: [...nodePath, nodeChildren.length]
+              });
+            });
+            slate.Transforms.removeNodes(editor, { at: nodeToBeMergedPath });
+          });
+          nodePathRef.unref();
+          nodeToBeMergedPathRef.unref();
+        });
+        return;
+      }
+    }
+    normalizeNode(entry);
+  };
+  return editor;
+}
+const definition = Select({
+  label: "Block",
+  labelOrientation: "horizontal",
+  options: [
+    {
+      value: BlockType.Paragraph,
+      label: "Paragraph"
+    },
+    {
+      value: BlockType.Heading1,
+      label: "Heading 1"
+    },
+    {
+      value: BlockType.Heading2,
+      label: "Heading 2"
+    },
+    {
+      value: BlockType.Heading3,
+      label: "Heading 3"
+    },
+    {
+      value: BlockType.Heading4,
+      label: "Heading 4"
+    },
+    {
+      value: BlockType.Heading5,
+      label: "Heading 5"
+    },
+    {
+      value: BlockType.Heading6,
+      label: "Heading 6"
+    },
+    {
+      value: BlockType.UnorderedList,
+      label: "Bulleted list"
+    },
+    {
+      value: BlockType.OrderedList,
+      label: "Numbered list"
+    },
+    {
+      value: BlockType.BlockQuote,
+      label: "Quote"
+    }
+  ],
+  defaultValue: BlockType.Paragraph
+});
+function BlockPlugin() {
+  return createRichTextV2Plugin({
+    withPlugin: withBlock,
+    onKeyDown,
+    control: {
+      definition,
+      onChange: (editor, value) => {
+        const activeBlockType = getActiveBlockType(editor);
+        if (value === BlockType.UnorderedList || value === BlockType.OrderedList) {
+          ListActions.toggleList(editor, {
+            type: value,
+            at: getSelection(editor)
+          });
+        } else if (activeBlockType === value) {
+          slate.Transforms.setNodes(editor, {
+            type: BlockType.Default
+          }, { at: getSelection(editor) });
+        } else {
+          ListActions.unwrapList(editor, {
+            at: getSelection(editor)
+          });
+          slate.Transforms.setNodes(editor, {
+            type: value != null ? value : BlockType.Default
+          }, { at: getSelection(editor) });
+        }
+      },
+      getValue: (editor) => {
+        const activeBlock = getActiveBlockType(editor);
+        if (activeBlock === RootBlockType.Text || activeBlock === RootBlockType.Default)
+          return void 0;
+        return activeBlock;
+      }
+    }
+  });
+}
 const RichTextV2ControlType = "makeswift::controls::rich-text-v2";
 const RichTextV2Mode = {
   Inline: "makeswift::controls::rich-text-v2::mode::inline",
@@ -1653,9 +2286,9 @@ const RichTextV2Mode = {
 function createRichTextV2Plugin({
   control,
   withPlugin,
-  onKeyDown
+  onKeyDown: onKeyDown2
 }) {
-  return { control, withPlugin, onKeyDown };
+  return { control, withPlugin, onKeyDown: onKeyDown2 };
 }
 function unstable_RichTextV2(config = {}) {
   return { type: RichTextV2ControlType, config };
@@ -2545,13 +3178,14 @@ var introspection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
 const reducer = redux.combineReducers({
   documents: reducer$8,
   reactComponents: reducer$7,
-  componentsMeta: reducer$6,
-  propControllers: reducer$5,
-  propControllerHandles: reducer$4,
-  isInBuilder: reducer$3,
-  isPreview: reducer$2,
-  builderEditMode: reducer$1,
-  breakpoints: state_breakpoints.reducer
+  componentsMeta: reducer$9,
+  propControllers: reducer$6,
+  propControllerHandles: reducer$5,
+  isInBuilder: reducer$4,
+  isPreview: reducer$3,
+  builderEditMode: reducer$2,
+  breakpoints: state_breakpoints.reducer,
+  locales: reducer$1
 });
 function getDocumentsStateSlice(state) {
   return state.documents;
@@ -2694,17 +3328,24 @@ function getBuilderEditMode(state) {
 function getBreakpoints(state) {
   return state.breakpoints;
 }
+function getLocales(state) {
+  return state.locales;
+}
 function configureStore({
   rootElements,
   preloadedState,
-  breakpoints
+  breakpoints,
+  locales
 } = {}) {
   return redux.createStore(reducer, __spreadProps(__spreadValues({}, preloadedState), {
     documents: getInitialState$7({ rootElements }),
-    breakpoints: state_breakpoints.getInitialState(breakpoints != null ? breakpoints : preloadedState == null ? void 0 : preloadedState.breakpoints)
+    breakpoints: state_breakpoints.getInitialState(breakpoints != null ? breakpoints : preloadedState == null ? void 0 : preloadedState.breakpoints),
+    locales: getInitialState(locales != null ? locales : preloadedState == null ? void 0 : preloadedState.locales)
   }), redux.applyMiddleware(thunk__default["default"]));
 }
 exports.Backgrounds = Backgrounds;
+exports.BlockActions = BlockActions;
+exports.BlockPlugin = BlockPlugin;
 exports.BlockTextAlignment = BlockTextAlignment;
 exports.BlockType = BlockType;
 exports.Border = Border;
@@ -2715,8 +3356,10 @@ exports.BuilderEditMode = BuilderEditMode;
 exports.Checkbox = Checkbox;
 exports.Color = Color;
 exports.ColorControlType = ColorControlType;
+exports.ComponentIcon = ComponentIcon;
 exports.Date = Date;
 exports.ElementID = ElementID;
+exports.ElementUtils = ElementUtils;
 exports.Font = Font;
 exports.GapX = GapX;
 exports.GapY = GapY;
@@ -2731,6 +3374,7 @@ exports.Link = Link;
 exports.Link$1 = Link$1;
 exports.LinkControlType = LinkControlType;
 exports.List = List$1;
+exports.ListActions = ListActions;
 exports.ListControl = ListControl;
 exports.ListControlMessageType = ListControlMessageType;
 exports.ListControlType = ListControlType;
@@ -2758,6 +3402,8 @@ exports.RichTextV2ControlMessageType = RichTextV2ControlMessageType;
 exports.RichTextV2ControlType = RichTextV2ControlType;
 exports.RichTextV2Mode = RichTextV2Mode;
 exports.RootBlockType = RootBlockType;
+exports.Select = Select;
+exports.SelectControlType = SelectControlType;
 exports.Shadows = Shadows;
 exports.ShadowsPropControllerFormat = ShadowsPropControllerFormat;
 exports.Shape = Shape$1;
@@ -2818,9 +3464,10 @@ exports.getElementPropControllerDescriptors = getElementPropControllerDescriptor
 exports.getElementSwatchIds = getElementSwatchIds;
 exports.getFileIds = getFileIds;
 exports.getInitialState = getInitialState$7;
-exports.getInitialState$1 = getInitialState$1;
+exports.getInitialState$1 = getInitialState$2;
 exports.getIsInBuilder = getIsInBuilder;
 exports.getIsPreview = getIsPreview;
+exports.getLocales = getLocales;
 exports.getPageIds = getPageIds;
 exports.getPropController = getPropController;
 exports.getPropControllerDescriptors = getPropControllerDescriptors;
@@ -2836,17 +3483,20 @@ exports.isNonNullable = isNonNullable;
 exports.isPropControllersHandle = isPropControllersHandle;
 exports.merge = merge;
 exports.mergeSlotData = mergeSlotData;
+exports.onKeyDown = onKeyDown;
 exports.reducer = reducer$8;
 exports.reducer$1 = reducer$7;
-exports.reducer$2 = reducer$6;
-exports.reducer$3 = reducer$5;
-exports.reducer$4 = reducer$4;
-exports.reducer$5 = reducer$3;
-exports.reducer$6 = reducer$2;
-exports.reducer$7 = reducer$1;
+exports.reducer$2 = reducer$9;
+exports.reducer$3 = reducer$6;
+exports.reducer$4 = reducer$5;
+exports.reducer$5 = reducer$4;
+exports.reducer$6 = reducer$3;
+exports.reducer$7 = reducer$2;
+exports.reducer$8 = reducer$1;
 exports.richTextDAOToDTO = richTextDAOToDTO;
 exports.richTextDTOtoDAO = richTextDTOtoDAO;
 exports.richTextDTOtoSelection = richTextDTOtoSelection;
 exports.toSelectionDTO = toSelectionDTO;
 exports.unstable_RichTextV2 = unstable_RichTextV2;
+exports.withBlock = withBlock;
 //# sourceMappingURL=react-page.cjs.js.map