@uniformdev/canvas 20.63.0 → 20.63.1-alpha.17

package/dist/index.js

@@ -465,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,
@@ -551,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
@@ -766,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 {
@@ -781,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);
@@ -951,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(
@@ -1288,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) {
@@ -1446,7 +1510,7 @@ function hasReferencedVariables(value) {
 
 // src/enhancement/walkNodeTree.ts
 function walkNodeTree(node, visitor, options) {
-  var _a, _b;
+  var _a, _b, _c;
   const componentQueue = [
     {
       ancestorsAndSelf: Array.isArray(node) ? node : [{ node, type: "root" }],
@@ -1454,12 +1518,14 @@ function walkNodeTree(node, visitor, options) {
     }
   ];
   const childContexts = /* @__PURE__ */ new Map();
+  const order = (_a = options == null ? void 0 : options.order) != null ? _a : "dfs";
+  const takeNext = () => order === "bfs" ? componentQueue.shift() : componentQueue.pop();
   do {
-    const currentQueueEntry = componentQueue.pop();
+    const currentQueueEntry = takeNext();
     if (!currentQueueEntry) continue;
     const currentComponent = currentQueueEntry.ancestorsAndSelf[0];
     let visitDescendants = true;
-    let descendantContext = (_a = childContexts.get(currentComponent.node)) != null ? _a : currentQueueEntry.context;
+    let descendantContext = (_b = childContexts.get(currentComponent.node)) != null ? _b : currentQueueEntry.context;
     let visitorInfo;
     if (currentComponent.type === "root" && isRootEntryReference(currentComponent) || currentComponent.type === "block") {
       visitorInfo = {
@@ -1646,39 +1712,11 @@ function walkNodeTree(node, visitor, options) {
       continue;
     }
     const slots = "slots" in currentComponent.node && currentComponent.node.slots;
-    if (slots) {
-      const slotKeys = Object.keys(slots);
-      for (let slotIndex = slotKeys.length - 1; slotIndex >= 0; slotIndex--) {
-        const slotKey = slotKeys[slotIndex];
-        const components = slots[slotKey];
-        for (let componentIndex = components.length - 1; componentIndex >= 0; componentIndex--) {
-          const enqueueingComponent = components[componentIndex];
-          const parentSlotIndexFn = () => {
-            const result = currentComponent.node.slots[slotKey].findIndex(
-              (x) => x === enqueueingComponent
-            );
-            return result;
-          };
-          componentQueue.push({
-            ancestorsAndSelf: [
-              {
-                type: "slot",
-                node: enqueueingComponent,
-                parentSlot: slotKey,
-                parentSlotIndexFn
-              },
-              ...currentQueueEntry.ancestorsAndSelf
-            ],
-            context: descendantContext
-          });
-        }
-      }
-    }
+    const childEntries = [];
     const properties = getPropertiesValue(currentComponent.node);
     if (properties) {
       const propertyEntries = Object.entries(properties);
-      for (let propIndex = propertyEntries.length - 1; propIndex >= 0; propIndex--) {
-        const [propKey, propObject] = propertyEntries[propIndex];
+      for (const [propKey, propObject] of propertyEntries) {
         if (!isNestedNodeType(propObject.type)) {
           continue;
         }
@@ -1698,13 +1736,12 @@ function walkNodeTree(node, visitor, options) {
             continue;
           }
         }
-        const blocks = (_b = propObject.value) != null ? _b : [];
-        for (let blockIndex = blocks.length - 1; blockIndex >= 0; blockIndex--) {
-          const enqueueingBlock = blocks[blockIndex];
+        const blocks = (_c = propObject.value) != null ? _c : [];
+        for (const enqueueingBlock of blocks) {
           const blockIndexFn = () => {
             return getBlockValue(currentComponent.node, propKey).findIndex((x) => x === enqueueingBlock);
           };
-          componentQueue.push({
+          childEntries.push({
             ancestorsAndSelf: [
               {
                 type: "block",
@@ -1719,6 +1756,36 @@ function walkNodeTree(node, visitor, options) {
         }
       }
     }
+    if (slots) {
+      const slotKeys = Object.keys(slots);
+      for (const slotKey of slotKeys) {
+        const components = slots[slotKey];
+        for (const enqueueingComponent of components) {
+          const parentSlotIndexFn = () => {
+            const result = currentComponent.node.slots[slotKey].findIndex(
+              (x) => x === enqueueingComponent
+            );
+            return result;
+          };
+          childEntries.push({
+            ancestorsAndSelf: [
+              {
+                type: "slot",
+                node: enqueueingComponent,
+                parentSlot: slotKey,
+                parentSlotIndexFn
+              },
+              ...currentQueueEntry.ancestorsAndSelf
+            ],
+            context: descendantContext
+          });
+        }
+      }
+    }
+    if (order === "dfs") {
+      childEntries.reverse();
+    }
+    componentQueue.push(...childEntries);
   } while (componentQueue.length > 0);
 }
 function isNestedNodeType(type) {
@@ -2584,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;
   }
@@ -2593,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({
@@ -2614,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);
@@ -2625,7 +2691,7 @@ function localize(options) {
         actions.remove();
       }
     } else {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
     }
   });
 }
@@ -2644,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;
@@ -2663,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({
@@ -3345,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";
@@ -3473,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
@@ -3836,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");
@@ -3952,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,
@@ -4038,10 +4281,13 @@ var CanvasClientError = import_api19.ApiClientError;
   localize,
   mapSlotToPersonalizedVariations,
   mapSlotToTestVariations,
+  matchesProjectionPattern,
   mergeAssetConfigWithDefaults,
   nullLimitPolicy,
   parseComponentPlaceholderId,
   parseVariableExpression,
+  projectionToQuery,
+  queryToProjection,
   version,
   walkNodeTree,
   walkPropertyValues