@uniformdev/tms-sdk 19.153.1-alpha.1

package/dist/index.js

@@ -0,0 +1,594 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  collectTranslationPayload: () => collectTranslationPayload,
+  mergeCompositionTranslationToUniform: () => mergeCompositionTranslationToUniform,
+  mergeEntryTranslationToUniform: () => mergeEntryTranslationToUniform,
+  translateComposition: () => translateComposition,
+  translateEntry: () => translateEntry
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/collectTranslationPayload.ts
+var import_canvas = require("@uniformdev/canvas");
+
+// src/constants.ts
+var TRANSLATION_PAYLOAD_SOURCE_KEY = "source";
+var TRANSLATION_PAYLOAD_TARGET_KEY = "target";
+var TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY = "originalTarget";
+
+// src/collectTranslationPayload.ts
+var MERGE_TRANSLATION_ERRORS = {
+  unknown: "Unknown error",
+  "invalid-args": "Invalid arguments",
+  "entity-source-locale-missing": "Entity does not include specified  Uniform source locale"
+};
+var createErrorResult = (errorKind) => {
+  return { errorKind, errorText: MERGE_TRANSLATION_ERRORS[errorKind] };
+};
+var collectTranslationPayload = ({
+  uniformProjectId,
+  uniformSourceLocale,
+  uniformTargetLocale,
+  uniformReleaseId,
+  targetLang,
+  entity,
+  entityType,
+  overrideModifiedTargetLocale
+}) => {
+  if (!uniformSourceLocale || !uniformTargetLocale || !targetLang || !entity) {
+    return createErrorResult("invalid-args");
+  }
+  if (!entity._locales || !entity._locales.includes(uniformSourceLocale)) {
+    return createErrorResult("entity-source-locale-missing");
+  }
+  const payload = {
+    schemaVersion: 1,
+    metadata: {
+      uniformProjectId,
+      uniformSourceLocale,
+      uniformTargetLocale,
+      uniformReleaseId,
+      targetLang,
+      entityType,
+      entity: {
+        id: entity._id,
+        slug: entity._slug || ""
+      },
+      overrideModifiedTargetLocale
+    },
+    components: {}
+  };
+  (0, import_canvas.walkNodeTree)(entity, ({ node: component, type, actions }) => {
+    var _a;
+    if (!component.type || !component._id) {
+      actions.stopProcessingDescendants();
+      return;
+    }
+    const parameters = {};
+    const overrides = {};
+    const parametersOrFields = type == "component" ? component.parameters : component.fields;
+    Object.entries(parametersOrFields != null ? parametersOrFields : {}).forEach(([paramKey, param]) => {
+      var _a2, _b;
+      const sourceLocaleValue = (_a2 = param.locales) == null ? void 0 : _a2[uniformSourceLocale];
+      const targetLocaleValue = (_b = param.locales) == null ? void 0 : _b[uniformTargetLocale];
+      if (!canTranslateParameterValue(param, sourceLocaleValue)) {
+        return;
+      }
+      if (!overrideModifiedTargetLocale && !isTargetLocaleUntouched(sourceLocaleValue, targetLocaleValue)) {
+        return;
+      }
+      parameters[paramKey] = {
+        type: param.type,
+        locales: {
+          [TRANSLATION_PAYLOAD_SOURCE_KEY]: sourceLocaleValue,
+          [TRANSLATION_PAYLOAD_TARGET_KEY]: sourceLocaleValue,
+          [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: targetLocaleValue
+        }
+      };
+    });
+    Object.entries((_a = component._overrides) != null ? _a : {}).forEach(([componentId, override]) => {
+      var _a2;
+      Object.entries((_a2 = override.parameters) != null ? _a2 : {}).forEach(([paramKey, param]) => {
+        var _a3, _b, _c, _d, _e;
+        const sourceLocaleValue = (_a3 = param.locales) == null ? void 0 : _a3[uniformSourceLocale];
+        const targetLocaleValue = (_b = param.locales) == null ? void 0 : _b[uniformTargetLocale];
+        if (!canTranslateParameterValue(param, sourceLocaleValue)) {
+          return;
+        }
+        if (!overrideModifiedTargetLocale && !isTargetLocaleUntouched(sourceLocaleValue, targetLocaleValue)) {
+          return;
+        }
+        (_c = overrides[componentId]) != null ? _c : overrides[componentId] = {};
+        (_e = (_d = overrides[componentId]).parameters) != null ? _e : _d.parameters = {};
+        overrides[componentId].parameters[paramKey] = {
+          type: param.type,
+          locales: {
+            [TRANSLATION_PAYLOAD_SOURCE_KEY]: sourceLocaleValue,
+            [TRANSLATION_PAYLOAD_TARGET_KEY]: sourceLocaleValue,
+            [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: targetLocaleValue
+          }
+        };
+      });
+    });
+    const hasParameters = Object.keys(parameters).length > 0;
+    const hasOverrides = Object.keys(overrides).length > 0;
+    if (hasParameters || hasOverrides) {
+      payload.components[component._id] = {
+        type: component.type,
+        parameters: hasParameters ? parameters : void 0,
+        _overrides: hasOverrides ? overrides : void 0
+      };
+    }
+  });
+  return { payload };
+};
+var canTranslateParameterValue = (parameter, value) => {
+  if (parameter.type === "text") {
+    if (typeof value !== "string" || !value) {
+      return false;
+    }
+    if (value.trim().length === 0) {
+      return false;
+    }
+    const bindResult = (0, import_canvas.bindVariables)({
+      variables: {},
+      value,
+      handleBinding: () => ""
+    });
+    const valueWithoutVariables = bindResult.result;
+    if (!valueWithoutVariables || valueWithoutVariables.trim().length === 0) {
+      return false;
+    }
+    return true;
+  } else if (parameter.type === "richText") {
+    return typeof value === "object" && !!value;
+  }
+  return false;
+};
+var isTargetLocaleUntouched = (sourceLocaleValue, targetLocaleValue) => {
+  return targetLocaleValue === void 0 || targetLocaleValue === null || targetLocaleValue === "" || targetLocaleValue === sourceLocaleValue;
+};
+
+// src/mergeCompositionTranslationToUniform.ts
+var import_canvas3 = require("@uniformdev/canvas");
+
+// src/translateComposition.ts
+var import_canvas2 = require("@uniformdev/canvas");
+var import_immer = require("immer");
+
+// src/translationHelpers.ts
+var import_lite = require("dequal/lite");
+var MERGE_TRANSLATION_ERRORS2 = {
+  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 createErrorResult2 = (errorKind) => {
+  return { updated: false, errorKind, errorText: MERGE_TRANSLATION_ERRORS2[errorKind] };
+};
+var processParameterTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalParameter,
+  parameter,
+  overrideModifiedTargetLocale
+}) => {
+  var _a, _b, _c;
+  if (!originalParameter.locales) {
+    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 isSourceValueUntouched = isSameParameterValue({
+    parameterType: originalParameter.type,
+    originalValue: originalParameter.locales[uniformSourceLocale],
+    value: sourceValue
+  });
+  const isTargetValueUntouched = overrideModifiedTargetLocale || isSameParameterValue({
+    parameterType: originalParameter.type,
+    originalValue: originalParameter.locales[uniformTargetLocale],
+    value: originalTargetValue
+  });
+  if (targetValue && isSourceValueUntouched && isTargetValueUntouched) {
+    originalParameter.locales[uniformTargetLocale] = targetValue;
+    return { updated: true };
+  }
+  return { updated: false };
+};
+var processOverrideTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalOverride,
+  override,
+  overrideModifiedTargetLocale
+}) => {
+  var _a;
+  let updated = false;
+  Object.entries((_a = override.parameters) != null ? _a : {}).forEach(([paramKey, parameter]) => {
+    var _a2, _b, _c, _d;
+    const originalParameter = (_a2 = originalOverride.parameters) == null ? void 0 : _a2[paramKey];
+    if (!originalParameter || !originalParameter.locales) {
+      return;
+    }
+    const sourceValue = (_b = parameter.locales) == null ? void 0 : _b[TRANSLATION_PAYLOAD_SOURCE_KEY];
+    const targetValue = (_c = parameter.locales) == null ? void 0 : _c[TRANSLATION_PAYLOAD_TARGET_KEY];
+    const originalTargetValue = (_d = parameter.locales) == null ? void 0 : _d[TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY];
+    const isSourceValueUntouched = isSameParameterValue({
+      parameterType: originalParameter.type,
+      originalValue: originalParameter.locales[uniformSourceLocale],
+      value: sourceValue
+    });
+    const isTargetValueUntouched = overrideModifiedTargetLocale || isSameParameterValue({
+      parameterType: originalParameter.type,
+      originalValue: originalParameter.locales[uniformTargetLocale],
+      value: originalTargetValue
+    });
+    if (targetValue && isSourceValueUntouched && isTargetValueUntouched) {
+      originalParameter.locales[uniformTargetLocale] = targetValue;
+      updated = true;
+    }
+  });
+  return { updated };
+};
+var isSameParameterValue = ({
+  parameterType,
+  originalValue,
+  value
+}) => {
+  switch (parameterType) {
+    case "text":
+      return originalValue === value || !originalValue && !value;
+      break;
+    case "richText":
+      return (0, import_lite.dequal)(originalValue, value);
+      break;
+    default:
+      return originalValue === value;
+  }
+};
+
+// src/translateComposition.ts
+var translateComposition = ({
+  composition,
+  translationPayload,
+  overrideModifiedTargetLocale
+}) => {
+  var _a;
+  if (!composition || !composition.composition || !translationPayload) {
+    return createErrorResult2("invalid-args");
+  }
+  if (composition.projectId !== translationPayload.metadata.uniformProjectId) {
+    return createErrorResult2("project-id-mismatch");
+  }
+  if (composition.composition._id !== translationPayload.metadata.entity.id) {
+    return createErrorResult2("entity-id-mismatch");
+  }
+  const compositionLocales = (_a = composition.composition._locales) != null ? _a : [];
+  const uniformSourceLocale = translationPayload.metadata.uniformSourceLocale;
+  const uniformTargetLocale = translationPayload.metadata.uniformTargetLocale;
+  if (!compositionLocales.includes(uniformSourceLocale)) {
+    return createErrorResult2("entity-locales-mismatch");
+  }
+  let updated = false;
+  const translatedComposition = (0, import_immer.produce)(composition, (draft) => {
+    var _a2, _b;
+    draft.state = import_canvas2.CANVAS_DRAFT_STATE;
+    if (!compositionLocales.includes(uniformTargetLocale)) {
+      (_b = (_a2 = draft.composition)._locales) != null ? _b : _a2._locales = [];
+      draft.composition._locales.push(uniformTargetLocale);
+    }
+    (0, import_canvas2.walkNodeTree)(draft.composition, ({ node: component, type, actions }) => {
+      var _a3, _b2;
+      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;
+      }
+      Object.entries((_a3 = translatedComponent.parameters) != null ? _a3 : {}).forEach(([paramKey, param]) => {
+        var _a4;
+        const originalParameter = (_a4 = component.parameters) == null ? void 0 : _a4[paramKey];
+        if (!originalParameter) {
+          return;
+        }
+        const result = processParameterTranslation({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          originalParameter,
+          parameter: param,
+          overrideModifiedTargetLocale: overrideModifiedTargetLocale != null ? overrideModifiedTargetLocale : false
+        });
+        if (result.updated) {
+          updated = true;
+        }
+      });
+      Object.entries((_b2 = translatedComponent._overrides) != null ? _b2 : {}).forEach(([componentId, override]) => {
+        var _a4;
+        const originalOverride = (_a4 = component._overrides) == null ? void 0 : _a4[componentId];
+        if (!originalOverride) {
+          return;
+        }
+        const result = processOverrideTranslation({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          originalOverride,
+          override,
+          overrideModifiedTargetLocale
+        });
+        if (result.updated) {
+          updated = true;
+        }
+      });
+    });
+  });
+  return { result: translatedComposition, updated };
+};
+
+// src/mergeCompositionTranslationToUniform.ts
+var mergeCompositionTranslationToUniform = async ({
+  canvasClient,
+  translationPayload,
+  getCurrentComposition = defaultGetCurrentComposition,
+  onMissingComposition,
+  onCompositionTranslationResult,
+  updateComposition = defaultUpdateComposition
+}) => {
+  if (!translationPayload) {
+    return { translationMerged: false };
+  }
+  const entityId = translationPayload.metadata.entity.id;
+  const overrideModifiedTargetLocale = translationPayload.metadata.overrideModifiedTargetLocale;
+  if ((translationPayload == null ? void 0 : translationPayload.metadata.entityType) !== "composition") {
+    return { translationMerged: false, entityId };
+  }
+  const composition = await getCurrentComposition({
+    canvasClient,
+    translationPayload
+  });
+  if (!composition) {
+    await (onMissingComposition == null ? void 0 : onMissingComposition({
+      translationPayload
+    }));
+    return { translationMerged: false, entityId };
+  }
+  let translationResult = translateComposition({
+    composition,
+    translationPayload,
+    overrideModifiedTargetLocale
+  });
+  if (onCompositionTranslationResult) {
+    translationResult = await onCompositionTranslationResult(translationResult);
+  }
+  const { updated, errorKind, result: translatedComposition } = translationResult;
+  if (translatedComposition && updated && !errorKind) {
+    const translationMerged = await updateComposition({
+      canvasClient,
+      translationPayload,
+      composition: translatedComposition
+    });
+    return { translationMerged, entityId };
+  }
+  return { translationMerged: false, entityId };
+};
+var defaultGetCurrentComposition = async ({
+  canvasClient,
+  translationPayload
+}) => {
+  const compositionId = translationPayload.metadata.entity.id;
+  const releaseId = translationPayload.metadata.uniformReleaseId;
+  const currentComposition = await canvasClient.getCompositionById({
+    compositionId,
+    releaseId: releaseId ? releaseId : void 0,
+    withComponentIDs: true,
+    skipDataResolution: true,
+    skipOverridesResolution: true,
+    skipPatternResolution: true,
+    state: import_canvas3.CANVAS_DRAFT_STATE
+  });
+  return currentComposition;
+};
+var defaultUpdateComposition = async ({
+  canvasClient,
+  composition
+}) => {
+  await canvasClient.updateComposition(composition);
+  return true;
+};
+
+// src/mergeEntryTranslationToUniform.ts
+var import_canvas5 = require("@uniformdev/canvas");
+
+// src/translateEntry.ts
+var import_canvas4 = require("@uniformdev/canvas");
+var import_immer2 = require("immer");
+var translateEntry = ({
+  entry,
+  translationPayload,
+  overrideModifiedTargetLocale
+}) => {
+  var _a;
+  if (!entry || !translationPayload) {
+    return createErrorResult2("invalid-args");
+  }
+  if (entry.projectId !== translationPayload.metadata.uniformProjectId) {
+    return createErrorResult2("project-id-mismatch");
+  }
+  if ((entry == null ? void 0 : entry.entry._id) !== translationPayload.metadata.entity.id) {
+    return createErrorResult2("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 createErrorResult2("entity-locales-mismatch");
+  }
+  let updated = false;
+  const translatedEntry = (0, import_immer2.produce)(entry, (draft) => {
+    var _a2, _b;
+    draft.state = import_canvas4.CANVAS_DRAFT_STATE;
+    if (!entryLocales.includes(uniformTargetLocale)) {
+      (_b = (_a2 = draft.entry)._locales) != null ? _b : _a2._locales = [];
+      draft.entry._locales.push(uniformTargetLocale);
+    }
+    (0, import_canvas4.walkNodeTree)(draft.entry, ({ node: component, type, actions }) => {
+      var _a3, _b2;
+      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;
+      }
+      Object.entries((_a3 = translatedComponent.parameters) != null ? _a3 : {}).forEach(([paramKey, parameter]) => {
+        var _a4;
+        const originalParameter = (_a4 = component.fields) == null ? void 0 : _a4[paramKey];
+        if (!originalParameter) {
+          return;
+        }
+        const result = processParameterTranslation({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          originalParameter,
+          parameter,
+          overrideModifiedTargetLocale
+        });
+        if (result.updated) {
+          updated = true;
+        }
+      });
+      Object.entries((_b2 = translatedComponent._overrides) != null ? _b2 : {}).forEach(([componentId, override]) => {
+        var _a4;
+        const originalOverride = (_a4 = component._overrides) == null ? void 0 : _a4[componentId];
+        if (!originalOverride) {
+          return;
+        }
+        const result = processOverrideTranslation({
+          uniformSourceLocale,
+          uniformTargetLocale,
+          originalOverride,
+          override,
+          overrideModifiedTargetLocale
+        });
+        if (result.updated) {
+          updated = true;
+        }
+      });
+    });
+  });
+  return { result: translatedEntry, updated };
+};
+
+// src/mergeEntryTranslationToUniform.ts
+var mergeEntryTranslationToUniform = async ({
+  contentClient,
+  translationPayload,
+  getCurrentEntry = defaultGetCurrentEntry,
+  onMissingEntry,
+  onEntryTranslationResult,
+  updateEntry = defaultUpdateEntry
+}) => {
+  if (!translationPayload) {
+    return { translationMerged: false };
+  }
+  const entityId = translationPayload.metadata.entity.id;
+  const overrideModifiedTargetLocale = translationPayload.metadata.overrideModifiedTargetLocale;
+  if ((translationPayload == null ? void 0 : translationPayload.metadata.entityType) !== "entry") {
+    return { translationMerged: false, entityId };
+  }
+  const entry = await getCurrentEntry({
+    contentClient,
+    translationPayload
+  });
+  if (!entry) {
+    await (onMissingEntry == null ? void 0 : onMissingEntry({
+      translationPayload
+    }));
+    return { translationMerged: false, entityId };
+  }
+  let translationResult = translateEntry({
+    entry,
+    translationPayload,
+    overrideModifiedTargetLocale
+  });
+  if (onEntryTranslationResult) {
+    translationResult = await onEntryTranslationResult(translationResult);
+  }
+  const { updated, errorKind, result: translatedEntry } = translationResult;
+  if (translatedEntry && updated && !errorKind) {
+    const translationMerged = await updateEntry({
+      contentClient,
+      translationPayload,
+      entry: translatedEntry
+    });
+    return { translationMerged, entityId };
+  }
+  return { translationMerged: false, entityId };
+};
+var defaultGetCurrentEntry = async ({
+  contentClient,
+  translationPayload
+}) => {
+  const entryId = translationPayload.metadata.entity.id;
+  const releaseId = translationPayload.metadata.uniformReleaseId;
+  const entriesResponse = await contentClient.getEntries({
+    entryIDs: [entryId],
+    releaseId: releaseId ? releaseId : void 0,
+    limit: 1,
+    withComponentIDs: true,
+    skipDataResolution: true,
+    skipOverridesResolution: true,
+    skipPatternResolution: true,
+    state: import_canvas5.CANVAS_DRAFT_STATE
+  });
+  const currentEntry = entriesResponse.entries.at(0);
+  return currentEntry ? currentEntry : void 0;
+};
+var defaultUpdateEntry = async ({
+  contentClient,
+  entry
+}) => {
+  await contentClient.upsertEntry(entry);
+  return true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectTranslationPayload,
+  mergeCompositionTranslationToUniform,
+  mergeEntryTranslationToUniform,
+  translateComposition,
+  translateEntry
+});