@makeswift/runtime 0.11.2 → 0.11.3

package/dist/main.cjs.js

@@ -12,12 +12,14 @@ require("corporate-ipsum");
 require("slate");
 require("uuid");
 require("escape-html");
+require("slate-hyperscript");
+require("parse5");
+require("is-hotkey");
+require("react/jsx-runtime");
 require("react");
 require("@emotion/css");
 require("@emotion/serialize");
 require("@emotion/utils");
-require("react/jsx-runtime");
-require("is-hotkey");
 exports.ActionTypes = actions.ActionTypes;
 exports.builderPointerMove = actions.builderPointerMove;
 exports.changeApiResource = actions.changeApiResource;

package/dist/main.cjs.js.map

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

package/dist/main.es.js

@@ -10,10 +10,12 @@ import "corporate-ipsum";
 import "slate";
 import "uuid";
 import "escape-html";
+import "slate-hyperscript";
+import "parse5";
+import "is-hotkey";
+import "react/jsx-runtime";
 import "react";
 import "@emotion/css";
 import "@emotion/serialize";
 import "@emotion/utils";
-import "react/jsx-runtime";
-import "is-hotkey";
 //# sourceMappingURL=main.es.js.map

package/dist/main.es.js.map

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

package/dist/next.cjs.js

@@ -16,10 +16,12 @@ require("corporate-ipsum");
 require("slate");
 require("uuid");
 require("escape-html");
+require("slate-hyperscript");
+require("parse5");
+require("is-hotkey");
 require("@emotion/css");
 require("@emotion/serialize");
 require("@emotion/utils");
-require("is-hotkey");
 require("./number.cjs.js");
 require("./combobox.cjs.js");
 require("use-sync-external-store/shim");

package/dist/next.cjs.js.map

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

package/dist/next.es.js

@@ -14,10 +14,12 @@ import "corporate-ipsum";
 import "slate";
 import "uuid";
 import "escape-html";
+import "slate-hyperscript";
+import "parse5";
+import "is-hotkey";
 import "@emotion/css";
 import "@emotion/serialize";
 import "@emotion/utils";
-import "is-hotkey";
 import "./number.es.js";
 import "./combobox.es.js";
 import "use-sync-external-store/shim";

package/dist/next.es.js.map

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

package/dist/prop-controllers.cjs.js

@@ -11,12 +11,14 @@ require("corporate-ipsum");
 require("slate");
 require("uuid");
 require("escape-html");
+require("slate-hyperscript");
+require("parse5");
+require("is-hotkey");
+require("react/jsx-runtime");
 require("react");
 require("@emotion/css");
 require("@emotion/serialize");
 require("@emotion/utils");
-require("react/jsx-runtime");
-require("is-hotkey");
 exports.Introspection = reactPage.introspection;
 exports.Props = reactPage.descriptors;
 exports.RichTextPropControllerMessageType = reactPage.RichTextPropControllerMessageType;

package/dist/prop-controllers.cjs.js.map

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

package/dist/prop-controllers.es.js

@@ -9,10 +9,12 @@ import "corporate-ipsum";
 import "slate";
 import "uuid";
 import "escape-html";
+import "slate-hyperscript";
+import "parse5";
+import "is-hotkey";
+import "react/jsx-runtime";
 import "react";
 import "@emotion/css";
 import "@emotion/serialize";
 import "@emotion/utils";
-import "react/jsx-runtime";
-import "is-hotkey";
 //# sourceMappingURL=prop-controllers.es.js.map

package/dist/prop-controllers.es.js.map

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

package/dist/react-page.cjs.js

@@ -44,20 +44,22 @@ var ipsum = require("corporate-ipsum");
 var slate = require("slate");
 var uuid = require("uuid");
 var escapeHtml = require("escape-html");
