@uniformdev/tms-sdk 19.135.1-alpha.11

package/dist/index.esm.js

@@ -0,0 +1,1014 @@
+// src/collectTranslationPayload.ts
+import {
+  bindVariables,
+  walkNodeTree as walkNodeTree2
+} from "@uniformdev/canvas";
+import { isRichTextValue as isRichTextValue2, isRichTextValueConsideredEmpty as isRichTextValueConsideredEmpty2 } from "@uniformdev/richtext";
+
+// src/constants.ts
+var TRANSLATION_PAYLOAD_SOURCE_KEY = "source";
+var TRANSLATION_PAYLOAD_TARGET_KEY = "target";
+var TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY = "originalTarget";
+var SUPPORTED_PARAM_TYPES = {
+  text: "text",
+  richText: "richText"
+};
+
+// src/richText/renderAsTranslatableXml.ts
+import { getRichTextTagsFromTextFormat, isRichTextNodeType } from "@uniformdev/richtext";
+var REF_ATTRIBUTE_NAME = "ref";
+function renderAsTranslatableXml(root) {
+  if (!root) {
+    return null;
+  }
+  const result = {
+    attributes: [],
+    xmlParts: []
+  };
+  renderXmlNode(result, root);
+  const metadata = result.attributes.reduce(
+    (result2, current, index) => {
+      result2[String(index)] = {
+        attrs: current
+      };
+      return result2;
+    },
+    {}
+  );
+  return {
+    metadata,
+    xml: result.xmlParts.join("")
+  };
+}
+var IGNORE_ATTRS = ["type", "children", "text"];
+function renderXmlNode(context, node) {
+  if (!node) {
+    return;
+  }
+  const base64Props = getPropsAsBase64(node, IGNORE_ATTRS);
+  let refKey = context.attributes.findIndex((x) => x === base64Props);
+  if (refKey == -1) {
+    context.attributes.push(base64Props);
+    refKey = context.attributes.length - 1;
+  }
+  context.xmlParts.push(`<${node.type} ${REF_ATTRIBUTE_NAME}="${refKey}"`);
+  const metaAttrsString = getNodeMetaAttributesString(node);
+  if (metaAttrsString) {
+    context.xmlParts.push(" " + metaAttrsString);
+  }
+  context.xmlParts.push(">");
+  if (isRichTextNodeType(node, "text")) {
+    context.xmlParts.push(node.text);
+  } else if (Array.isArray(node.children) && node.children.length) {
+    node.children.forEach((child) => {
+      renderXmlNode(context, child);
+    });
+  }
+  context.xmlParts.push(`</${node.type}>`);
+}
+var getPropsAsBase64 = (node, ignoreProps) => {
+  const props = {};
+  Object.keys(node).forEach((key) => {
+    if (!ignoreProps.includes(key)) {
+      props[key] = node[key];
+    }
+  });
+  return btoa(JSON.stringify(props));
+};
+var getNodeMetaAttributesString = (node) => {
+  const metadata = {};
+  if (isRichTextNodeType(node, "text")) {
+    const formatTags = getRichTextTagsFromTextFormat(node.format);
+    if (formatTags.length) {
+      metadata["format"] = formatTags.join(" ");
+    }
+  } else if (isRichTextNodeType(node, "heading")) {
+    if (node.tag) {
+      metadata["tag"] = node.tag;
+    }
+  } else if (isRichTextNodeType(node, "paragraph")) {
+    if (node.format) {
+      metadata["format"] = node.format;
+    }
+  } else if (isRichTextNodeType(node, "list")) {
+    if (node.tag) {
+      metadata["tag"] = node.tag;
+    }
+  } else if (isRichTextNodeType(node, "listitem")) {
+    metadata["value"] = String(node.value);
+  }
+  if (!Object.keys(metadata).length) {
+    return "";
+  }
+  const result = [];
+  Object.entries(metadata).forEach(([key, value]) => {
+    result.push(`${key}="${value}"`);
+  });
+  return result.join(" ");
+};
+
+// src/translationHelpers.ts
+import {
+  walkNodeTree
+} from "@uniformdev/canvas";
+import { isRichTextValueConsideredEmpty } from "@uniformdev/richtext";
+import { dequal } from "dequal/lite";
+
+// src/richText/parseTranslatableXml.ts
+import { isRichTextValue } from "@uniformdev/richtext";
+import { XMLParser } from "fast-xml-parser";
+var ATTR_NAME_PREFIX = "@_";
+var ATTRIBUTES_SUBNODE_NAME = ":@";
+var IGNORE_PROPS_PREFIX = [ATTR_NAME_PREFIX, ATTRIBUTES_SUBNODE_NAME, "#"];
+var parseTranslatableXml = ({ xml, metadata }) => {
+  const parser = new XMLParser({
+    ignoreDeclaration: true,
+    ignorePiTags: true,
+    ignoreAttributes: false,
+    preserveOrder: true,
+    trimValues: false,
+    attributeNamePrefix: ATTR_NAME_PREFIX
+  });
+  const rawObj = parser.parse(prepareXml(xml));
+  const result = processParseObject(rawObj, {
+    metadata,
+    nodeTypes: []
+  });
+  return result;
+};
+var prepareXml = (xml) => {
+  const result = xml.replaceAll("&lt;/text>", "</text>");
+  return result;
+};
+var processParseObject = (rawObj, context) => {
+  const result = visitAndTransformNode(rawObj, context);
+  const root = Array.isArray(result) ? result.at(0) : result;
+  if (root && root.type === "root") {
+    const value = { root };
+    if (isRichTextValue(value)) {
+      return value;
+    }
+  }
+  return null;
+};
+var visitAndTransformNode = (node, context) => {
+  if (Array.isArray(node)) {
+    return node.map((x) => visitAndTransformNode(x, context)).filter((node2) => !!node2);
+  } else if (typeof node === "object" && node !== null) {
+    const type = Object.keys(node).find(
+      (key) => !IGNORE_PROPS_PREFIX.some((prefix) => key.startsWith(prefix))
+    );
+    if (!type) {
+      return null;
+    }
+    const transformed = {};
+    transformed["type"] = type;
+    const propsFromRef = restorePropsFromRef(node, context);
+    Object.entries(propsFromRef).forEach(([key, value]) => {
+      transformed[key] = value;
+    });
+    if (type === "text") {
+      const nestedNode = node[type];
+      const nestedNodeAsArray = Array.isArray(nestedNode) ? nestedNode : [nestedNode];
+      const firstChild = nestedNodeAsArray.at(0);
+      const text = firstChild == null ? void 0 : firstChild["#text"];
+      transformed["text"] = typeof text === "string" && text ? text : "";
+    } else {
+      const children = [];
+      const nestedNode = node[type];
+      if (typeof nestedNode === "object" && nestedNode) {
+        const nestedNodeAsArray = Array.isArray(nestedNode) ? nestedNode : [nestedNode];
+        nestedNodeAsArray.forEach((currNode) => {
+          const transformed2 = visitAndTransformNode(currNode, context);
+          if (transformed2) {
+            children.push(transformed2);
+          }
+        });
+      }
+      if (children.length) {
+        transformed["children"] = children;
+      } else if (type === "paragraph" && Array.isArray(nestedNode) && !nestedNode.length) {
+        transformed["children"] = [];
+      }
+    }
+    return transformed;
+  } else {
+    return node;
+  }
+};
+var restorePropsFromRef = (node, context) => {
+  const result = {};
+  let uniformRef = node[ATTR_NAME_PREFIX + REF_ATTRIBUTE_NAME];
+  if (!uniformRef) {
+    const attrsSubNode = node[ATTRIBUTES_SUBNODE_NAME];
+    uniformRef = attrsSubNode == null ? void 0 : attrsSubNode[ATTR_NAME_PREFIX + REF_ATTRIBUTE_NAME];
+  }
+  if (typeof uniformRef === "string" && uniformRef && context.metadata[uniformRef]) {
+    const metadata = context.metadata[uniformRef];
+    if (metadata.attrs) {
+      const decodedProps = JSON.parse(atob(metadata.attrs));
+      Object.keys(decodedProps).forEach((key) => {
+        result[key] = decodedProps[key];
+      });
+    }
+  }
+  return result;
+};
+
+// src/richText/types.ts
+var isTranslatableRichTextValue = (value) => {
+  if (typeof value !== "object" || !value) {
+    return false;
+  }
+  if (!("xml" in value) || typeof value.xml !== "string") {
+    return false;
+  }
+  if (!("metadata" in value) || typeof value.metadata !== "object" || !value.metadata) {
+    return false;
+  }
+  return true;
+};
+
+// src/translationHelpers.ts
+var MERGE_TRANSLATION_ERRORS = {
+  unknown: "Unknown error",
+  "invalid-args": "Invalid arguments",
+  "project-id-mismatch": "Project ID mismatch",
+  "entity-id-mismatch": "Enity ID mismatch",
+  "entity-locales-mismatch": "Entity does not include required locales"
+};
+var createErrorResult = (errorKind) => {
+  return { updated: false, errorKind, errorText: MERGE_TRANSLATION_ERRORS[errorKind] };
+};
+var processComponentTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalNode,
+  translatedComponent
+}) => {
+  var _a, _b;
+  let updated = false;
+  if (!originalNode.type || !originalNode._id) {
+    return { updated };
+  }
+  const componentParameters = "parameters" in originalNode ? originalNode.parameters : void 0;
+  const entryFields = "fields" in originalNode ? originalNode.fields : void 0;
+  const originalParametersOrFields = componentParameters != null ? componentParameters : entryFields;
+  Object.entries((_a = translatedComponent.parameters) != null ? _a : {}).forEach(([paramKey, parameter]) => {
+    const originalParameter = originalParametersOrFields == null ? void 0 : originalParametersOrFields[paramKey];
+    if (!originalParameter) {
+      return;
+    }
+    const result = processParameterTranslation({
+      uniformSourceLocale,
+      uniformTargetLocale,
+      originalParameter,
+      parameter
+    });
+    if (result.updated) {
+      updated = true;
+    }
+  });
+  Object.entries((_b = translatedComponent._overrides) != null ? _b : {}).forEach(([overrideKey, override]) => {
+    var _a2;
+    const originalOverride = (_a2 = originalNode._overrides) == null ? void 0 : _a2[overrideKey];
+    if (!originalOverride) {
+      return;
+    }
+    const result = processOverrideTranslation({
+      uniformSourceLocale,
+      uniformTargetLocale,
+      originalOverride,
+      override
+    });
+    if (result.updated) {
+      updated = true;
+    }
+  });
+  return { updated };
+};
+var processParameterTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalParameter,
+  parameter
+}) => {
+  var _a, _b, _c, _d;
+  if (originalParameter.type !== parameter.type) {
+    return { updated: false };
+  }
+  if (!originalParameter.locales && originalParameter.value === void 0) {
+    return { updated: false };
+  }
+  const sourceValue = (_a = parameter.locales) == null ? void 0 : _a[TRANSLATION_PAYLOAD_SOURCE_KEY];
+  const targetValue = (_b = parameter.locales) == null ? void 0 : _b[TRANSLATION_PAYLOAD_TARGET_KEY];
+  const originalTargetValue = (_c = parameter.locales) == null ? void 0 : _c[TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY];
+  const originalParameterSource = originalParameter.locales ? originalParameter.locales[uniformSourceLocale] : originalParameter.value;
+  const isSourceValueUntouched = isSameParameterValue({
+    parameterType: originalParameter.type,
+    left: originalParameterSource,
+    right: sourceValue
+  });
+  const isTargetValueUntouched = isSameParameterValue({
+    parameterType: originalParameter.type,
+    left: (_d = originalParameter.locales) == null ? void 0 : _d[uniformTargetLocale],
+    right: originalTargetValue
+  });
+  if (targetValue !== void 0 && isSourceValueUntouched && isTargetValueUntouched) {
+    if (parameter.type == SUPPORTED_PARAM_TYPES.richText && isTranslatableRichTextValue(targetValue)) {
+      try {
+        const richTextValue = parseTranslatableXml(targetValue);
+        updateOriginalParameterValue(richTextValue);
+        return { updated: true };
+      } catch (e) {
+        return { updated: false };
+      }
+    } else if (parameter.type == SUPPORTED_PARAM_TYPES.text) {
+      updateOriginalParameterValue(targetValue);
+      return { updated: true };
+    }
+  }
+  function updateOriginalParameterValue(value) {
+    if (originalParameter.locales) {
+      originalParameter.locales[uniformTargetLocale] = value;
+    } else if (originalParameter.value !== void 0) {
+      originalParameter.locales = {
+        [uniformSourceLocale]: originalParameter.value,
+        [uniformTargetLocale]: value
+      };
+      originalParameter.value = void 0;
+    }
+  }
+  return { updated: false };
+};
+var processOverrideTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalOverride,
+  override
+}) => {
+  var _a, _b;
+  let updated = false;
+  Object.entries((_a = override.parameters) != null ? _a : {}).forEach(([paramKey, parameter]) => {
+    var _a2;
+    const originalParameter = (_a2 = originalOverride.parameters) == null ? void 0 : _a2[paramKey];
+    if (!originalParameter) {
+      return;
+    }
+    const result = processParameterTranslation({
+      uniformSourceLocale,
+      uniformTargetLocale,
+      originalParameter,
+      parameter
+    });
+    if (result.updated) {
+      updated = true;
+    }
+  });
+  Object.entries((_b = override.slots) != null ? _b : {}).forEach(([slotKey, slotComponents]) => {
+    var _a2;
+    const originalSlotComponents = (_a2 = originalOverride.slots) == null ? void 0 : _a2[slotKey];
+    if (!(originalSlotComponents == null ? void 0 : originalSlotComponents.length)) {
+      return;
+    }
+    slotComponents.forEach((slotComponent) => {
+      if (!slotComponent.type || !slotComponent._id) {
+        return;
+      }
+      const originalSlotComponent = originalSlotComponents.find(
+        (x) => x._id === slotComponent._id && x.type === slotComponent.type
+      );
+      if (!originalSlotComponent) {
+        return;
+      }
+      walkNodeTree(slotComponent, ({ node: component, type, actions }) => {
+        if (type !== "component" || !component._id || !component.type) {
+          actions.stopProcessingDescendants();
+          return;
+        }
+        const originalComponent = findComponentInNodeTree(originalSlotComponent, component._id);
+        if (!originalComponent || originalComponent.type !== component.type) {
+          actions.stopProcessingDescendants();
+          return;
+        }
+        const { updated: isComponentUpdated } = processComponentTranslation({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          originalNode: originalComponent,
+          translatedComponent: component
+        });
+        if (isComponentUpdated) {
+          updated = true;
+        }
+      });
+    });
+  });
+  return { updated };
+};
+var isSameParameterValue = ({
+  parameterType,
+  left,
+  right
+}) => {
+  switch (parameterType) {
+    case SUPPORTED_PARAM_TYPES.text:
+      return left === right || !left && !right;
+      break;
+    case SUPPORTED_PARAM_TYPES.richText:
+      try {
+        if (isRichTextValueConsideredEmpty(left) && isRichTextValueConsideredEmpty(right)) {
+          return true;
+        }
+      } catch (e) {
+        return false;
+      }
+      return dequal(left, right);
+      break;
+    default:
+      return left === right;
+  }
+};
+var findComponentInNodeTree = (root, id) => {
+  let result;
+  walkNodeTree(root, ({ node, actions }) => {
+    if (node._id === id) {
+      result = node;
+      actions.stopProcessingDescendants();
+    }
+  });
+  return result;
+};
+
+// src/collectTranslationPayload.ts
+var MERGE_TRANSLATION_ERRORS2 = {
+  unknown: "Unknown error",
+  "invalid-args": "Invalid arguments",
+  "entity-source-locale-missing": "Entity does not include specified  Uniform source locale"
+};
+var createErrorResult2 = (errorKind) => {
+  return { errorKind, errorText: MERGE_TRANSLATION_ERRORS2[errorKind] };
+};
+var collectTranslationPayload = ({
+  uniformProjectId,
+  uniformSourceLocale,
+  uniformTargetLocale,
+  uniformReleaseId,
+  targetLang,
+  entity,
+  entityType
+}) => {
+  if (!uniformSourceLocale || !uniformTargetLocale || !targetLang || !entity) {
+    return createErrorResult2("invalid-args");
+  }
+  if (!entity._locales || !entity._locales.includes(uniformSourceLocale)) {
+    return createErrorResult2("entity-source-locale-missing");
+  }
+  const payload = {
+    schemaVersion: 1,
+    metadata: {
+      uniformProjectId,
+      uniformSourceLocale,
+      uniformTargetLocale,
+      uniformReleaseId,
+      targetLang,
+      entityType,
+      entity: {
+        id: entity._id,
+        slug: entity._slug || ""
+      }
+    },
+    components: {}
+  };
+  walkNodeTree2(entity, ({ node, actions }) => {
+    if (!node.type || !node._id) {
+      actions.stopProcessingDescendants();
+      return;
+    }
+    const { _id, type, parameters, _overrides } = collectFromNode({
+      uniformSourceLocale,
+      uniformTargetLocale,
+      node,
+      deep: false
+    });
+    if (parameters || _overrides) {
+      payload.components[node._id] = {
+        _id,
+        type,
+        parameters,
+        _overrides
+      };
+    }
+  });
+  return { payload };
+};
+var collectFromNode = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  node,
+  deep
+}) => {
+  var _a, _b, _c;
+  const collectedParameters = {};
+  const collectedSlots = {};
+  const collectedOverrides = {};
+  const componentParameters = "parameters" in node ? node.parameters : void 0;
+  const entryFields = "fields" in node ? node.fields : void 0;
+  Object.entries((_a = componentParameters != null ? componentParameters : entryFields) != null ? _a : {}).forEach(([paramKey, param]) => {
+    var _a2, _b2;
+    const sourceLocaleValue = (_a2 = param.locales) == null ? void 0 : _a2[uniformSourceLocale];
+    const targetLocaleValue = (_b2 = param.locales) == null ? void 0 : _b2[uniformTargetLocale];
+    if (!canTranslateParameterValue(param, sourceLocaleValue)) {
+      return;
+    }
+    if (!isTargetLocaleUntouched(param.type, sourceLocaleValue, targetLocaleValue)) {
+      return;
+    }
+    collectedParameters[paramKey] = {
+      type: param.type,
+      locales: {
+        [TRANSLATION_PAYLOAD_SOURCE_KEY]: sourceLocaleValue,
+        [TRANSLATION_PAYLOAD_TARGET_KEY]: preprocessTargetValue(param, sourceLocaleValue),
+        [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: targetLocaleValue
+      }
+    };
+  });
+  if (deep) {
+    Object.entries((_b = "slots" in node ? node.slots : null) != null ? _b : {}).forEach(([slotKey, slotComponents]) => {
+      slotComponents.map((slotComponent) => {
+        var _a2;
+        if (!slotComponent.type || !slotComponent._id) {
+          return;
+        }
+        const collectedNode = collectFromNode({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          node: slotComponent,
+          deep: true
+        });
+        const hasContent = collectedNode.parameters || collectedNode._overrides || collectedNode.slots;
+        if (hasContent) {
+          (_a2 = collectedSlots[slotKey]) != null ? _a2 : collectedSlots[slotKey] = [];
+          collectedSlots[slotKey].push(collectedNode);
+        }
+      });
+    });
+  }
+  Object.entries((_c = node._overrides) != null ? _c : {}).forEach(([overrideKey, override]) => {
+    var _a2, _b2;
+    Object.entries((_a2 = override.parameters) != null ? _a2 : {}).forEach(([paramKey, param]) => {
+      var _a3, _b3, _c2, _d, _e;
+      const sourceLocaleValue = (_a3 = param.locales) == null ? void 0 : _a3[uniformSourceLocale];
+      const targetLocaleValue = (_b3 = param.locales) == null ? void 0 : _b3[uniformTargetLocale];
+      if (!canTranslateParameterValue(param, sourceLocaleValue)) {
+        return;
+      }
+      if (!isTargetLocaleUntouched(param.type, sourceLocaleValue, targetLocaleValue)) {
+        return;
+      }
+      (_c2 = collectedOverrides[overrideKey]) != null ? _c2 : collectedOverrides[overrideKey] = {};
+      (_e = (_d = collectedOverrides[overrideKey]).parameters) != null ? _e : _d.parameters = {};
+      collectedOverrides[overrideKey].parameters[paramKey] = {
+        type: param.type,
+        locales: {
+          [TRANSLATION_PAYLOAD_SOURCE_KEY]: sourceLocaleValue,
+          [TRANSLATION_PAYLOAD_TARGET_KEY]: preprocessTargetValue(param, sourceLocaleValue),
+          [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: targetLocaleValue
+        }
+      };
+    });
+    Object.entries((_b2 = override.slots) != null ? _b2 : {}).forEach(([slotKey, slotComponents]) => {
+      slotComponents.map((slotComponent) => {
+        var _a3, _b3, _c2, _d, _e;
+        if (!slotComponent.type || !slotComponent._id) {
+          return;
+        }
+        const collectedNode = collectFromNode({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          node: slotComponent,
+          // keep tree structure for `Slot Sections`
+          // to store whole `override` content in scope of current component
+          deep: true
+        });
+        const hasContent = collectedNode.parameters || collectedNode._overrides || collectedNode.slots;
+        if (hasContent) {
+          (_a3 = collectedOverrides[overrideKey]) != null ? _a3 : collectedOverrides[overrideKey] = {};
+          (_c2 = (_b3 = collectedOverrides[overrideKey]).slots) != null ? _c2 : _b3.slots = {};
+          (_e = (_d = collectedOverrides[overrideKey].slots)[slotKey]) != null ? _e : _d[slotKey] = [];
+          collectedOverrides[overrideKey].slots[slotKey].push(collectedNode);
+        }
+      });
+    });
+  });
+  const hasParameters = Object.keys(collectedParameters).length > 0;
+  const hasSlots = Object.keys(collectedSlots).length > 0;
+  const hasOverrides = Object.keys(collectedOverrides).length > 0;
+  return {
+    _id: node._id,
+    type: node.type,
+    parameters: hasParameters ? collectedParameters : void 0,
+    slots: hasSlots ? collectedSlots : void 0,
+    _overrides: hasOverrides ? collectedOverrides : void 0
+  };
+};
+var canTranslateParameterValue = (parameter, value) => {
+  if (parameter.type === SUPPORTED_PARAM_TYPES.text) {
+    if (typeof value !== "string" || !value) {
+      return false;
+    }
+    if (value.trim().length === 0) {
+      return false;
+    }
+    const bindResult = bindVariables({
+      variables: {},
+      value,
+      handleBinding: () => ""
+    });
+    const valueWithoutVariables = bindResult.result;
+    if (!valueWithoutVariables || valueWithoutVariables.trim().length === 0) {
+      return false;
+    }
+    return true;
+  } else if (parameter.type === SUPPORTED_PARAM_TYPES.richText) {
+    return isRichTextValue2(value) && !isRichTextValueConsideredEmpty2(value);
+  }
+  return false;
+};
+var isTargetLocaleUntouched = (parameterType, sourceLocaleValue, targetLocaleValue) => {
+  if (targetLocaleValue === void 0 || targetLocaleValue === null) {
+    return true;
+  }
+  if (parameterType === SUPPORTED_PARAM_TYPES.text && !targetLocaleValue) {
+    return true;
+  }
+  if (parameterType === SUPPORTED_PARAM_TYPES.richText && isRichTextValueConsideredEmpty2(targetLocaleValue)) {
+    return true;
+  }
+  return isSameParameterValue({
+    parameterType,
+    left: sourceLocaleValue,
+    right: targetLocaleValue
+  });
+};
+var preprocessTargetValue = (parameter, value) => {
+  if (parameter.type === SUPPORTED_PARAM_TYPES.richText) {
+    try {
+      return isRichTextValue2(value) ? renderAsTranslatableXml(value.root) : value;
+    } catch (e) {
+      return value;
+    }
+  }
+  return value;
+};
+
+// src/getCompositionForTranslation.ts
+import { CANVAS_DRAFT_STATE } from "@uniformdev/canvas";
+var getCompositionForTranslation = async ({
+  canvasClient,
+  compositionId,
+  releaseId,
+  state = CANVAS_DRAFT_STATE
+}) => {
+  if (!compositionId) {
+    return void 0;
+  }
+  const composition = await canvasClient.getCompositionById({
+    compositionId,
+    releaseId: releaseId ? releaseId : void 0,
+    withComponentIDs: true,
+    skipDataResolution: true,
+    skipOverridesResolution: true,
+    skipPatternResolution: true,
+    state
+  });
+  return composition ? composition : void 0;
+};
+
+// src/getEntryForTranslation.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE2 } from "@uniformdev/canvas";
+var getEntryForTranslation = async ({
+  contentClient,
+  entryId,
+  releaseId,
+  pattern,
+  state = CANVAS_DRAFT_STATE2
+}) => {
+  if (!entryId) {
+    return void 0;
+  }
+  const entriesResponse = await contentClient.getEntries({
+    entryIDs: [entryId],
+    releaseId: releaseId ? releaseId : void 0,
+    limit: 1,
+    withComponentIDs: true,
+    skipDataResolution: true,
+    skipOverridesResolution: true,
+    skipPatternResolution: true,
+    pattern,
+    state
+  });
+  const entry = entriesResponse.entries.at(0);
+  return entry ? entry : void 0;
+};
+
+// src/mergeCompositionTranslationToUniform.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE4 } from "@uniformdev/canvas";
+
+// src/translateComposition.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE3, walkNodeTree as walkNodeTree3 } from "@uniformdev/canvas";
+import { produce } from "immer";
+var translateComposition = ({
+  composition,
+  translationPayload
+}) => {
+  var _a;
+  if (!composition || !composition.composition || !translationPayload) {
+    return createErrorResult("invalid-args");
+  }
+  if (composition.projectId !== translationPayload.metadata.uniformProjectId) {
+    return createErrorResult("project-id-mismatch");
+  }
+  if (composition.composition._id !== translationPayload.metadata.entity.id) {
+    return createErrorResult("entity-id-mismatch");
+  }
+  const uniformSourceLocale = translationPayload.metadata.uniformSourceLocale;
+  const uniformTargetLocale = translationPayload.metadata.uniformTargetLocale;
+  const compositionLocales = (_a = composition.composition._locales) != null ? _a : [];
+  if (compositionLocales.length > 0 && !compositionLocales.includes(uniformSourceLocale)) {
+    return createErrorResult("entity-locales-mismatch");
+  }
+  let updated = false;
+  const translatedComposition = produce(composition, (draft) => {
+    var _a2, _b, _c;
+    draft.state = CANVAS_DRAFT_STATE3;
+    if (!((_a2 = draft.composition._locales) == null ? void 0 : _a2.length)) {
+      (_c = (_b = draft.composition)._locales) != null ? _c : _b._locales = [];
+      draft.composition._locales.push(uniformSourceLocale);
+    }
+    if (!draft.composition._locales.includes(uniformTargetLocale)) {
+      draft.composition._locales.push(uniformTargetLocale);
+    }
+    walkNodeTree3(draft.composition, ({ node: component, type, actions }) => {
+      if (type !== "component") {
+        actions.stopProcessingDescendants();
+        return;
+      }
+      if (!component.type || !component._id) {
+        actions.stopProcessingDescendants();
+        return;
+      }
+      const translatedComponent = translationPayload.components[component._id];
+      if (!translatedComponent || component.type !== translatedComponent.type) {
+        return;
+      }
+      const { updated: isComponentUpdated } = processComponentTranslation({
+        uniformSourceLocale,
+        uniformTargetLocale,
+        originalNode: component,
+        translatedComponent
+      });
+      if (isComponentUpdated) {
+        updated = true;
+      }
+    });
+  });
+  return { result: translatedComposition, updated };
+};
+
+// src/mergeCompositionTranslationToUniform.ts
+var mergeCompositionTranslationToUniform = async ({
+  canvasClient,
+  translationPayload,
+  updateComposition = defaultUpdateComposition,
+  onNotFound,
+  onNotTranslatedResult
+}) => {
+  if (!translationPayload) {
+    return { translationMerged: false };
+  }
+  const entityType = translationPayload.metadata.entityType;
+  const entityId = translationPayload.metadata.entity.id;
+  if (entityType !== "composition" && entityType !== "componentPattern") {
+    return { translationMerged: false, entityId };
+  }
+  const composition = await getCurrentCompositionFromPayload({
+    canvasClient,
+    translationPayload
+  });
+  if (!composition) {
+    await (onNotFound == null ? void 0 : onNotFound({
+      translationPayload
+    }));
+    return { translationMerged: false, entityId };
+  }
+  const translationResult = translateComposition({
+    composition,
+    translationPayload
+  });
+  const { updated, errorKind, errorText, result: translatedComposition } = translationResult;
+  if (translatedComposition && updated && !errorKind) {
+    const translationMerged = await updateComposition({
+      canvasClient,
+      translationPayload,
+      composition: translatedComposition
+    });
+    return { translationMerged, entityId };
+  } else {
+    await (onNotTranslatedResult == null ? void 0 : onNotTranslatedResult({ updated, errorKind, errorText }));
+    return { translationMerged: false, entityId };
+  }
+};
+var getCurrentCompositionFromPayload = async ({
+  canvasClient,
+  translationPayload
+}) => {
+  const compositionId = translationPayload.metadata.entity.id;
+  const releaseId = translationPayload.metadata.uniformReleaseId;
+  const currentComposition = await getCompositionForTranslation({
+    canvasClient,
+    compositionId,
+    releaseId,
+    state: CANVAS_DRAFT_STATE4
+  });
+  return currentComposition;
+};
+var defaultUpdateComposition = async ({
+  canvasClient,
+  composition
+}) => {
+  await canvasClient.updateComposition(composition);
+  return true;
+};
+
+// src/mergeEntryTranslationToUniform.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE6 } from "@uniformdev/canvas";
+
+// src/translateEntry.ts
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE5, walkNodeTree as walkNodeTree4 } from "@uniformdev/canvas";
+import { produce as produce2 } from "immer";
+var translateEntry = ({
+  entry,
+  translationPayload
+}) => {
+  var _a;
+  if (!entry || !translationPayload) {
+    return createErrorResult("invalid-args");
+  }
+  if (entry.projectId !== translationPayload.metadata.uniformProjectId) {
+    return createErrorResult("project-id-mismatch");
+  }
+  if ((entry == null ? void 0 : entry.entry._id) !== translationPayload.metadata.entity.id) {
+    return createErrorResult("entity-id-mismatch");
+  }
+  const entryLocales = (_a = entry.entry._locales) != null ? _a : [];
+  const uniformSourceLocale = translationPayload.metadata.uniformSourceLocale;
+  const uniformTargetLocale = translationPayload.metadata.uniformTargetLocale;
+  if (!entryLocales.includes(uniformSourceLocale)) {
+    return createErrorResult("entity-locales-mismatch");
+  }
+  let updated = false;
+  const translatedEntry = produce2(entry, (draft) => {
+    var _a2, _b;
+    draft.state = CANVAS_DRAFT_STATE5;
+    if (!entryLocales.includes(uniformTargetLocale)) {
+      (_b = (_a2 = draft.entry)._locales) != null ? _b : _a2._locales = [];
+      draft.entry._locales.push(uniformTargetLocale);
+    }
+    walkNodeTree4(draft.entry, ({ node: component, type, actions }) => {
+      if (type !== "entry") {
+        actions.stopProcessingDescendants();
+        return;
+      }
+      if (!component.type || !component._id) {
+        actions.stopProcessingDescendants();
+        return;
+      }
+      const translatedComponent = translationPayload.components[component._id];
+      if (!translatedComponent || component.type !== translatedComponent.type) {
+        return;
+      }
+      const { updated: isComponentUpdated } = processComponentTranslation({
+        uniformSourceLocale,
+        uniformTargetLocale,
+        originalNode: component,
+        translatedComponent
+      });
+      if (isComponentUpdated) {
+        updated = true;
+      }
+    });
+  });
+  return { result: translatedEntry, updated };
+};
+
+// src/mergeEntryTranslationToUniform.ts
+var mergeEntryTranslationToUniform = async ({
+  contentClient,
+  translationPayload,
+  updateEntry = defaultUpdateEntry,
+  onNotFound,
+  onNotTranslatedResult
+}) => {
+  if (!translationPayload) {
+    return { translationMerged: false };
+  }
+  const entityType = translationPayload.metadata.entityType;
+  const entityId = translationPayload.metadata.entity.id;
+  if (entityType !== "entry" && entityType !== "entryPattern") {
+    return { translationMerged: false, entityId };
+  }
+  const entry = await getCurrentEntryFromPayload({
+    contentClient,
+    translationPayload
+  });
+  if (!entry) {
+    await (onNotFound == null ? void 0 : onNotFound({
+      translationPayload
+    }));
+    return { translationMerged: false, entityId };
+  }
+  const translationResult = translateEntry({
+    entry,
+    translationPayload
+  });
+  const { updated, errorKind, errorText, result: translatedEntry } = translationResult;
+  if (translatedEntry && updated && !errorKind) {
+    const translationMerged = await updateEntry({
+      contentClient,
+      translationPayload,
+      entry: translatedEntry
+    });
+    return { translationMerged, entityId };
+  } else {
+    await (onNotTranslatedResult == null ? void 0 : onNotTranslatedResult({ updated, errorKind, errorText }));
+    return { translationMerged: false, entityId };
+  }
+};
+var getCurrentEntryFromPayload = async ({
+  contentClient,
+  translationPayload
+}) => {
+  const entityType = translationPayload.metadata.entityType;
+  const entryId = translationPayload.metadata.entity.id;
+  const releaseId = translationPayload.metadata.uniformReleaseId;
+  const currentEntry = await getEntryForTranslation({
+    contentClient,
+    entryId,
+    releaseId,
+    pattern: entityType === "entryPattern",
+    state: CANVAS_DRAFT_STATE6
+  });
+  return currentEntry;
+};
+var defaultUpdateEntry = async ({
+  contentClient,
+  entry
+}) => {
+  await contentClient.upsertEntry(entry);
+  return true;
+};
+
+// src/mergeTranslationToUniform.ts
+var mergeTranslationToUniform = async ({
+  canvasClient,
+  contentClient,
+  translationPayload,
+  updateComposition,
+  updateEntry,
+  onNotFound,
+  onNotTranslatedResult
+}) => {
+  if (!translationPayload) {
+    return { translationMerged: false };
+  }
+  const entityType = translationPayload.metadata.entityType;
+  const entityId = translationPayload.metadata.entity.id;
+  if (entityType === "composition" || entityType === "componentPattern") {
+    return await mergeCompositionTranslationToUniform({
+      canvasClient,
+      translationPayload,
+      updateComposition,
+      onNotFound,
+      onNotTranslatedResult
+    });
+  } else if (entityType === "entry" || entityType === "entryPattern") {
+    return await mergeEntryTranslationToUniform({
+      contentClient,
+      translationPayload,
+      updateEntry,
+      onNotFound,
+      onNotTranslatedResult
+    });
+  }
+  return { translationMerged: false, entityId };
+};
+export {
+  collectTranslationPayload,
+  getCompositionForTranslation,
+  getEntryForTranslation,
+  mergeCompositionTranslationToUniform,
+  mergeEntryTranslationToUniform,
+  mergeTranslationToUniform,
+  translateComposition,
+  translateEntry
+};