@uniformdev/tms-sdk 20.48.1-alpha.27 → 20.48.1-alpha.33.sha-eb3f272086

package/dist/index.js

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,11 +20,137 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports2, module2) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module2.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports2, module2) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module2.exports = pLimit2;
+  }
+});
+
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   collectTranslationPayload: () => collectTranslationPayload,
   getCompositionForTranslation: () => getCompositionForTranslation,
   getEntryForTranslation: () => getEntryForTranslation,
@@ -29,7 +160,7 @@ __export(src_exports, {
   translateComposition: () => translateComposition,
   translateEntry: () => translateEntry
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/collectTranslationPayload.ts
 var import_canvas2 = require("@uniformdev/canvas");
@@ -103,8 +234,23 @@ var getPropsAsBase64 = (node, ignoreProps) => {
       props[key] = node[key];
     }
   });
+  applyMissingSerializedDefaults(node.type, props);
   return btoa(JSON.stringify(props));
 };
+function applyMissingSerializedDefaults(nodeType, props) {
+  if (props.version === void 0) {
+    props.version = 1;
+  }
+  if ((nodeType === "text" || nodeType === "tab") && props.format === void 0) {
+    props.format = 0;
+  } else if (nodeType === "list" && props.start === void 0) {
+    props.start = 1;
+  } else if (nodeType === "listitem" && props.value === void 0) {
+    props.value = 1;
+  } else if (nodeType === "tablecell" && props.headerState === void 0) {
+    props.headerState = 0;
+  }
+}
 var getNodeMetaAttributesString = (node) => {
   const metadata = {};
   if ((0, import_richtext.isRichTextNodeType)(node, "text")) {
@@ -125,7 +271,10 @@ var getNodeMetaAttributesString = (node) => {
       metadata["tag"] = node.tag;
     }
   } else if ((0, import_richtext.isRichTextNodeType)(node, "listitem")) {
-    metadata["value"] = String(node.value);
+    const value = (0, import_richtext.getRichTextListItemValue)(node.value);
+    if (typeof value === "number") {
+      metadata["value"] = String(value);
+    }
   }
   if (!Object.keys(metadata).length) {
     return "";
@@ -315,6 +464,9 @@ var processComponentTranslation = ({
   });
   return { updated };
 };
+var isNestedParameterType = (type) => {
+  return type === import_canvas.CANVAS_BLOCK_PARAM_TYPE;
+};
 var processParameterTranslation = ({
   uniformSourceLocale,
   uniformTargetLocale,
@@ -325,6 +477,14 @@ var processParameterTranslation = ({
   if (originalParameter.type !== parameter.type) {
     return { updated: false };
   }
+  if (isNestedParameterType(originalParameter.type)) {
+    return processNestedParameterTranslation({
+      uniformSourceLocale,
+      uniformTargetLocale,
+      originalParameter,
+      parameter
+    });
+  }
   if (!originalParameter.locales && originalParameter.value === void 0) {
     return { updated: false };
   }
@@ -337,7 +497,7 @@ var processParameterTranslation = ({
     left: originalParameterSource,
     right: sourceValue
   });
-  const isTargetValueUntouched = isSameParameterValue({
+  const isTargetValueUntouched = originalTargetValue === void 0 ? true : isSameParameterValue({
     parameterType: originalParameter.type,
     left: (_d = originalParameter.locales) == null ? void 0 : _d[uniformTargetLocale],
     right: originalTargetValue
@@ -369,6 +529,39 @@ var processParameterTranslation = ({
   }
   return { updated: false };
 };
+var processNestedParameterTranslation = ({
+  uniformSourceLocale,
+  uniformTargetLocale,
+  originalParameter,
+  parameter
+}) => {
+  let updated = false;
+  if (originalParameter.type == import_canvas.CANVAS_BLOCK_PARAM_TYPE && Array.isArray(originalParameter.value) && Array.isArray(parameter.value)) {
+    const originalValue = originalParameter.value;
+    const translatedValue = parameter.value;
+    for (const translatedBlock of translatedValue) {
+      if (!translatedBlock._id || !translatedBlock.type) {
+        continue;
+      }
+      const originalBlock = originalValue.find(
+        (b) => b._id === translatedBlock._id && b.type === translatedBlock.type
+      );
+      if (!originalBlock) {
+        continue;
+      }
+      const { updated: blockUpdated } = processComponentTranslation({
+        uniformSourceLocale,
+        uniformTargetLocale,
+        originalNode: originalBlock,
+        translatedComponent: translatedBlock
+      });
+      if (blockUpdated) {
+        updated = true;
+      }
+    }
+  }
+  return { updated };
+};
 var processOverrideTranslation = ({
   uniformSourceLocale,
   uniformTargetLocale,
@@ -481,7 +674,8 @@ var collectTranslationPayload = ({
   uniformReleaseId,
   targetLang,
   entity,
-  entityType
+  entityType,
+  config = {}
 }) => {
   if (!uniformSourceLocale || !uniformTargetLocale || !targetLang || !entity) {
     return createErrorResult2("invalid-args");
@@ -505,16 +699,22 @@ var collectTranslationPayload = ({
     },
     components: {}
   };
-  (0, import_canvas2.walkNodeTree)(entity, ({ node, actions }) => {
+  (0, import_canvas2.walkNodeTree)(entity, ({ node, actions, ancestorsAndSelf }) => {
+    var _a;
     if (!node.type || !node._id) {
       actions.stopProcessingDescendants();
       return;
     }
+    if (((_a = ancestorsAndSelf.at(0)) == null ? void 0 : _a.type) === "block") {
+      actions.stopProcessingDescendants();
+      return;
+    }
     const { _id, type, parameters, _overrides } = collectFromNode({
       uniformSourceLocale,
       uniformTargetLocale,
       node,
-      deep: false
+      deep: false,
+      config
     });
     if (parameters || _overrides) {
       payload.components[node._id] = {
@@ -531,7 +731,8 @@ var collectFromNode = ({
   uniformSourceLocale,
   uniformTargetLocale,
   node,
-  deep
+  deep,
+  config
 }) => {
   var _a, _b, _c;
   const collectedParameters = {};
@@ -541,12 +742,24 @@ var collectFromNode = ({
   const entryFields = "fields" in node ? node.fields : void 0;
   Object.entries((_a = componentParameters != null ? componentParameters : entryFields) != null ? _a : {}).forEach(([paramKey, param]) => {
     var _a2, _b2;
+    if (isNestedParameterType(param.type)) {
+      const nestedParam = collectNestedParameter({
+        param,
+        uniformSourceLocale,
+        uniformTargetLocale,
+        config
+      });
+      if (nestedParam) {
+        collectedParameters[paramKey] = nestedParam;
+      }
+      return;
+    }
     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)) {
+    if (!config.ignoreTargetLocaleValueMismatch && !isTargetLocaleUntouched(param.type, sourceLocaleValue, targetLocaleValue)) {
       return;
     }
     collectedParameters[paramKey] = {
@@ -554,7 +767,7 @@ var collectFromNode = ({
       locales: {
         [TRANSLATION_PAYLOAD_SOURCE_KEY]: sourceLocaleValue,
         [TRANSLATION_PAYLOAD_TARGET_KEY]: preprocessTargetValue(param, sourceLocaleValue),
-        [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: targetLocaleValue
+        [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: !config.ignoreTargetLocaleValueMismatch ? targetLocaleValue : void 0
       }
     };
   });
@@ -569,7 +782,8 @@ var collectFromNode = ({
           uniformSourceLocale,
           uniformTargetLocale,
           node: slotComponent,
-          deep: true
+          deep: true,
+          config
         });
         const hasContent = collectedNode.parameters || collectedNode._overrides || collectedNode.slots;
         if (hasContent) {
@@ -582,23 +796,37 @@ var collectFromNode = ({
   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];
+      var _a3, _b3, _c2, _d, _e, _f, _g, _h;
+      if (isNestedParameterType(param.type)) {
+        const nestedParam = collectNestedParameter({
+          param,
+          uniformSourceLocale,
+          uniformTargetLocale,
+          config
+        });
+        if (nestedParam) {
+          (_a3 = collectedOverrides[overrideKey]) != null ? _a3 : collectedOverrides[overrideKey] = {};
+          (_c2 = (_b3 = collectedOverrides[overrideKey]).parameters) != null ? _c2 : _b3.parameters = {};
+          collectedOverrides[overrideKey].parameters[paramKey] = nestedParam;
+        }
+        return;
+      }
+      const sourceLocaleValue = (_d = param.locales) == null ? void 0 : _d[uniformSourceLocale];
+      const targetLocaleValue = (_e = param.locales) == null ? void 0 : _e[uniformTargetLocale];
       if (!canTranslateParameterValue(param, sourceLocaleValue)) {
         return;
       }
-      if (!isTargetLocaleUntouched(param.type, sourceLocaleValue, targetLocaleValue)) {
+      if (!config.ignoreTargetLocaleValueMismatch && !isTargetLocaleUntouched(param.type, sourceLocaleValue, targetLocaleValue)) {
         return;
       }
-      (_c2 = collectedOverrides[overrideKey]) != null ? _c2 : collectedOverrides[overrideKey] = {};
-      (_e = (_d = collectedOverrides[overrideKey]).parameters) != null ? _e : _d.parameters = {};
+      (_f = collectedOverrides[overrideKey]) != null ? _f : collectedOverrides[overrideKey] = {};
+      (_h = (_g = collectedOverrides[overrideKey]).parameters) != null ? _h : _g.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
+          [TRANSLATION_PAYLOAD_ORIGINAL_TARGET_KEY]: !config.ignoreTargetLocaleValueMismatch ? targetLocaleValue : void 0
         }
       };
     });
@@ -614,7 +842,8 @@ var collectFromNode = ({
           node: slotComponent,
           // keep tree structure for `Slot Sections`
           // to store whole `override` content in scope of current component
-          deep: true
+          deep: true,
+          config
         });
         const hasContent = collectedNode.parameters || collectedNode._overrides || collectedNode.slots;
         if (hasContent) {
@@ -637,6 +866,42 @@ var collectFromNode = ({
     _overrides: hasOverrides ? collectedOverrides : void 0
   };
 };
+var collectNestedParameter = ({
+  param,
+  uniformSourceLocale,
+  uniformTargetLocale,
+  config
+}) => {
+  if (param.type === import_canvas2.CANVAS_BLOCK_PARAM_TYPE && Array.isArray(param.value)) {
+    const blockValue = param.value;
+    const collectedBlocks = [];
+    for (const blockEntry of blockValue) {
+      if (!blockEntry._id || !blockEntry.type) {
+        continue;
+      }
+      const collectedNode = collectFromNode({
+        uniformSourceLocale,
+        uniformTargetLocale,
+        node: blockEntry,
+        deep: false,
+        config
+      });
+      const hasContent = collectedNode.parameters || collectedNode._overrides;
+      if (hasContent) {
+        collectedNode.slots = void 0;
+        collectedBlocks.push(collectedNode);
+      }
+    }
+    if (collectedBlocks.length === 0) {
+      return void 0;
+    }
+    return {
+      type: import_canvas2.CANVAS_BLOCK_PARAM_TYPE,
+      value: collectedBlocks
+    };
+  }
+  return void 0;
+};
 var canTranslateParameterValue = (parameter, value) => {
   if (parameter.type === SUPPORTED_PARAM_TYPES.text) {
     if (typeof value !== "string" || !value) {
@@ -689,6 +954,421 @@ var preprocessTargetValue = (parameter, value) => {
 
 // src/getCompositionForTranslation.ts
 var import_canvas3 = require("@uniformdev/canvas");
+
+// ../context/dist/api/api.mjs
+var import_p_limit = __toESM(require_p_limit(), 1);
+var __defProp2 = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var defaultLimitPolicy = (0, import_p_limit.default)(6);
+var UNIFORM_BEARER_TOKEN_NOT_VALID_OR_EXPIRED_MESSAGE = "Bearer token not valid or expired";
+var ApiClientError = class _ApiClientError extends Error {
+  constructor(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId) {
+    super(
+      `${errorMessage}
+ ${statusCode}${statusText ? " " + statusText : ""} (${fetchMethod} ${fetchUri}${requestId ? ` Request ID: ${requestId}` : ""})`
+    );
+    __publicField(this, "errorMessage", errorMessage);
+    __publicField(this, "fetchMethod", fetchMethod);
+    __publicField(this, "fetchUri", fetchUri);
+    __publicField(this, "statusCode", statusCode);
+    __publicField(this, "statusText", statusText);
+    __publicField(this, "requestId", requestId);
+    Object.setPrototypeOf(this, _ApiClientError.prototype);
+  }
+};
+var BearerTokenNotValidOrExpiredError = class _BearerTokenNotValidOrExpiredError extends ApiClientError {
+  constructor(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId) {
+    super(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId);
+    Object.setPrototypeOf(this, _BearerTokenNotValidOrExpiredError.prototype);
+  }
+};
+var ApiClient = class _ApiClient {
+  constructor(options) {
+    __publicField(this, "options");
+    var _a, _b, _c, _d, _e;
+    if (!options.apiKey && !options.bearerToken) {
+      throw new Error("You must provide an API key or a bearer token");
+    }
+    let leFetch = options.fetch;
+    if (!leFetch) {
+      if (typeof window !== "undefined") {
+        leFetch = window.fetch.bind(window);
+      } else if (typeof fetch !== "undefined") {
+        leFetch = fetch;
+      } else {
+        throw new Error("You must provide or polyfill a fetch implementation when not in a browser");
+      }
+    }
+    this.options = {
+      ...options,
+      fetch: leFetch,
+      apiHost: this.ensureApiHost(options.apiHost),
+      apiKey: (_a = options.apiKey) != null ? _a : null,
+      projectId: (_b = options.projectId) != null ? _b : null,
+      bearerToken: (_c = options.bearerToken) != null ? _c : null,
+      limitPolicy: (_d = options.limitPolicy) != null ? _d : defaultLimitPolicy,
+      bypassCache: (_e = options.bypassCache) != null ? _e : false
+    };
+  }
+  async apiClient(fetchUri, options) {
+    return (await this.apiClientWithResponse(fetchUri, options)).body;
+  }
+  async apiClientWithResponse(fetchUri, options) {
+    return this.options.limitPolicy(async () => {
+      var _a, _b;
+      const coreHeaders = this.options.apiKey ? {
+        "x-api-key": this.options.apiKey
+      } : {
+        Authorization: `Bearer ${this.options.bearerToken}`
+      };
+      if (this.options.bypassCache) {
+        coreHeaders["x-bypass-cache"] = "true";
+      }
+      const { fetch: fetch2, signal } = this.options;
+      const callApi = () => fetch2(fetchUri.toString(), {
+        ...options,
+        signal,
+        headers: {
+          ...options == null ? void 0 : options.headers,
+          ...coreHeaders
+        }
+      });
+      const apiResponse = await handleRateLimits(callApi);
+      if (!apiResponse.ok) {
+        let message = "";
+        try {
+          const responseText = await apiResponse.text();
+          try {
+            const parsed = JSON.parse(responseText);
+            if (parsed.errorMessage) {
+              message = Array.isArray(parsed.errorMessage) ? parsed.errorMessage.join(", ") : parsed.errorMessage;
+            } else {
+              message = responseText;
+            }
+          } catch (e) {
+            message = responseText;
+          }
+        } catch (e) {
+          message = `General error`;
+        }
+        if (apiResponse.status === 401 && message === UNIFORM_BEARER_TOKEN_NOT_VALID_OR_EXPIRED_MESSAGE) {
+          throw new BearerTokenNotValidOrExpiredError(
+            message,
+            (_a = options == null ? void 0 : options.method) != null ? _a : "GET",
+            fetchUri.toString(),
+            apiResponse.status,
+            apiResponse.statusText,
+            _ApiClient.getRequestId(apiResponse)
+          );
+        }
+        throw new ApiClientError(
+          message,
+          (_b = options == null ? void 0 : options.method) != null ? _b : "GET",
+          fetchUri.toString(),
+          apiResponse.status,
+          apiResponse.statusText,
+          _ApiClient.getRequestId(apiResponse)
+        );
+      }
+      if (options == null ? void 0 : options.expectNoContent) {
+        return { response: apiResponse, body: null };
+      }
+      return {
+        response: apiResponse,
+        body: await apiResponse.json()
+      };
+    });
+  }
+  createUrl(path, queryParams, hostOverride) {
+    const url = new URL(`${hostOverride != null ? hostOverride : this.options.apiHost}${path}`);
+    Object.entries(queryParams != null ? queryParams : {}).forEach(([key, value]) => {
+      var _a;
+      if (typeof value !== "undefined" && value !== null) {
+        url.searchParams.append(key, Array.isArray(value) ? value.join(",") : (_a = value == null ? void 0 : value.toString()) != null ? _a : "");
+      }
+    });
+    return url;
+  }
+  ensureApiHost(apiHost) {
+    if (!apiHost) return "https://uniform.app";
+    if (!(apiHost == null ? void 0 : apiHost.startsWith("http"))) {
+      throw new Error('Your apiHost must start with "http"');
+    }
+    if (apiHost.indexOf("/", 8) > -1) {
+      throw new Error("Your apiHost must not contain a path element after the domain");
+    }
+    if (apiHost.indexOf("?") > -1) {
+      throw new Error("Your apiHost must not contain a query string");
+    }
+    if (apiHost == null ? void 0 : apiHost.endsWith("/")) {
+      apiHost = apiHost.substring(0, apiHost.length - 1);
+    }
+    return apiHost;
+  }
+  static getRequestId(response) {
+    const apigRequestId = response.headers.get("apigw-requestid");
+    if (apigRequestId) {
+      return apigRequestId;
+    }
+    return void 0;
+  }
+};
+async function handleRateLimits(callApi) {
+  var _a;
+  const backoffRetries = 5;
+  let backoffRetriesLeft = backoffRetries;
+  let response;
+  while (backoffRetriesLeft > 0) {
+    response = await callApi();
+    if (response.status !== 429) {
+      break;
+    }
+    let resetWait = 0;
+    try {
+      const responseClone = response.clone();
+      const dateHeader = responseClone.headers.get("date");
+      const serverTime = dateHeader ? new Date(dateHeader).getTime() : void 0;
+      const body = await responseClone.json();
+      const resetTime = (_a = body == null ? void 0 : body.info) == null ? void 0 : _a.reset;
+      if (typeof serverTime === "number" && typeof resetTime === "number") {
+        resetWait = Math.max(0, Math.min(Math.round(1.1 * (resetTime - serverTime)), 1e4));
+      }
+    } catch (e) {
+    }
+    const base = Math.pow(2, backoffRetries - backoffRetriesLeft) * 333;
+    const backoffWait = base + Math.round(Math.random() * (base / 2)) * (Math.random() > 0.5 ? 1 : -1);
+    await new Promise((resolve) => setTimeout(resolve, Math.max(0, resetWait + backoffWait)));
+    backoffRetriesLeft -= 1;
+  }
+  return response;
+}
+var _url;
+var _AggregateClient = class _AggregateClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all aggregates for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) an Aggregate */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an Aggregate */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url = /* @__PURE__ */ new WeakMap();
+__privateAdd(_AggregateClient, _url, "/api/v2/aggregate");
+var _url2;
+var _DimensionClient = class _DimensionClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches the known score dimensions for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_DimensionClient2, _url2), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+};
+_url2 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_DimensionClient, _url2, "/api/v2/dimension");
+var _url3;
+var _valueUrl;
+var _EnrichmentClient = class _EnrichmentClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all enrichments and values for a project, grouped by category */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) an enrichment category */
+  async upsertCategory(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an enrichment category */
+  async removeCategory(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Updates or creates (based on id) an enrichment value within an enrichment category */
+  async upsertValue(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _valueUrl));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an enrichment value within an enrichment category. The category is left alone. */
+  async removeValue(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _valueUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url3 = /* @__PURE__ */ new WeakMap();
+_valueUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_EnrichmentClient, _url3, "/api/v1/enrichments");
+__privateAdd(_EnrichmentClient, _valueUrl, "/api/v1/enrichment-values");
+var _url4;
+var _ManifestClient = class _ManifestClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches the Context manifest for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_ManifestClient2, _url4), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Publishes the Context manifest for a project */
+  async publish() {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl("/api/v1/publish", { siteId: projectId });
+    await this.apiClient(fetchUri, {
+      method: "POST",
+      expectNoContent: true
+    });
+  }
+};
+_url4 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ManifestClient, _url4, "/api/v2/manifest");
+var _url5;
+var _QuirkClient = class _QuirkClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Quirks for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Quirk */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Quirk */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url5 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_QuirkClient, _url5, "/api/v2/quirk");
+var _url6;
+var _SignalClient = class _SignalClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Signals for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Signal */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Signal */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url6 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_SignalClient, _url6, "/api/v2/signal");
+var _url7;
+var _TestClient = class _TestClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Tests for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Test */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Test */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url7 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_TestClient, _url7, "/api/v2/test");
+
+// src/getCompositionForTranslation.ts
 var getCompositionForTranslation = async ({
   canvasClient,
   compositionId,
@@ -698,16 +1378,19 @@ var getCompositionForTranslation = async ({
   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;
+  try {
+    const composition = await canvasClient.get({
+      compositionId,
+      releaseId: releaseId ? releaseId : void 0,
+      state
+    });
+    return composition ? composition : void 0;
+  } catch (error) {
+    if (error instanceof ApiClientError && error.statusCode === 404) {
+      return void 0;
+    }
+    throw error;
+  }
 };
 
 // src/getEntryForTranslation.ts
@@ -722,14 +1405,10 @@ var getEntryForTranslation = async ({
   if (!entryId) {
     return void 0;
   }
-  const entriesResponse = await contentClient.getEntries({
+  const entriesResponse = await contentClient.list({
     entryIDs: [entryId],
     releaseId: releaseId ? releaseId : void 0,
     limit: 1,
-    withComponentIDs: true,
-    skipDataResolution: true,
-    skipOverridesResolution: true,
-    skipPatternResolution: true,
     pattern,
     state
   });
@@ -858,7 +1537,7 @@ var defaultUpdateComposition = async ({
   canvasClient,
   composition
 }) => {
-  await canvasClient.updateComposition(composition);
+  await canvasClient.save(composition);
   return true;
 };
 
@@ -986,7 +1665,7 @@ var defaultUpdateEntry = async ({
   contentClient,
   entry
 }) => {
-  await contentClient.upsertEntry(entry);
+  await contentClient.save(entry);
   return true;
 };