+var slateHyperscript = require("slate-hyperscript");
+var parse5 = require("parse5");
+var isHotkey = require("is-hotkey");
+var jsxRuntime = require("react/jsx-runtime");
 var React = require("react");
 var css = require("@emotion/css");
 var serialize = require("@emotion/serialize");
 var utils = require("@emotion/utils");
-var jsxRuntime = require("react/jsx-runtime");
-var isHotkey = require("is-hotkey");
 function _interopDefaultLegacy(e) {
   return e && typeof e === "object" && "default" in e ? e : { "default": e };
 }
 var thunk__default = /* @__PURE__ */ _interopDefaultLegacy(thunk);
 var ipsum__default = /* @__PURE__ */ _interopDefaultLegacy(ipsum);
 var escapeHtml__default = /* @__PURE__ */ _interopDefaultLegacy(escapeHtml);
-var React__default = /* @__PURE__ */ _interopDefaultLegacy(React);
 var isHotkey__default = /* @__PURE__ */ _interopDefaultLegacy(isHotkey);
+var React__default = /* @__PURE__ */ _interopDefaultLegacy(React);
 const ComponentIcon = {
   Billing: "billing",
   Bolt: "bolt",
@@ -573,6 +575,11 @@ function GapY(options = {}) {
 function Grid(options = {}) {
   return { type: Types.Grid, options };
 }
+function mergeGridPropControllerTranslatedData(data, context) {
+  return __spreadProps(__spreadValues({}, data), {
+    elements: data.elements.map((element) => context.mergeTranslatedData(element))
+  });
+}
 function Image$1(options = {}) {
   return { type: Types.Image, version: 1, options };
 }
@@ -726,6 +733,7 @@ var descriptors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   GapX,
   GapY,
   Grid,
+  mergeGridPropControllerTranslatedData,
   Image: Image$1,
   Images,
   Link: Link$1,
@@ -1063,6 +1071,13 @@ function getListPageIds(definition2, value) {
 function getListTranslatableData(definition2, data) {
   return Object.fromEntries(data.map((item) => [item.id, getTranslatableData(definition2.config.type, item.value)]));
 }
+function mergeListTranslatedData(definition2, data, translatedData, context) {
+  return data.map((item) => {
+    return __spreadProps(__spreadValues({}, item), {
+      value: mergeTranslatedData(definition2.config.type, item.value, translatedData[item.id], context)
+    });
+  });
+}
 const ShapeControlType = "makeswift::controls::shape";
 function Shape(config) {
   return { type: ShapeControlType, config };
@@ -1142,6 +1157,12 @@ function getShapeTranslatableData(definition2, data) {
     getTranslatableData(definition22, data[key])
   ]));
 }
+function mergeShapeTranslatedData(definition2, data, translatedData, context) {
+  return Object.fromEntries(Object.entries(definition2.config.type).map(([key, definition22]) => [
+    key,
+    mergeTranslatedData(definition22, data.key, translatedData[key], context)
+  ]));
+}
 const TextAreaControlType = "makeswift::controls::text-area";
 function TextArea(config = {}) {
   return { type: TextAreaControlType, config };
@@ -1194,6 +1215,11 @@ function mergeSlotData(base = { columns: [], elements: [] }, override = { column
   });
   return { columns: mergedColumns, elements: mergedElements };
 }
+function mergeSlotControlTranslatedData(data, context) {
+  return __spreadProps(__spreadValues({}, data), {
+    elements: data.elements.map((element) => context.mergeTranslatedData(element))
+  });
+}
 function copy$e(descriptor, value, context) {
   if (value == null)
     return value;
@@ -2374,7 +2400,7 @@ const ElementUtils = {
     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);
+    return slate.Element.isElement(node) && (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);
@@ -3949,40 +3975,132 @@ function copyRichTextV2Data(data, context) {
     });
   }
 }
