@uniformdev/canvas 19.61.1 → 19.62.1-alpha.127

package/dist/index.mjs

@@ -476,12 +476,30 @@ var CanvasClient = class extends ApiClient {
     }
     super(options);
     this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+    this.edgeApiRequestInit = options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0;
   }
   /** Fetches lists of Canvas compositions, optionally by type */
-  async getCompositionList(options) {
+  async getCompositionList(params = {}) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(CANVAS_URL, { ...options, projectId });
-    return await this.apiClient(fetchUri);
+    const { resolveData, filters, ...originParams } = params;
+    const rewrittenFilters = Object.entries(filters != null ? filters : {}).reduce((acc, [key, value]) => {
+      const lhs = `filters.${key}` + (typeof value === "object" ? `[${Object.keys(value)[0]}]` : "");
+      let rhs = typeof value === "object" ? Object.values(value)[0] : value;
+      rhs = Array.isArray(rhs) ? rhs.map((v) => `${v}`.trim()).join(",") : `${rhs}`.trim();
+      return { ...acc, [lhs]: rhs };
+    }, {});
+    if (!resolveData) {
+      const fetchUri = this.createUrl(CANVAS_URL, { ...originParams, projectId, ...rewrittenFilters });
+      return this.apiClient(fetchUri);
+    }
+    const edgeParams = {
+      ...originParams,
+      projectId,
+      ...params.diagnostics ? { diagnostics: "true" } : {},
+      ...rewrittenFilters
+    };
+    const edgeUrl = this.createUrl("/api/v1/compositions", edgeParams, this.edgeApiHost);
+    return this.apiClient(edgeUrl, this.edgeApiRequestInit);
   }
   getCompositionByNodePath(options) {
     return this.getOneComposition(options);
@@ -499,12 +517,12 @@ var CanvasClient = class extends ApiClient {
     return this.getOneComposition(options);
   }
   /** Fetches historical versions of a composition or pattern */
-  async unstable_getCompositionHistory(options) {
-    const edgeUrl = this.createUrl("/api/v1/canvas-history", {
+  async getCompositionHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/canvas-history", {
       ...options,
       projectId: this.options.projectId
     });
-    return this.apiClient(edgeUrl);
+    return this.apiClient(historyUrl);
   }
   getOneComposition({
     skipDataResolution,
@@ -521,7 +539,7 @@ var CanvasClient = class extends ApiClient {
       ...diagnostics ? { diagnostics: "true" } : {}
     };
     const edgeUrl = this.createUrl("/api/v1/composition", edgeParams, this.edgeApiHost);
-    return this.apiClient(edgeUrl);
+    return this.apiClient(edgeUrl, this.edgeApiRequestInit);
   }
   /** Updates or creates a Canvas component definition */
   async updateComposition(body) {
@@ -546,7 +564,7 @@ var CanvasClient = class extends ApiClient {
   async getComponentDefinitions(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl("/api/v1/canvas-definitions", { ...options, projectId });
-    return await this.apiClient(fetchUri);
+    return this.apiClient(fetchUri);
   }
   /** Updates or creates a Canvas component definition */
   async updateComponentDefinition(body) {
@@ -616,73 +634,10 @@ var UncachedCategoryClient = class extends CategoryClient {
   }
 };
 
-// src/CompositionRelationshipClient.ts
-import { ApiClient as ApiClient3 } from "@uniformdev/context/api";
-var COMPOSITION_RELATIONSHIP_URL = "/api/v1/composition-relationships";
-var unstable_CompositionRelationshipClient = class extends ApiClient3 {
-  constructor(options) {
-    super(options);
-    this.getDefinitionsRelationships = async ({
-      definitionIds,
-      withCompositions
-    }) => {
-      const url = this.createUrl(COMPOSITION_RELATIONSHIP_URL, {
-        type: "definition",
-        projectId: this._options.projectId,
-        definitionIds: definitionIds.join(","),
-        withCompositions
-      });
-      return this.apiClient(url);
-    };
-    this.clearAllRelationships = async () => {
-      const url = this.createUrl(COMPOSITION_RELATIONSHIP_URL);
-      return this.apiClient(url, {
-        method: "POST",
-        body: JSON.stringify({
-          type: "clear",
-          projectId: this._options.projectId
-        })
-      });
-    };
-    this.indexCompositionRelationships = async ({
-      state,
-      compositionId
-    }) => {
-      const url = this.createUrl(COMPOSITION_RELATIONSHIP_URL);
-      return this.apiClient(url, {
-        method: "POST",
-        body: JSON.stringify({
-          type: "index",
-          projectId: this._options.projectId,
-          state,
-          compositionId
-        })
-      });
-    };
-    this.getVersion = async () => {
-      const url = this.createUrl("/api/v1/usage-tracking", {
-        projectId: this._options.projectId
-      });
-      return this.apiClient(url).then((response) => response.version);
-    };
-    this.setVersion = async (version) => {
-      const url = this.createUrl("/api/v1/usage-tracking");
-      return this.apiClient(url, {
-        method: "POST",
-        body: JSON.stringify({
-          projectId: this._options.projectId,
-          version
-        })
-      });
-    };
-    this._options = options;
-  }
-};
-
 // src/ContentClient.ts
-import { ApiClient as ApiClient4 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient3 } from "@uniformdev/context/api";
 var _contentTypesUrl, _entriesUrl;
-var _ContentClient = class _ContentClient extends ApiClient4 {
+var _ContentClient = class _ContentClient extends ApiClient3 {
   constructor(options) {
     var _a;
     super(options);
@@ -695,16 +650,42 @@ var _ContentClient = class _ContentClient extends ApiClient4 {
   }
   getEntries(options) {
     const { projectId } = this.options;
-    const { skipDataResolution, ...params } = options;
-    const fetchUri = skipDataResolution ? this.createUrl(__privateGet(_ContentClient, _entriesUrl), { ...params, projectId }) : this.createUrl(__privateGet(_ContentClient, _entriesUrl), this.getEdgeOptions(params), this.edgeApiHost);
-    return this.apiClient(fetchUri);
+    const { skipDataResolution, filters, ...params } = options;
+    const rewrittenFilters = Object.entries(filters != null ? filters : {}).reduce((acc, [key, value]) => {
+      const lhs = `filters.${key}` + (typeof value === "object" ? `[${Object.keys(value)[0]}]` : "");
+      let rhs = typeof value === "object" ? Object.values(value)[0] : value;
+      rhs = Array.isArray(rhs) ? rhs.map((v) => `${v}`.trim()).join(",") : `${rhs}`.trim();
+      return { ...acc, [lhs]: rhs };
+    }, {});
+    if (skipDataResolution) {
+      const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), { ...params, ...rewrittenFilters, projectId });
+      return this.apiClient(url);
+    }
+    const edgeUrl = this.createUrl(
+      __privateGet(_ContentClient, _entriesUrl),
+      { ...this.getEdgeOptions(params), ...rewrittenFilters },
+      this.edgeApiHost
+    );
+    return this.apiClient(
+      edgeUrl,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
   }
-  async upsertContentType(body) {
+  /** Fetches historical versions of an entry */
+  async getEntryHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/entries-history", {
+      ...options,
+      projectId: this.options.projectId
+    });
+    return this.apiClient(historyUrl);
+  }
+  async upsertContentType(body, opts = {}) {
     const fetchUri = this.createUrl(__privateGet(_ContentClient, _contentTypesUrl));
     await this.apiClient(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
-      expectNoContent: true
+      expectNoContent: true,
+      headers: opts.autogenerateDataTypes ? { "x-uniform-autogenerate-data-types": "true" } : {}
     });
   }
   async upsertEntry(body) {
@@ -753,10 +734,10 @@ var UncachedContentClient = class extends ContentClient {
 };
 
 // src/DataSourceClient.ts
-import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient4 } from "@uniformdev/context/api";
 var dataSourceUrl = "/api/v1/data-source";
 var dataSourcesUrl = "/api/v1/data-sources";
-var DataSourceClient = class extends ApiClient5 {
+var DataSourceClient = class extends ApiClient4 {
   constructor(options) {
     super(options);
   }
@@ -793,9 +774,9 @@ var DataSourceClient = class extends ApiClient5 {
 };
 
 // src/DataTypeClient.ts
-import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
 var _url;
-var _DataTypeClient = class _DataTypeClient extends ApiClient6 {
+var _DataTypeClient = class _DataTypeClient extends ApiClient5 {
   constructor(options) {
     super(options);
   }
@@ -951,12 +932,14 @@ function getComponentPath(ancestorsAndSelf) {
 var CANVAS_PERSONALIZE_TYPE = "$personalization";
 var CANVAS_TEST_TYPE = "$test";
 var CANVAS_LOCALIZATION_TYPE = "$localization";
+var CANVAS_SLOT_SECTION_TYPE = "$slotSection";
 var CANVAS_INTENT_TAG_PARAM = "intentTag";
 var CANVAS_LOCALE_TAG_PARAM = "locale";
 var CANVAS_BLOCK_PARAM_TYPE = "$block";
 var CANVAS_PERSONALIZE_SLOT = "pz";
 var CANVAS_TEST_SLOT = "test";
 var CANVAS_LOCALIZATION_SLOT = "localized";
+var CANVAS_SLOT_SECTION_SLOT = "$slotSectionItems";
 var CANVAS_DRAFT_STATE = 0;
 var CANVAS_PUBLISHED_STATE = 64;
 var CANVAS_EDITOR_STATE = 63;
@@ -966,6 +949,7 @@ var CANVAS_ENRICHMENT_TAG_PARAM = "$enr";
 var SECRET_QUERY_STRING_PARAM = "secret";
 var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
 var IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM = "is_incontext_editing_playground";
+var IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM = "is_incontext_editing_forced_settings";
 var IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM = "is_config_check";
 var IN_CONTEXT_EDITOR_COMPONENT_START_ROLE = "uniform-component-start";
 var IN_CONTEXT_EDITOR_COMPONENT_END_ROLE = "uniform-component-end";
@@ -977,31 +961,79 @@ var EMPTY_COMPOSITION = {
   _name: "An empty composition used for contextual editing",
   type: "_empty_composition_type"
 };
-var EDGE_MIN_CACHE_TTL = 15;
-var EDGE_MAX_CACHE_TTL = 600;
+var EDGE_MIN_CACHE_TTL = 10;
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
 var EDGE_DEFAULT_CACHE_TTL = 30;
 var EDGE_CACHE_DISABLED = -1;
-var EDGE_MIN_L2_CACHE_TTL_IN_HOURS = 1;
-var EDGE_MAX_L2_CACHE_TTL_IN_HOURS = 4 * 7 * 24;
-var EDGE_DEFAULT_L2_CACHE_TTL_IN_HOURS = 24;
+var ASSET_PARAMETER_TYPE = "asset";
+var ASSETS_SOURCE_UNIFORM = "uniform-assets";
+var ASSETS_SOURCE_CUSTOM_URL = "custom-url";
 
-// src/utils/entryConverter.ts
-function convertEntryToPutEntry(entry) {
-  return {
-    entry: {
-      type: entry.entry.type,
-      _dataResources: entry.entry._dataResources,
-      _id: entry.entry._id,
-      _slug: entry.entry._slug,
-      fields: entry.entry.fields
-    },
-    state: entry.state,
-    projectId: entry.projectId
-  };
+// src/utils/guards.ts
+function isRootEntryReference(root) {
+  return root.type === "root" && isEntryData(root.node);
+}
+function isEntryData(entryData) {
+  return Boolean(entryData && typeof entryData === "object" && "fields" in entryData);
+}
+function isAssetParamValue(value) {
+  return Array.isArray(value) && (value.length > 0 ? isAssetParamValueItem(value[0]) : true);
+}
+function isAssetParamValueItem(item) {
+  return Boolean(
+    item instanceof Object && "_source" in item && "fields" in item && item.fields instanceof Object && "url" in item.fields && item.fields.url instanceof Object
+  );
 }
+
+// src/utils/properties.ts
 function getPropertiesValue(entity) {
   return "parameters" in entity && entity.parameters ? entity.parameters : "fields" in entity && entity.fields ? entity.fields : void 0;
 }
+function getPropertyValue(parameter) {
+  return parameter ? parameter.value : parameter;
+}
+function getLocalizedPropertyValues(parameter) {
+  if (!parameter) {
+    return parameter;
+  }
+  const localizedValues = /* @__PURE__ */ new Map();
+  if (typeof parameter.value !== "undefined") {
+    localizedValues.set(void 0, parameter.value);
+  }
+  if (parameter.locales !== void 0) {
+    for (const [locale, localeValue] of Object.entries(parameter.locales)) {
+      localizedValues.set(locale, localeValue);
+    }
+  }
+  return localizedValues;
+}
+function flattenValues(data, options = {}) {
+  if (!data) {
+    return data;
+  } else if (Array.isArray(data) && options.toSingle) {
+    return data.length > 0 ? flattenSingleNodeValues(data[0]) : void 0;
+  } else if (Array.isArray(data)) {
+    return data.map((node) => flattenSingleNodeValues(node, options));
+  } else {
+    return flattenSingleNodeValues(data, options);
+  }
+}
+function flattenSingleNodeValues(data, options = {}) {
+  const { levels = 1 } = options;
+  const properties = getPropertiesValue(data);
+  return properties ? Object.fromEntries(
+    Object.entries(properties).map(([id, parameter]) => {
+      const value = getPropertyValue(parameter);
+      if (levels > 0 && Array.isArray(value) && // In the future ASSET_PARAMETER_TYPE will be a nested data type
+      (isNestedNodeType(parameter.type) || parameter.type === ASSET_PARAMETER_TYPE)) {
+        const nestedOptions = { ...options, levels: levels - 1 };
+        return [id, value.map((item) => flattenValues(item, nestedOptions))];
+      } else {
+        return [id, value];
+      }
+    })
+  ) : properties;
+}
 
 // src/enhancement/walkNodeTree.ts
 function walkNodeTree(node, visitor, options) {
@@ -1021,7 +1053,83 @@ function walkNodeTree(node, visitor, options) {
     let visitDescendants = true;
     let descendantContext = (_a = childContexts.get(currentComponent.node)) != null ? _a : currentQueueEntry.context;
     let visitorInfo;
-    if (currentComponent.type === "root" || currentComponent.type === "slot") {
+    if (currentComponent.type === "root" && isRootEntryReference(currentComponent) || currentComponent.type === "block") {
+      visitorInfo = {
+        type: "entry",
+        node: currentComponent.node,
+        ancestorsAndSelf: currentQueueEntry.ancestorsAndSelf,
+        actions: {
+          replace: (replacementNode) => {
+            Object.assign(currentComponent.node, replacementNode);
+            const propertiesToCheck = ["fields", "_dataResources", "_author"];
+            propertiesToCheck.forEach((property) => {
+              if (!replacementNode[property]) {
+                delete currentComponent.node[property];
+              }
+            });
+          },
+          remove: () => {
+            const currentComponentLocation = currentQueueEntry.ancestorsAndSelf[0];
+            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+            if (currentComponentLocation.type === "block") {
+              const { fieldName, blockIndex } = currentComponentLocation;
+              const blockValue = getBlockValue(parentComponent.node, fieldName);
+              blockValue.splice(blockIndex, 1);
+              if (blockValue.length === 0) {
+                const properties2 = getPropertiesValue(parentComponent.node);
+                delete properties2[fieldName];
+              }
+            } else {
+              throw new Error("Unknown node type");
+            }
+          },
+          insertAfter: (nodes) => {
+            const currentNodeInfo = currentQueueEntry.ancestorsAndSelf[0];
+            if (currentNodeInfo.type !== "block") {
+              throw new Error("Unknown type");
+            }
+            const { fieldName, blockIndex } = currentNodeInfo;
+            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+            const nodesToInsert = Array.isArray(nodes) ? nodes : [nodes];
+            if (fieldName && typeof blockIndex !== "undefined") {
+              getPropertiesValue(parentComponent.node)[fieldName].value.splice(
+                blockIndex + 1,
+                0,
+                ...nodesToInsert
+              );
+              componentQueue.unshift(
+                ...nodesToInsert.map((enqueueingComponent) => ({
+                  ancestorsAndSelf: [
+                    {
+                      type: "block",
+                      node: enqueueingComponent,
+                      fieldName,
+                      get blockIndex() {
+                        const parentArray = getPropertiesValue(parentComponent.node)[fieldName].value;
+                        return parentArray.findIndex((x) => x === enqueueingComponent);
+                      }
+                    },
+                    // slice removes 'self' since we are inserting a peer of self
+                    ...currentQueueEntry.ancestorsAndSelf.slice(1)
+                  ],
+                  context: descendantContext
+                }))
+              );
+            }
+          },
+          stopProcessingDescendants() {
+            visitDescendants = false;
+          },
+          setDescendantsContext(context) {
+            descendantContext = context;
+          },
+          setChildContext(child, context) {
+            childContexts.set(child, context);
+          }
+        },
+        context: descendantContext
+      };
+    } else {
       visitorInfo = {
         type: "component",
         node: currentComponent.node,
@@ -1112,82 +1220,6 @@ function walkNodeTree(node, visitor, options) {
         },
         context: descendantContext
       };
-    } else {
-      visitorInfo = {
-        type: "entry",
-        node: currentComponent.node,
-        ancestorsAndSelf: currentQueueEntry.ancestorsAndSelf,
-        actions: {
-          replace: (replacementNode) => {
-            Object.assign(currentComponent.node, replacementNode);
-            const propertiesToCheck = ["fields", "_dataResources", "_author"];
-            propertiesToCheck.forEach((property) => {
-              if (!replacementNode[property]) {
-                delete currentComponent.node[property];
-              }
-            });
-          },
-          remove: () => {
-            const currentComponentLocation = currentQueueEntry.ancestorsAndSelf[0];
-            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
-            if (currentComponentLocation.type === "block") {
-              const { fieldName, blockIndex } = currentComponentLocation;
-              const blockValue = getBlockValue(parentComponent.node, fieldName);
-              blockValue.splice(blockIndex, 1);
-              if (blockValue.length === 0) {
-                const properties2 = getPropertiesValue(parentComponent.node);
-                delete properties2[fieldName];
-              }
-            } else {
-              throw new Error("Unknown node type");
-            }
-          },
-          insertAfter: (nodes) => {
-            const currentNodeInfo = currentQueueEntry.ancestorsAndSelf[0];
-            if (currentNodeInfo.type !== "block") {
-              throw new Error("Unknown type");
-            }
-            const { fieldName, blockIndex } = currentNodeInfo;
-            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
-            const nodesToInsert = Array.isArray(nodes) ? nodes : [nodes];
-            if (fieldName && typeof blockIndex !== "undefined") {
-              getPropertiesValue(parentComponent.node)[fieldName].value.splice(
-                blockIndex + 1,
-                0,
-                ...nodesToInsert
-              );
-              componentQueue.unshift(
-                ...nodesToInsert.map((enqueueingComponent) => ({
-                  ancestorsAndSelf: [
-                    {
-                      type: "block",
-                      node: enqueueingComponent,
-                      fieldName,
-                      get blockIndex() {
-                        const parentArray = getPropertiesValue(parentComponent.node)[fieldName].value;
-                        return parentArray.findIndex((x) => x === enqueueingComponent);
-                      }
-                    },
-                    // slice removes 'self' since we are inserting a peer of self
-                    ...currentQueueEntry.ancestorsAndSelf.slice(1)
-                  ],
-                  context: descendantContext
-                }))
-              );
-            }
-          },
-          stopProcessingDescendants() {
-            visitDescendants = false;
-          },
-          setDescendantsContext(context) {
-            descendantContext = context;
-          },
-          setChildContext(child, context) {
-            childContexts.set(child, context);
-          }
-        },
-        context: descendantContext
-      };
     }
     visitor(visitorInfo);
     if (!visitDescendants) {
@@ -1225,7 +1257,7 @@ function walkNodeTree(node, visitor, options) {
       const propertyEntries = Object.entries(properties);
       for (let propIndex = propertyEntries.length - 1; propIndex >= 0; propIndex--) {
         const [propKey, propObject] = propertyEntries[propIndex];
-        if (propObject.type !== CANVAS_BLOCK_PARAM_TYPE)
+        if (!isNestedNodeType(propObject.type))
           continue;
         const blocks = (_b = propObject.value) != null ? _b : [];
         for (let blockIndex = blocks.length - 1; blockIndex >= 0; blockIndex--) {
@@ -1251,6 +1283,9 @@ function walkNodeTree(node, visitor, options) {
     }
   } while (componentQueue.length > 0);
 }
+function isNestedNodeType(type) {
+  return type === CANVAS_BLOCK_PARAM_TYPE;
+}
 function getBlockValue(component, parameterName) {
   var _a;
   const parameter = (_a = getPropertiesValue(component)) == null ? void 0 : _a[parameterName];
@@ -1519,7 +1554,7 @@ function getComponentJsonPointer(ancestorsAndSelf) {
       if (currentLocation.type === "block") {
         const { fieldName: parameterName, blockIndex } = currentLocation;
         if (parameterName && blockIndex !== void 0) {
-          const noun = parentLocation && "type" in parentLocation && parentLocation.type === "block" ? "fields" : "parameters";
+          const noun = getNounForLocation(parentLocation);
           path.push(`${noun}/${parameterName}/value/${blockIndex}`);
         }
       } else {
@@ -1533,6 +1568,40 @@ function getComponentJsonPointer(ancestorsAndSelf) {
   }
   return `/${path.join("/")}`;
 }
+function getNounForLocation(parentLocation) {
+  let noun = "parameters";
+  if (parentLocation && "type" in parentLocation) {
+    if (parentLocation.type === "block" || isRootEntryReference(parentLocation)) {
+      noun = "fields";
+    }
+  }
+  return noun;
+}
+function getNounForNode(node) {
+  let noun = "parameters";
+  if (isEntryData(node)) {
+    noun = "fields";
+  }
+  return noun;
+}
+
+// src/enhancement/findInNodeTree.ts
+function findParameterInNodeTree(data, predicate) {
+  const results = [];
+  walkNodeTree(data, ({ node, ancestorsAndSelf }) => {
+    const parameters = getPropertiesValue(node);
+    if (parameters) {
+      Object.entries(parameters).filter(([key, field]) => predicate(field, key, node)).forEach(([key, field]) => {
+        results.push({
+          key,
+          pointer: (ancestorsAndSelf.length === 1 ? "" : getComponentJsonPointer(ancestorsAndSelf)) + `/${getNounForNode(node)}/${key}`,
+          parameter: field
+        });
+      });
+    }
+  });
+  return results;
+}
 
 // src/enhancement/localize.ts
 function extractLocales({ component }) {
@@ -1549,23 +1618,31 @@ function extractLocales({ component }) {
   });
   return variations;
 }
-function localize({
-  composition,
-  locale
-}) {
-  walkNodeTree(composition, ({ type, node, actions }) => {
+function localize(options) {
+  const nodes = "nodes" in options ? options.nodes : options.composition;
+  const locale = options.locale;
+  walkNodeTree(nodes, ({ type, node, actions }) => {
     if (type !== "component") {
-      actions.stopProcessingDescendants();
+      if (typeof locale === "string") {
+        localizeProperties(node.fields, locale);
+      }
       return;
     }
+    const shouldRunPropertyLocalization = typeof locale === "string";
     if (node.type === CANVAS_LOCALIZATION_TYPE) {
       const locales = extractLocales({ component: node });
-      const resolvedLocale = typeof locale === "string" ? locale : locale({ component: node, locales });
+      const resolvedLocale = typeof locale === "string" ? locale : locale == null ? void 0 : locale({ component: node, locales });
       let replaceComponent;
       if (resolvedLocale) {
         replaceComponent = locales[resolvedLocale];
       }
       if (replaceComponent == null ? void 0 : replaceComponent.length) {
+        replaceComponent.forEach((component) => {
+          removeLocaleProperty(component);
+          if (shouldRunPropertyLocalization) {
+            localizeProperties(getPropertiesValue(component), locale);
+          }
+        });
         const [first, ...rest] = replaceComponent;
         actions.replace(first);
         if (rest.length) {
@@ -1574,6 +1651,42 @@ function localize({
       } else {
         actions.remove();
       }
+    } else if (shouldRunPropertyLocalization) {
+      localizeProperties(getPropertiesValue(node), locale);
+    }
+  });
+}
+function removeLocaleProperty(component) {
+  const properties = getPropertiesValue(component);
+  const localeTagProperty = properties == null ? void 0 : properties[CANVAS_LOCALE_TAG_PARAM];
+  if (localeTagProperty) {
+    delete properties[CANVAS_LOCALE_TAG_PARAM];
+  }
+  if (properties && Object.keys(properties).length === 0) {
+    if ("fields" in component) {
+      delete component.fields;
+    }
+    if ("parameters" in component) {
+      delete component.parameters;
+    }
+  }
+}
+function localizeProperties(properties, locale) {
+  if (!properties) {
+    return void 0;
+  }
+  Object.entries(properties).forEach(([key, property]) => {
+    var _a;
+    if (!locale) {
+      delete property.locales;
+    }
+    const currentLocaleValue = locale ? (_a = property.locales) == null ? void 0 : _a[locale] : void 0;
+    if (currentLocaleValue !== void 0) {
+      property.value = currentLocaleValue;
+    }
+    delete property.locales;
+    if (property.value === void 0) {
+      delete properties[key];
     }
   });
 }
@@ -1723,6 +1836,39 @@ function walkComponentTree(component, visitor, initialContext) {
   } while (componentQueue.length > 0);
 }
 
+// src/LocaleClient.ts
+import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
+var localesUrl = "/api/v1/locales";
+var LocaleClient = class extends ApiClient6 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all locales for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(localesUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a locale */
+  async upsert(body) {
+    const fetchUri = this.createUrl(localesUrl);
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a locale */
+  async remove(body) {
+    const fetchUri = this.createUrl(localesUrl);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
 // src/utils/hash.ts
 var generateHash = ({
   composition,
@@ -1793,6 +1939,12 @@ var isOpenParameterEditorMessage = (message) => {
 var isUpdateComponentReferencesMessage = (message) => {
   return message.type === "update-component-references";
 };
+var isRequestComponentSuggestionMessage = (message) => {
+  return message.type === "request-component-suggestion";
+};
+var isSuggestComponentMessage = (message) => {
+  return message.type === "suggest-component";
+};
 var createCanvasChannel = ({
   listenTo,
   broadcastTo
@@ -1801,7 +1953,13 @@ var createCanvasChannel = ({
   const handlers = {};
   const broadcastToItems = [...broadcastTo];
   const postMessage = (message) => {
-    broadcastToItems.forEach((item) => item.postMessage(JSON.stringify(message), "*"));
+    broadcastToItems.forEach((item) => item == null ? void 0 : item.postMessage(JSON.stringify(message), "*"));
+    for (const handlerId in handlers) {
+      const handler = handlers[handlerId];
+      if (handler.types.includes(message.type)) {
+        handler.handler(message, new MessageEvent(message.type));
+      }
+    }
   };
   const selectComponent = (id) => {
     const message = {
@@ -1810,7 +1968,7 @@ var createCanvasChannel = ({
     };
     postMessage(message);
   };
-  const ready = () => {
+  const ready = (options) => {
     var _a, _b;
     if (typeof window === "undefined") {
       return;
@@ -1820,7 +1978,8 @@ var createCanvasChannel = ({
     const message = {
       type: "ready",
       framework,
-      version
+      version,
+      rsc: options == null ? void 0 : options.rsc
     };
     postMessage(message);
   };
@@ -1943,6 +2102,20 @@ var createCanvasChannel = ({
     };
     postMessage(message);
   };
+  const requestComponentSuggestion = (options) => {
+    const message = {
+      ...options,
+      type: "request-component-suggestion"
+    };
+    postMessage(message);
+  };
+  const suggestComponent = (options) => {
+    const message = {
+      ...options,
+      type: "suggest-component"
+    };
+    postMessage(message);
+  };
   const updateFeatureFlags = (options) => {
     const message = {
       ...options,
@@ -1996,7 +2169,9 @@ var createCanvasChannel = ({
     openParameterEditor,
     reportRenderedCompositions,
     editorStateUpdated,
-    updateComponentReferences
+    updateComponentReferences,
+    requestComponentSuggestion,
+    suggestComponent
   };
 };
 
@@ -2078,10 +2253,166 @@ function subscribeToComposition({
   };
 }
 
-// src/RouteClient.ts
+// src/PromptClient.ts
 import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
+var PromptsUrl = "/api/v1/prompts";
+var PromptClient = class extends ApiClient7 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches Prompts for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(PromptsUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Prompt */
+  async upsert(body) {
+    const fetchUri = this.createUrl(PromptsUrl);
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Prompt */
+  async remove(body) {
+    const fetchUri = this.createUrl(PromptsUrl);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/RelationshipClient.ts
+import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
+var RELATIONSHIPS_URL = "/api/v1/relationships";
+var RelationshipClient = class extends ApiClient8 {
+  constructor(options) {
+    super(options);
+    this.get = async (options) => {
+      const { projectId } = this.options;
+      const url = this.createUrl(RELATIONSHIPS_URL, { ...options, projectId });
+      return this.apiClient(url);
+    };
+    this.clearProjectRelationships = async () => {
+      const { projectId } = this.options;
+      const url = this.createUrl(RELATIONSHIPS_URL);
+      return this.apiClient(url, {
+        method: "POST",
+        body: JSON.stringify({
+          action: "clear",
+          projectId
+        })
+      });
+    };
+    this.indexRelationships = async ({ state, id, type }) => {
+      const { projectId } = this.options;
+      const url = this.createUrl(RELATIONSHIPS_URL);
+      return this.apiClient(url, {
+        method: "POST",
+        body: JSON.stringify({
+          action: "index",
+          type,
+          projectId,
+          state,
+          id
+        })
+      });
+    };
+    this.getVersion = async () => {
+      const { projectId } = this.options;
+      const url = this.createUrl("/api/v1/usage-tracking", {
+        projectId
+      });
+      return this.apiClient(url).then((response) => response.version);
+    };
+    this.setVersion = async (version) => {
+      const { projectId } = this.options;
+      const url = this.createUrl("/api/v1/usage-tracking");
+      return this.apiClient(url, {
+        method: "POST",
+        body: JSON.stringify({
+          projectId,
+          version
+        })
+      });
+    };
+  }
+};
+
+// src/ReleaseClient.ts
+import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
+var releasesUrl = "/api/v1/releases";
+var ReleaseClient = class extends ApiClient9 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all releases for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(releasesUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a release */
+  async upsert(body) {
+    const fetchUri = this.createUrl(releasesUrl);
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a release */
+  async remove(body) {
+    const fetchUri = this.createUrl(releasesUrl);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Readies or unreadies a release for merging */
+  async ready(body) {
+    const fetchUri = this.createUrl(releasesUrl);
+    await this.apiClient(fetchUri, {
+      method: "PATCH",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/ReleaseContentsClient.ts
+import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
+var releaseContentsUrl = "/api/v1/release-contents";
+var ReleaseContentsClient = class extends ApiClient10 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all entities added to a release */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(releaseContentsUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Removes a release content from a release */
+  async remove(body) {
+    const fetchUri = this.createUrl(releaseContentsUrl);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/RouteClient.ts
+import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
 var ROUTE_URL = "/api/v1/route";
-var RouteClient = class extends ApiClient7 {
+var RouteClient = class extends ApiClient11 {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -2094,10 +2425,16 @@ var RouteClient = class extends ApiClient7 {
   async getRoute(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(ROUTE_URL, { ...options, projectId }, this.edgeApiHost);
-    return await this.apiClient(fetchUri);
+    return await this.apiClient(
+      fetchUri,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
   }
 };
 
+// src/types/locales.ts
+var LOCALE_DYNAMIC_INPUT_NAME = "locale";
+
 // src/utils/createApiEnhancer.ts
 var createUniformApiEnhancer = ({ apiUrl }) => {
   return async (message) => {
@@ -2120,6 +2457,28 @@ var createUniformApiEnhancer = ({ apiUrl }) => {
   };
 };
 
+// src/utils/entryConverter.ts
+function convertEntryToPutEntry(entry) {
+  return {
+    entry: {
+      type: entry.entry.type,
+      _dataResources: entry.entry._dataResources,
+      _id: entry.entry._id,
+      _name: entry.entry._name,
+      _slug: entry.entry._slug,
+      _pattern: entry.entry._pattern,
+      _overridability: entry.entry._overridability,
+      _overrides: entry.entry._overrides,
+      fields: entry.entry.fields,
+      _locales: entry.entry._locales
+    },
+    pattern: entry.pattern,
+    state: entry.state,
+    projectId: entry.projectId,
+    releaseId: entry.releaseId
+  };
+}
+
 // src/utils/getParameterAttributes.ts
 var ATTRIBUTE_COMPONENT_ID = "data-uniform-component-id";
 var ATTRIBUTE_PARAMETER_ID = "data-uniform-parameter-id";
@@ -2193,17 +2552,41 @@ function mapSlotToTestVariations(slot) {
 }
 
 // src/utils/placeholder.ts
+var SEPARATOR = "_";
 var isComponentPlaceholderId = (id) => {
   if (id === PLACEHOLDER_ID) {
     return true;
   }
+  if (typeof id !== "string") {
+    return false;
+  }
   return id == null ? void 0 : id.startsWith(PLACEHOLDER_ID);
 };
-var generateComponentPlaceholderId = (randomId, sdkVersion) => {
+var generateComponentPlaceholderId = (randomId, sdkVersion, parent) => {
   if (typeof sdkVersion === "undefined" || sdkVersion === 1) {
     return PLACEHOLDER_ID;
   }
-  return `${PLACEHOLDER_ID}_${randomId}`;
+  let idParts = [PLACEHOLDER_ID, randomId];
+  if (parent) {
+    idParts = [...idParts, parent.nodeId, parent.slotId];
+  }
+  return idParts.join(SEPARATOR);
+};
+var parseComponentPlaceholderId = (id) => {
+  if (!isComponentPlaceholderId(id)) {
+    return;
+  }
+  const idParts = id.split(SEPARATOR);
+  const result = {
+    id: idParts[1]
+  };
+  if (idParts[2]) {
+    result.parent = {
+      nodeId: idParts[2],
+      slotId: idParts[3]
+    };
+  }
+  return result;
 };
 
 // src/utils/variables/parseVariableExpression.ts
@@ -2246,9 +2629,14 @@ function parseVariableExpression(serialized, onToken) {
       continue;
     }
     if (char === variableSuffix && state === "variable") {
+      if (serialized[index - 1] === escapeCharacter) {
+        bufferEndIndex++;
+        continue;
+      }
       state = "text";
       if (bufferEndIndex > bufferStartIndex) {
-        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "variable") === false) {
+        const unescapedVariableName = serialized.substring(bufferStartIndex, bufferEndIndex).replace(/\\([${}])/g, "$1");
+        if (handleToken(unescapedVariableName, "variable") === false) {
           return tokenCount;
         }
         bufferStartIndex = bufferEndIndex + variableSuffix.length;
@@ -2308,7 +2696,7 @@ import { produce } from "immer";
 
 // src/utils/variables/createVariableReference.ts
 function createVariableReference(variableName) {
-  return `\${${variableName}}`;
+  return `\${${variableName.replace(/([${}])/g, "\\$1")}}`;
 }
 
 // src/utils/variables/bindVariablesToObject.ts
@@ -2392,6 +2780,9 @@ function handleRichTextNodeBinding(object, options) {
 import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
 var CanvasClientError = ApiClientError2;
 export {
+  ASSETS_SOURCE_CUSTOM_URL,
+  ASSETS_SOURCE_UNIFORM,
+  ASSET_PARAMETER_TYPE,
   ATTRIBUTE_COMPONENT_ID,
   ATTRIBUTE_MULTILINE,
   ATTRIBUTE_PARAMETER_ID,
@@ -2412,6 +2803,8 @@ export {
   CANVAS_PERSONALIZE_SLOT,
   CANVAS_PERSONALIZE_TYPE,
   CANVAS_PUBLISHED_STATE,
+  CANVAS_SLOT_SECTION_SLOT,
+  CANVAS_SLOT_SECTION_TYPE,
   CANVAS_TEST_SLOT,
   CANVAS_TEST_TYPE,
   CANVAS_TEST_VARIANT_PARAM,
@@ -2424,21 +2817,25 @@ export {
   DataTypeClient,
   EDGE_CACHE_DISABLED,
   EDGE_DEFAULT_CACHE_TTL,
-  EDGE_DEFAULT_L2_CACHE_TTL_IN_HOURS,
   EDGE_MAX_CACHE_TTL,
-  EDGE_MAX_L2_CACHE_TTL_IN_HOURS,
   EDGE_MIN_CACHE_TTL,
-  EDGE_MIN_L2_CACHE_TTL_IN_HOURS,
   EMPTY_COMPOSITION,
   EnhancerBuilder,
   IN_CONTEXT_EDITOR_COMPONENT_END_ROLE,
   IN_CONTEXT_EDITOR_COMPONENT_START_ROLE,
   IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM,
   IN_CONTEXT_EDITOR_EMBED_SCRIPT_ID,
+  IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM,
   IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM,
   IN_CONTEXT_EDITOR_QUERY_STRING_PARAM,
   IS_RENDERED_BY_UNIFORM_ATTRIBUTE,
+  LOCALE_DYNAMIC_INPUT_NAME,
+  LocaleClient,
   PLACEHOLDER_ID,
+  PromptClient,
+  RelationshipClient,
+  ReleaseClient,
+  ReleaseContentsClient,
   RouteClient,
   SECRET_QUERY_STRING_PARAM,
   UncachedCanvasClient,
@@ -2457,25 +2854,38 @@ export {
   createVariableReference,
   enhance,
   extractLocales,
+  findParameterInNodeTree,
+  flattenValues,
   generateComponentPlaceholderId,
   generateHash,
   getBlockValue,
   getChannelName,
   getComponentJsonPointer,
   getComponentPath,
+  getLocalizedPropertyValues,
+  getNounForLocation,
+  getNounForNode,
   getParameterAttributes,
   getPropertiesValue,
+  getPropertyValue,
   isAddComponentMessage,
   isAllowedReferrer,
+  isAssetParamValue,
+  isAssetParamValueItem,
   isComponentActionMessage,
   isComponentPlaceholderId,
   isDismissPlaceholderMessage,
+  isEntryData,
   isMovingComponentMessage,
+  isNestedNodeType,
   isOpenParameterEditorMessage,
   isReadyMessage,
   isReportRenderedCompositionsMessage,
+  isRequestComponentSuggestionMessage,
+  isRootEntryReference,
   isSelectComponentMessage,
   isSelectParameterMessage,
+  isSuggestComponentMessage,
   isSystemComponentDefinition,
   isTriggerCompositionActionMessage,
   isUpdateComponentParameterMessage,
@@ -2489,9 +2899,9 @@ export {
   mapSlotToPersonalizedVariations,
   mapSlotToTestVariations,
   nullLimitPolicy,
+  parseComponentPlaceholderId,
   parseVariableExpression,
   subscribeToComposition,
-  unstable_CompositionRelationshipClient,
   walkComponentTree,
   walkNodeTree
 };