@uniformdev/canvas 20.63.1-alpha.12 → 20.63.1-alpha.17

package/dist/index.js

@@ -8,6 +8,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+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 });
@@ -33,6 +36,355 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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);
 
+// ../../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;
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports2, module2) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports2) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports2.operation = function(options) {
+      var timeouts = exports2.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports2.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports2.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports2.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports2.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_retry();
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -113,11 +465,13 @@ __export(src_exports, {
   PreviewClient: () => PreviewClient,
   ProjectClient: () => ProjectClient,
   PromptClient: () => PromptClient,
+  REFERENCE_DATA_TYPE_ID: () => REFERENCE_DATA_TYPE_ID,
   RelationshipClient: () => RelationshipClient,
   ReleaseClient: () => ReleaseClient,
   ReleaseContentsClient: () => ReleaseContentsClient,
   RouteClient: () => RouteClient,
   SECRET_QUERY_STRING_PARAM: () => SECRET_QUERY_STRING_PARAM,
+  SELECT_QUERY_PREFIX: () => SELECT_QUERY_PREFIX,
   UncachedCanvasClient: () => UncachedCanvasClient,
   UncachedCategoryClient: () => UncachedCategoryClient,
   UncachedContentClient: () => UncachedContentClient,
@@ -199,10 +553,13 @@ __export(src_exports, {
   localize: () => localize,
   mapSlotToPersonalizedVariations: () => mapSlotToPersonalizedVariations,
   mapSlotToTestVariations: () => mapSlotToTestVariations,
+  matchesProjectionPattern: () => matchesProjectionPattern,
   mergeAssetConfigWithDefaults: () => mergeAssetConfigWithDefaults,
   nullLimitPolicy: () => nullLimitPolicy,
   parseComponentPlaceholderId: () => parseComponentPlaceholderId,
   parseVariableExpression: () => parseVariableExpression,
+  projectionToQuery: () => projectionToQuery,
+  queryToProjection: () => queryToProjection,
   version: () => version,
   walkNodeTree: () => walkNodeTree,
   walkPropertyValues: () => walkPropertyValues
@@ -214,15 +571,176 @@ var import_api2 = require("@uniformdev/context/api");
 
 // src/enhancement/createLimitPolicy.ts
 var import_api = require("@uniformdev/context/api");
-var import_p_limit = __toESM(require("p-limit"));
-var import_p_retry = __toESM(require("p-retry"));
-var import_p_throttle = __toESM(require("p-throttle"));
+var import_p_limit = __toESM(require_p_limit());
+
+// ../../node_modules/.pnpm/p-retry@5.1.2/node_modules/p-retry/index.js
+var import_retry = __toESM(require_retry2(), 1);
+var networkErrorMsgs = /* @__PURE__ */ new Set([
+  "Failed to fetch",
+  // Chrome
+  "NetworkError when attempting to fetch resource.",
+  // Firefox
+  "The Internet connection appears to be offline.",
+  // Safari
+  "Network request failed",
+  // `cross-fetch`
+  "fetch failed"
+  // Undici (Node.js)
+]);
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var decorateErrorWithCounts = (error, attemptNumber, options) => {
+  const retriesLeft = options.retries - (attemptNumber - 1);
+  error.attemptNumber = attemptNumber;
+  error.retriesLeft = retriesLeft;
+  return error;
+};
+var isNetworkError = (errorMessage) => networkErrorMsgs.has(errorMessage);
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new Error(errorMessage) : new DOMException(errorMessage);
+async function pRetry(input, options) {
+  return new Promise((resolve, reject) => {
+    options = {
+      onFailedAttempt() {
+      },
+      retries: 10,
+      ...options
+    };
+    const operation = import_retry.default.operation(options);
+    operation.attempt(async (attemptNumber) => {
+      try {
+        resolve(await input(attemptNumber));
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+          return;
+        }
+        if (error instanceof AbortError) {
+          operation.stop();
+          reject(error.originalError);
+        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+          operation.stop();
+          reject(error);
+        } else {
+          decorateErrorWithCounts(error, attemptNumber, options);
+          try {
+            await options.onFailedAttempt(error);
+          } catch (error2) {
+            reject(error2);
+            return;
+          }
+          if (!operation.retry(error)) {
+            reject(operation.mainError());
+          }
+        }
+      }
+    });
+    if (options.signal && !options.signal.aborted) {
+      options.signal.addEventListener("abort", () => {
+        operation.stop();
+        const reason = options.signal.reason === void 0 ? getDOMException("The operation was aborted.") : options.signal.reason;
+        reject(reason instanceof Error ? reason : getDOMException(reason));
+      }, {
+        once: true
+      });
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/p-throttle@5.0.0/node_modules/p-throttle/index.js
+var AbortError2 = class extends Error {
+  constructor() {
+    super("Throttled function aborted");
+    this.name = "AbortError";
+  }
+};
+function pThrottle({ limit, interval, strict }) {
+  if (!Number.isFinite(limit)) {
+    throw new TypeError("Expected `limit` to be a finite number");
+  }
+  if (!Number.isFinite(interval)) {
+    throw new TypeError("Expected `interval` to be a finite number");
+  }
+  const queue = /* @__PURE__ */ new Map();
+  let currentTick = 0;
+  let activeCount = 0;
+  function windowedDelay() {
+    const now = Date.now();
+    if (now - currentTick > interval) {
+      activeCount = 1;
+      currentTick = now;
+      return 0;
+    }
+    if (activeCount < limit) {
+      activeCount++;
+    } else {
+      currentTick += interval;
+      activeCount = 1;
+    }
+    return currentTick - now;
+  }
+  const strictTicks = [];
+  function strictDelay() {
+    const now = Date.now();
+    if (strictTicks.length < limit) {
+      strictTicks.push(now);
+      return 0;
+    }
+    const earliestTime = strictTicks.shift() + interval;
+    if (now >= earliestTime) {
+      strictTicks.push(now);
+      return 0;
+    }
+    strictTicks.push(earliestTime);
+    return earliestTime - now;
+  }
+  const getDelay = strict ? strictDelay : windowedDelay;
+  return (function_) => {
+    const throttled = function(...args) {
+      if (!throttled.isEnabled) {
+        return (async () => function_.apply(this, args))();
+      }
+      let timeout;
+      return new Promise((resolve, reject) => {
+        const execute = () => {
+          resolve(function_.apply(this, args));
+          queue.delete(timeout);
+        };
+        timeout = setTimeout(execute, getDelay());
+        queue.set(timeout, reject);
+      });
+    };
+    throttled.abort = () => {
+      for (const timeout of queue.keys()) {
+        clearTimeout(timeout);
+        queue.get(timeout)(new AbortError2());
+      }
+      queue.clear();
+      strictTicks.splice(0, strictTicks.length);
+    };
+    throttled.isEnabled = true;
+    return throttled;
+  };
+}
+
+// src/enhancement/createLimitPolicy.ts
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry = { retries: 1, factor: 1.66 },
+  retry: retry2 = { retries: 1, factor: 1.66 },
   limit = 10
 }) {
-  const throttler = throttle ? (0, import_p_throttle.default)(throttle) : null;
+  const throttler = throttle ? pThrottle(throttle) : null;
   const limiter = limit ? (0, import_p_limit.default)(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
@@ -234,13 +752,13 @@ function createLimitPolicy({
       const limitFunc = currentFunc;
       currentFunc = () => limiter(limitFunc);
     }
-    if (retry) {
+    if (retry2) {
       const retryFunc = currentFunc;
-      currentFunc = () => (0, import_p_retry.default)(retryFunc, {
-        ...retry,
+      currentFunc = () => pRetry(retryFunc, {
+        ...retry2,
         onFailedAttempt: async (error) => {
-          if (retry.onFailedAttempt) {
-            await retry.onFailedAttempt(error);
+          if (retry2.onFailedAttempt) {
+            await retry2.onFailedAttempt(error);
           }
           if (error instanceof import_api.ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
@@ -253,6 +771,51 @@ function createLimitPolicy({
 }
 var nullLimitPolicy = async (func) => await func();
 
+// src/projection/types.ts
+var SELECT_QUERY_PREFIX = "select.";
+
+// src/projection/projectionToQuery.ts
+function appendCsv(out, key, values) {
+  if (values === void 0) {
+    return;
+  }
+  out[key] = values.join(",");
+}
+function projectionToQuery(spec) {
+  const out = {};
+  if (!spec) {
+    return out;
+  }
+  const { fields, fieldTypes, slots } = spec;
+  const p = SELECT_QUERY_PREFIX;
+  if (fields) {
+    appendCsv(out, `${p}fields[only]`, fields.only);
+    appendCsv(out, `${p}fields[except]`, fields.except);
+    appendCsv(out, `${p}fields[locales]`, fields.locales);
+  }
+  if (fieldTypes) {
+    appendCsv(out, `${p}fieldTypes[only]`, fieldTypes.only);
+    appendCsv(out, `${p}fieldTypes[except]`, fieldTypes.except);
+  }
+  if (slots) {
+    appendCsv(out, `${p}slots[only]`, slots.only);
+    appendCsv(out, `${p}slots[except]`, slots.except);
+    if (typeof slots.depth === "number") {
+      out[`${p}slots[depth]`] = String(slots.depth);
+    }
+    if (slots.named) {
+      const slotNames = Object.keys(slots.named).sort();
+      for (const slotName of slotNames) {
+        const named = slots.named[slotName];
+        if (named && typeof named.depth === "number") {
+          out[`${p}slots.${slotName}[depth]`] = String(named.depth);
+        }
+      }
+    }
+  }
+  return out;
+}
+
 // src/CanvasClient.ts
 var CANVAS_URL = "/api/v1/canvas";
 var CanvasClient = class extends import_api2.ApiClient {
@@ -268,17 +831,24 @@ var CanvasClient = class extends import_api2.ApiClient {
   /** Fetches lists of Canvas compositions, optionally by type */
   async getCompositionList(params = {}) {
     const { projectId } = this.options;
-    const { resolveData, filters, ...originParams } = params;
+    const { resolveData, filters, select, ...originParams } = params;
     const rewrittenFilters = (0, import_api2.rewriteFiltersForApi)(filters);
+    const rewrittenSelect = projectionToQuery(select);
     if (!resolveData) {
-      const fetchUri = this.createUrl(CANVAS_URL, { ...originParams, projectId, ...rewrittenFilters });
+      const fetchUri = this.createUrl(CANVAS_URL, {
+        ...originParams,
+        projectId,
+        ...rewrittenFilters,
+        ...rewrittenSelect
+      });
       return this.apiClient(fetchUri);
     }
     const edgeParams = {
       ...originParams,
       projectId,
       diagnostics: typeof params.diagnostics === "boolean" ? params.diagnostics : params.diagnostics === "no-data" ? "no-data" : void 0,
-      ...rewrittenFilters
+      ...rewrittenFilters,
+      ...rewrittenSelect
     };
     const edgeUrl = this.createUrl("/api/v1/compositions", edgeParams, this.edgeApiHost);
     return this.apiClient(edgeUrl, this.edgeApiRequestInit);
@@ -438,15 +1008,21 @@ var _ContentClient = class _ContentClient extends import_api4.ApiClient {
   }
   getEntries(options) {
     const { projectId } = this.options;
-    const { skipDataResolution, filters, ...params } = options;
+    const { skipDataResolution, filters, select, ...params } = options;
     const rewrittenFilters = (0, import_api4.rewriteFiltersForApi)(filters);
+    const rewrittenSelect = projectionToQuery(select);
     if (skipDataResolution) {
-      const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), { ...params, ...rewrittenFilters, projectId });
+      const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), {
+        ...params,
+        ...rewrittenFilters,
+        ...rewrittenSelect,
+        projectId
+      });
       return this.apiClient(url);
     }
     const edgeUrl = this.createUrl(
       __privateGet(_ContentClient, _entriesUrl),
-      { ...this.getEdgeOptions(params), ...rewrittenFilters },
+      { ...this.getEdgeOptions(params), ...rewrittenFilters, ...rewrittenSelect },
       this.edgeApiHost
     );
     return this.apiClient(
@@ -775,6 +1351,7 @@ var EDGE_CACHE_DISABLED = -1;
 var ASSET_PARAMETER_TYPE = "asset";
 var ASSETS_SOURCE_UNIFORM = "uniform-assets";
 var ASSETS_SOURCE_CUSTOM_URL = "custom-url";
+var REFERENCE_DATA_TYPE_ID = "uniformContentInternalReference";
 
 // src/utils/guards.ts
 function isRootEntryReference(root) {
@@ -2074,8 +2651,7 @@ function extractLocales({ component }) {
   return variations;
 }
 function localize(options) {
-  const nodes = options.nodes;
-  const locale = options.locale;
+  const { nodes, locale, keepLocalesFor } = options;
   if (!locale) {
     return;
   }
@@ -2083,7 +2659,7 @@ function localize(options) {
   walkNodeTree(nodes, (context) => {
     const { type, node, actions } = context;
     if (type !== "component") {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
       return;
     }
     const result = evaluateWalkTreeNodeVisibility({
@@ -2104,7 +2680,7 @@ function localize(options) {
       if (replaceComponent == null ? void 0 : replaceComponent.length) {
         replaceComponent.forEach((component) => {
           removeLocaleProperty(component);
-          localizeProperties(component, locale, vizControlLocaleRule);
+          localizeProperties(component, locale, vizControlLocaleRule, keepLocalesFor);
         });
         const [first, ...rest] = replaceComponent;
         actions.replace(first);
@@ -2115,7 +2691,7 @@ function localize(options) {
         actions.remove();
       }
     } else {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
     }
   });
 }
@@ -2134,7 +2710,7 @@ function removeLocaleProperty(component) {
     }
   }
 }
-function localizeProperties(node, locale, rules) {
+function localizeProperties(node, locale, rules, keepLocalesFor) {
   const properties = getPropertiesValue(node);
   if (!properties) {
     return void 0;
@@ -2153,10 +2729,16 @@ function localizeProperties(node, locale, rules) {
     if (currentLocaleConditionalValues !== void 0) {
       propertyValue.conditions = currentLocaleConditionalValues;
     }
-    delete propertyValue.locales;
-    delete propertyValue.localesConditions;
+    const preserveLocales = (keepLocalesFor == null ? void 0 : keepLocalesFor(propertyId)) === true;
+    if (!preserveLocales) {
+      delete propertyValue.locales;
+      delete propertyValue.localesConditions;
+    }
     if (propertyValue.value === void 0 && propertyValue.conditions === void 0) {
-      delete properties[propertyId];
+      const hasLocales = preserveLocales && (propertyValue.locales || propertyValue.localesConditions);
+      if (!hasLocales) {
+        delete properties[propertyId];
+      }
     }
   });
   evaluateWalkTreePropertyCriteria({
@@ -2835,6 +3417,173 @@ __privateAdd(_ProjectClient, _url2, "/api/v1/project");
 __privateAdd(_ProjectClient, _projectsUrl, "/api/v1/projects");
 var ProjectClient = _ProjectClient;
 
+// src/projection/matchesProjectionPattern.ts
+var DISALLOWED_PATTERN_CHARS = /[,&=?#[\]\s]/;
+var REGEX_METACHAR = /[\\^$.|?*+()[\]{}]/g;
+function isValidProjectionPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return false;
+  }
+  if (DISALLOWED_PATTERN_CHARS.test(pattern)) {
+    return false;
+  }
+  return true;
+}
+function compilePattern(pattern) {
+  let regexSource = "^";
+  for (const ch of pattern) {
+    if (ch === "*") {
+      regexSource += ".*";
+    } else {
+      regexSource += ch.replace(REGEX_METACHAR, "\\$&");
+    }
+  }
+  regexSource += "$";
+  return new RegExp(regexSource);
+}
+var PATTERN_CACHE_MAX = 1024;
+var patternRegexCache = /* @__PURE__ */ new Map();
+function matchesProjectionPattern(pattern, value) {
+  let re = patternRegexCache.get(pattern);
+  if (re === void 0) {
+    if (!isValidProjectionPattern(pattern)) {
+      throw new Error(`Invalid projection pattern: ${JSON.stringify(pattern)}`);
+    }
+    re = compilePattern(pattern);
+    if (patternRegexCache.size >= PATTERN_CACHE_MAX) {
+      const oldest = patternRegexCache.keys().next().value;
+      if (oldest !== void 0) patternRegexCache.delete(oldest);
+    }
+    patternRegexCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+
+// src/projection/queryToProjection.ts
+var TOP_LEVEL_OPERATOR_KEY = /^(fields|fieldTypes|slots)\[([A-Za-z]+)\]$/;
+var SLOTS_NAMED_KEY = /^slots\.([A-Za-z0-9_-]+)\[([A-Za-z]+)\]$/;
+function toStringValue2(value) {
+  if (Array.isArray(value)) {
+    return value.join(",");
+  }
+  return value;
+}
+function parseCsv(value) {
+  const str = toStringValue2(value);
+  if (!str) {
+    return [];
+  }
+  return str.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseDepth(value, key) {
+  const str = toStringValue2(value);
+  if (str === void 0 || str === "") {
+    throw new Error(`Invalid select projection: '${key}' requires a non-negative integer value`);
+  }
+  if (!/^\d+$/.test(str)) {
+    throw new Error(
+      `Invalid select projection: '${key}' must be a non-negative integer (got ${JSON.stringify(str)})`
+    );
+  }
+  return Number(str);
+}
+function extractSelectKeys(source) {
+  if (source instanceof URLSearchParams) {
+    let out2;
+    for (const [key, value] of source.entries()) {
+      if (!key.startsWith(SELECT_QUERY_PREFIX)) continue;
+      out2 != null ? out2 : out2 = {};
+      out2[key] = out2[key] === void 0 ? value : `${out2[key]},${value}`;
+    }
+    return out2;
+  }
+  let out;
+  for (const key in source) {
+    if (!key.startsWith(SELECT_QUERY_PREFIX)) continue;
+    out != null ? out : out = {};
+    out[key] = source[key];
+  }
+  return out;
+}
+function queryToProjection(source) {
+  var _a, _b, _c, _d, _e;
+  if (!source) {
+    return void 0;
+  }
+  const query = extractSelectKeys(source);
+  if (!query) {
+    return void 0;
+  }
+  const spec = {};
+  for (const [rawKey, value] of Object.entries(query)) {
+    const key = rawKey.slice(SELECT_QUERY_PREFIX.length);
+    const namedMatch = SLOTS_NAMED_KEY.exec(key);
+    if (namedMatch) {
+      const [, slotName, operator2] = namedMatch;
+      if (operator2 !== "depth") {
+        throw new Error(
+          `Invalid select projection: unsupported operator '${operator2}' for slots.${slotName}`
+        );
+      }
+      const slots = (_a = spec.slots) != null ? _a : spec.slots = {};
+      const named = (_b = slots.named) != null ? _b : slots.named = {};
+      named[slotName] = { ...named[slotName], depth: parseDepth(value, rawKey) };
+      continue;
+    }
+    const topMatch = TOP_LEVEL_OPERATOR_KEY.exec(key);
+    if (!topMatch) {
+      throw new Error(`Invalid select projection key: ${JSON.stringify(rawKey)}`);
+    }
+    const [, bucket, operator] = topMatch;
+    if (bucket === "fields") {
+      const fields = (_c = spec.fields) != null ? _c : spec.fields = {};
+      switch (operator) {
+        case "only":
+          fields.only = parseCsv(value);
+          break;
+        case "except":
+          fields.except = parseCsv(value);
+          break;
+        case "locales":
+          fields.locales = parseCsv(value);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'fields[${operator}]'`);
+      }
+    } else if (bucket === "fieldTypes") {
+      const fieldTypes = (_d = spec.fieldTypes) != null ? _d : spec.fieldTypes = {};
+      switch (operator) {
+        case "only":
+          fieldTypes.only = parseCsv(value);
+          break;
+        case "except":
+          fieldTypes.except = parseCsv(value);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'fieldTypes[${operator}]'`);
+      }
+    } else if (bucket === "slots") {
+      const slots = (_e = spec.slots) != null ? _e : spec.slots = {};
+      switch (operator) {
+        case "only":
+          slots.only = parseCsv(value);
+          break;
+        case "except":
+          slots.except = parseCsv(value);
+          break;
+        case "depth":
+          slots.depth = parseDepth(value, rawKey);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'slots[${operator}]'`);
+      }
+    } else {
+      throw new Error(`Invalid select projection key: ${JSON.stringify(rawKey)}`);
+    }
+  }
+  return spec;
+}
+
 // src/PromptClient.ts
 var import_api13 = require("@uniformdev/context/api");
 var PromptsUrl = "/api/v1/prompts";
@@ -2963,7 +3712,9 @@ var RouteClient = class extends import_api17.ApiClient {
   /** Fetches lists of Canvas compositions, optionally by type */
   async getRoute(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(ROUTE_URL, { ...options, projectId }, this.edgeApiHost);
+    const { select, ...rest } = options != null ? options : {};
+    const rewrittenSelect = projectionToQuery(select);
+    const fetchUri = this.createUrl(ROUTE_URL, { ...rest, projectId, ...rewrittenSelect }, this.edgeApiHost);
     return await this.apiClient(
       fetchUri,
       this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
@@ -3326,7 +4077,7 @@ function handleRichTextNodeBinding(object, options) {
 var import_api19 = require("@uniformdev/context/api");
 
 // src/.version.ts
-var version = "20.63.0";
+var version = "20.66.0";
 
 // src/WorkflowClient.ts
 var import_api18 = require("@uniformdev/context/api");
@@ -3442,11 +4193,13 @@ var CanvasClientError = import_api19.ApiClientError;
   PreviewClient,
   ProjectClient,
   PromptClient,
+  REFERENCE_DATA_TYPE_ID,
   RelationshipClient,
   ReleaseClient,
   ReleaseContentsClient,
   RouteClient,
   SECRET_QUERY_STRING_PARAM,
+  SELECT_QUERY_PREFIX,
   UncachedCanvasClient,
   UncachedCategoryClient,
   UncachedContentClient,
@@ -3528,10 +4281,13 @@ var CanvasClientError = import_api19.ApiClientError;
   localize,
   mapSlotToPersonalizedVariations,
   mapSlotToTestVariations,
+  matchesProjectionPattern,
   mergeAssetConfigWithDefaults,
   nullLimitPolicy,
   parseComponentPlaceholderId,
   parseVariableExpression,
+  projectionToQuery,
+  queryToProjection,
   version,
   walkNodeTree,
   walkPropertyValues