-function hashTranslationString(s) {
-  let hash = 0;
-  for (let i = 0, len = s.length; i < len; i++) {
-    let chr = s.charCodeAt(i);
-    hash = (hash << 5) - hash + chr;
-    hash |= 0;
+function pathToString(path) {
+  return path.join(":");
+}
+function stringToPath(s) {
+  return s.split(":").map((a) => parseInt(a));
+}
+function getDescendantTranslatableData(descendant, path) {
+  if (slate.Text.isText(descendant)) {
+    return {};
+  }
+  switch (descendant.type) {
+    case BlockType.UnorderedList:
+    case BlockType.OrderedList:
+    case BlockType.ListItem:
+      return descendant.children.reduce((acc, d, j) => __spreadValues(__spreadValues({}, acc), getDescendantTranslatableData(d, [...path, j])), {});
+    default:
+      const text = getInlineOrTextTranslatableData(descendant);
+      if (text == null)
+        return {};
+      return { [pathToString(path)]: text };
   }
-  return hash.toString();
 }
-function getRichTextV2TranslatableDescendant(definition2, descendant) {
+function getInlineOrTextTranslatableData(descendant, path = []) {
   if (slate.Text.isText(descendant)) {
     let string = escapeHtml__default["default"](descendant.text);
-    return string;
+    if (string === "")
+      return null;
+    return `<span key="${pathToString(path)}">${string}</span>`;
   }
-  const children = descendant.children.map((child) => getRichTextV2TranslatableDescendant(definition2, child)).join("");
+  const children = descendant.children.map((child, i) => getInlineOrTextTranslatableData(child, [...path, i])).join("");
+  if (children === "")
+    return null;
   switch (descendant.type) {
     case InlineType.Link:
-      return `<a>${children}</a>`;
-    case InlineType.Link:
-      return `<sup>${children}</sup>`;
-    case InlineType.Link:
-      return `<sub>${children}</sub>`;
-    case InlineType.Link:
-      return `<code>${children}</code>`;
+      return `<a key="${pathToString(path)}">${children}</a>`;
+    case InlineType.SuperScript:
+      return `<sup key="${pathToString(path)}">${children}</sup>`;
+    case InlineType.SubScript:
+      return `<sub key="${pathToString(path)}">${children}</sub>`;
+    case InlineType.Code:
+      return `<code key="${pathToString(path)}">${children}</code>`;
     default:
       return children;
   }
 }
-function getRichTextV2TranslatableData(definition2, data) {
-  return data.descendants.reduce((acc, descendant) => {
-    const value = getRichTextV2TranslatableDescendant(definition2, descendant);
-    const key = hashTranslationString(value);
-    return __spreadProps(__spreadValues({}, acc), { [key]: value });
-  }, {});
+function getRichTextV2TranslatableData(data) {
+  return data.descendants.reduce((acc, descendant, i) => __spreadValues(__spreadValues({}, acc), getDescendantTranslatableData(descendant, [i])), {});
+}
+function deserializeTranslationHtmlString(el, translationKey) {
+  var _a, _b;
+  if (el.nodeName === "#document-fragment") {
+    const children = Array.from(el.childNodes).map((element) => deserializeTranslationHtmlString(element)).flat();
+    if (children.length === 0) {
+      children.push(slateHyperscript.jsx("text", {}, ""));
+    }
+    return children;
+  } else if (el.nodeName === "#text" && "value" in el) {
+    return [slateHyperscript.jsx("text", { translationKey: translationKey != null ? translationKey : void 0 }, el.value)];
+  } else if ("namespaceURI" in el) {
+    const translationKey2 = (_b = (_a = el.attrs.find((a) => a.name === "key")) == null ? void 0 : _a.value) != null ? _b : void 0;
+    const children = Array.from(el.childNodes).map((element) => deserializeTranslationHtmlString(element, translationKey2)).flat();
+    if (children.length === 0) {
+      children.push(slateHyperscript.jsx("text", {}, ""));
+    }
+    switch (el.nodeName) {
+      case "code":
+        return [slateHyperscript.jsx("element", { type: InlineType.Code, translationKey: translationKey2 }, children)];
+      case "sub":
+        return [slateHyperscript.jsx("element", { type: InlineType.SubScript, translationKey: translationKey2 }, children)];
+      case "sup":
+        return [slateHyperscript.jsx("element", { type: InlineType.SuperScript, translationKey: translationKey2 }, children)];
+      case "a":
+        return [slateHyperscript.jsx("element", { type: InlineType.Link, translationKey: translationKey2 }, children)];
+      default:
+        return children;
+    }
+  }
+  return [];
+}
+function mergeRichTextV2TranslatedData(definition2, data, translatedData) {
+  var _a;
+  const plugins = ((_a = definition2 == null ? void 0 : definition2.config) == null ? void 0 : _a.mode) === RichTextV2Mode.Inline ? [InlineModePlugin()] : [BlockPlugin(), TypographyPlugin(), TextAlignPlugin(), InlinePlugin()];
+  const sourceEditor = plugins.reduceRight((editor, plugin) => {
+    var _a2, _b;
+    return (_b = (_a2 = plugin == null ? void 0 : plugin.withPlugin) == null ? void 0 : _a2.call(plugin, editor)) != null ? _b : editor;
+  }, slate.createEditor());
+  const targetEditor = plugins.reduceRight((editor, plugin) => {
+    var _a2, _b;
+    return (_b = (_a2 = plugin == null ? void 0 : plugin.withPlugin) == null ? void 0 : _a2.call(plugin, editor)) != null ? _b : editor;
+  }, slate.createEditor());
+  sourceEditor.children = data.descendants;
+  Object.entries(translatedData).reverse().forEach(([blockStringPath, htmlString]) => {
+    var _c2;
+    const blockPath = stringToPath(blockStringPath);
+    if (blockPath.length === 0)
+      return;
+    const html = parse5.parseFragment(htmlString);
+    const inlineDescendants = deserializeTranslationHtmlString(html);
+    targetEditor.children = [{ type: BlockType.Default, children: inlineDescendants }];
+    slate.Editor.normalize(targetEditor, { force: true });
+    for (const [descendant, absolutePathToTargetNode] of slate.Node.descendants(targetEditor)) {
+      if (!slate.Text.isText(descendant) && !ElementUtils.isInline(descendant) || descendant.translationKey == null || descendant.translationKey === "") {
+        continue;
+      }
+      const relativePathToSourceNode = stringToPath(descendant.translationKey);
+      const absolutePathToSourceNode = [...blockPath, ...relativePathToSourceNode];
+      const [sourceNode] = slate.Editor.node(sourceEditor, absolutePathToSourceNode);
+      if (slate.Text.isText(sourceNode) && slate.Text.isText(descendant)) {
+        const _a2 = sourceNode, { translationKey, text } = _a2, rest = __objRest(_a2, ["translationKey", "text"]);
+        slate.Transforms.setNodes(targetEditor, rest, { at: absolutePathToTargetNode });
+        slate.Transforms.unsetNodes(targetEditor, "translationKey", { at: absolutePathToTargetNode });
+      } else if (ElementUtils.isInline(sourceNode) && ElementUtils.isInline(descendant)) {
+        const _b = sourceNode, { translationKey, children } = _b, rest = __objRest(_b, ["translationKey", "children"]);
+        slate.Transforms.setNodes(targetEditor, rest, { at: absolutePathToTargetNode });
+        slate.Transforms.unsetNodes(targetEditor, "translationKey", { at: absolutePathToTargetNode });
+      }
+    }
+    const translatedChildren = (_c2 = targetEditor.children.at(0)) == null ? void 0 : _c2.children;
+    slate.Editor.withoutNormalizing(sourceEditor, () => {
+      Array.from(slate.Node.children(sourceEditor, blockPath)).reverse().forEach(([_, path]) => {
+        slate.Transforms.removeNodes(sourceEditor, { at: path });
+      });
+      slate.Transforms.insertNodes(sourceEditor, translatedChildren, { at: [...blockPath, 0] });
+    });
+  });
+  return __spreadProps(__spreadValues({}, data), { descendants: sourceEditor.children });
 }
 function copy(definition2, value, context) {
   switch (definition2.type) {
@@ -4038,7 +4156,10 @@ function getTranslatableData(definition2, data) {
     case TextAreaControlType:
       return data;
     case RichTextV2ControlType:
-      return getRichTextV2TranslatableData(definition2, data);
+      const richTextData = data;
+      if (isRichTextV1Data(richTextData))
+        return null;
+      return getRichTextV2TranslatableData(richTextData);
     case ListControlType:
       return getListTranslatableData(definition2, data);
     case ShapeControlType:
@@ -4047,6 +4168,35 @@ function getTranslatableData(definition2, data) {
       return null;
   }
 }
+function mergeTranslatedData(definition2, data, translatedData, context) {
+  switch (definition2.type) {
+    case Types.TextInput:
+    case Types.TextArea:
+    case TextInputControlType:
+    case TextAreaControlType:
+      if (translatedData == null)
+        return data;
+      return translatedData;
+    case Types.Grid:
+      return mergeGridPropControllerTranslatedData(data, context);
+    case SlotControlType:
+      return mergeSlotControlTranslatedData(data, context);
+    case RichTextV2ControlType:
+      if (translatedData == null)
+        return data;
+      return mergeRichTextV2TranslatedData(definition2, data, translatedData);
+    case ListControlType:
+      if (translatedData == null)
+        return data;
+      return mergeListTranslatedData(definition2, data, translatedData, context);
+    case ShapeControlType:
+      if (translatedData == null)
+        return data;
+      return mergeShapeTranslatedData(definition2, data, translatedData, context);
+    default:
+      return data;
+  }
+}
 const StyleV2ControlType = "makeswift::controls::style-v2";
 const unstable_useStyleV2ClassName = useStyle;
 function unstable_StyleV2(config) {
@@ -4722,6 +4872,30 @@ function getElementTreeTranslatableData(state, elementTree) {
   }
   return translatableData;
 }
+function mergeElementTreeTranslatedData(state, elementTree, translatedData) {
+  function merge2(state2, translatedData2) {
+    return function(node) {
+      if (isElementReference(node))
+        return node;
+      const elementDescriptors = getPropControllerDescriptors(state2);
+      const descriptors2 = elementDescriptors.get(node.type);
+      if (descriptors2 == null) {
+        throw new Error(`Can't merge element of type "${node.type}" because it has no descriptors`);
+      }
+      const context = {
+        translatedData: translatedData2,
+        mergeTranslatedData: merge2(state2, translatedData2)
+      };
+      const props = {};
+      for (const propName of Object.keys(descriptors2)) {
+        const descriptor = descriptors2[propName];
+        props[propName] = mergeTranslatedData(descriptor, node.props[propName], translatedData2[`${node.key}:${propName}`], context);
+      }
+      return __spreadProps(__spreadValues({}, node), { props });
+    };
+  }
+  return merge2(state, translatedData)(elementTree);
+}
 function getIsInBuilder(state) {
   return state.isInBuilder;
 }
@@ -4920,7 +5094,12 @@ exports.isNonNullable = isNonNullable;
 exports.isPropControllersHandle = isPropControllersHandle;
 exports.isRichTextV1Data = isRichTextV1Data;
 exports.merge = merge;
+exports.mergeElementTreeTranslatedData = mergeElementTreeTranslatedData;
+exports.mergeListTranslatedData = mergeListTranslatedData;
+exports.mergeShapeTranslatedData = mergeShapeTranslatedData;
+exports.mergeSlotControlTranslatedData = mergeSlotControlTranslatedData;
 exports.mergeSlotData = mergeSlotData;
+exports.mergeTranslatedData = mergeTranslatedData;
 exports.onChange = onChange$1;
 exports.onKeyDown = onKeyDown;
 exports.reducer = reducer$7;