@uniformdev/canvas 19.135.0 → 19.135.1-alpha.11

package/dist/index.esm.js

@@ -4,6 +4,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 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;
 };
@@ -23,19 +26,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
 // ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS({
@@ -466,6 +459,22 @@ function createLimitPolicy({
 }
 var nullLimitPolicy = async (func) => await func();
 
+// src/utils/rewriteFilters.ts
+var isPlainObject = (obj) => typeof obj === "object" && obj !== null && !Array.isArray(obj);
+function rewriteFilters(filters) {
+  return Object.entries(filters != null ? filters : {}).reduce(
+    (acc, [key, value]) => {
+      const lhs = `filters.${key}` + (isPlainObject(value) ? `[${Object.keys(value)[0]}]` : "");
+      const rhs = isPlainObject(value) ? Object.values(value)[0] : value;
+      return {
+        ...acc,
+        [lhs]: Array.isArray(rhs) ? rhs.map((v) => `${v}`.trim()).join(",") : `${rhs}`.trim()
+      };
+    },
+    {}
+  );
+}
+
 // src/CanvasClient.ts
 var CANVAS_URL = "/api/v1/canvas";
 var CanvasClient = class extends ApiClient {
@@ -482,12 +491,7 @@ var CanvasClient = class extends ApiClient {
   async getCompositionList(params = {}) {
     const { projectId } = this.options;
     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 };
-    }, {});
+    const rewrittenFilters = rewriteFilters(filters);
     if (!resolveData) {
       const fetchUri = this.createUrl(CANVAS_URL, { ...originParams, projectId, ...rewrittenFilters });
       return this.apiClient(fetchUri);
@@ -651,12 +655,7 @@ var _ContentClient = class _ContentClient extends ApiClient3 {
   getEntries(options) {
     const { projectId } = this.options;
     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 };
-    }, {});
+    const rewrittenFilters = rewriteFilters(filters);
     if (skipDataResolution) {
       const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), { ...params, ...rewrittenFilters, projectId });
       return this.apiClient(url);
@@ -984,6 +983,9 @@ function isAssetParamValueItem(item) {
     item instanceof Object && "_source" in item && "fields" in item && item.fields instanceof Object && "url" in item.fields && item.fields.url instanceof Object
   );
 }
+function isLinkParamValue(value) {
+  return typeof value === "object" && value !== null && "type" in value && "path" in value;
+}
 
 // src/utils/properties.ts
 function getPropertiesValue(entity) {
@@ -992,6 +994,21 @@ function getPropertiesValue(entity) {
 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;
@@ -1020,6 +1037,86 @@ function flattenSingleNodeValues(data, options = {}) {
   ) : properties;
 }
 
+// src/utils/variables/parseVariableExpression.ts
+var escapeCharacter = "\\";
+var variablePrefix = "${";
+var variableSuffix = "}";
+function parseVariableExpression(serialized, onToken) {
+  let bufferStartIndex = 0;
+  let bufferEndIndex = 0;
+  let tokenCount = 0;
+  const handleToken = (token, type) => {
+    tokenCount++;
+    return onToken == null ? void 0 : onToken(token, type);
+  };
+  let state = "text";
+  for (let index = 0; index < serialized.length; index++) {
+    const char = serialized[index];
+    if (bufferStartIndex > bufferEndIndex) {
+      bufferEndIndex = bufferStartIndex;
+    }
+    if (char === variablePrefix[0] && serialized[index + 1] === variablePrefix[1]) {
+      if (serialized[index - 1] === escapeCharacter) {
+        bufferEndIndex -= escapeCharacter.length;
+        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = index;
+        bufferEndIndex = index + 1;
+        continue;
+      }
+      state = "variable";
+      if (bufferEndIndex > bufferStartIndex) {
+        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = bufferEndIndex;
+      }
+      index += variablePrefix.length - 1;
+      bufferStartIndex += variablePrefix.length;
+      continue;
+    }
+    if (char === variableSuffix && state === "variable") {
+      if (serialized[index - 1] === escapeCharacter) {
+        bufferEndIndex++;
+        continue;
+      }
+      state = "text";
+      if (bufferEndIndex > bufferStartIndex) {
+        const unescapedVariableName = serialized.substring(bufferStartIndex, bufferEndIndex).replace(/\\([${}])/g, "$1");
+        if (handleToken(unescapedVariableName, "variable") === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = bufferEndIndex + variableSuffix.length;
+      }
+      continue;
+    }
+    bufferEndIndex++;
+  }
+  if (bufferEndIndex > bufferStartIndex) {
+    if (state === "variable") {
+      state = "text";
+      bufferStartIndex -= variablePrefix.length;
+    }
+    handleToken(serialized.substring(bufferStartIndex), state);
+  }
+  return tokenCount;
+}
+
+// src/utils/variables/hasReferencedVariables.ts
+function hasReferencedVariables(value) {
+  if (value === void 0) {
+    return 0;
+  }
+  let variableTokenCount = 0;
+  parseVariableExpression(value, (_, tokenType) => {
+    if (tokenType === "variable") {
+      variableTokenCount++;
+    }
+  });
+  return variableTokenCount;
+}
+
 // src/enhancement/walkNodeTree.ts
 function walkNodeTree(node, visitor, options) {
   var _a, _b;
@@ -1032,8 +1129,7 @@ function walkNodeTree(node, visitor, options) {
   const childContexts = /* @__PURE__ */ new Map();
   do {
     const currentQueueEntry = componentQueue.pop();
-    if (!currentQueueEntry)
-      continue;
+    if (!currentQueueEntry) continue;
     const currentComponent = currentQueueEntry.ancestorsAndSelf[0];
     let visitDescendants = true;
     let descendantContext = (_a = childContexts.get(currentComponent.node)) != null ? _a : currentQueueEntry.context;
@@ -1067,6 +1163,7 @@ function walkNodeTree(node, visitor, options) {
             } else {
               throw new Error("Unknown node type");
             }
+            visitDescendants = false;
           },
           insertAfter: (nodes) => {
             const currentNodeInfo = currentQueueEntry.ancestorsAndSelf[0];
@@ -1152,6 +1249,7 @@ function walkNodeTree(node, visitor, options) {
             } else {
               throw new Error("Unknown node type");
             }
+            visitDescendants = false;
           },
           insertAfter: (nodes) => {
             const nodesToInsert = Array.isArray(nodes) ? nodes : [nodes];
@@ -1242,8 +1340,25 @@ 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 (!isNestedNodeType(propObject.type))
+        if (!isNestedNodeType(propObject.type)) {
+          continue;
+        }
+        if (typeof propObject.value === "string" && hasReferencedVariables(propObject.value) > 0) {
           continue;
+        }
+        if (!Array.isArray(propObject.value)) {
+          const error = new BlockFormatError(
+            `${getComponentPath(currentQueueEntry.ancestorsAndSelf)}`,
+            propKey,
+            propObject.value
+          );
+          if (options == null ? void 0 : options.throwForInvalidBlockValues) {
+            throw error;
+          } else {
+            console.warn(`Skipped invalid block value: ${error.message}}`);
+            continue;
+          }
+        }
         const blocks = (_b = propObject.value) != null ? _b : [];
         for (let blockIndex = blocks.length - 1; blockIndex >= 0; blockIndex--) {
           const enqueueingBlock = blocks[blockIndex];
@@ -1279,6 +1394,17 @@ function getBlockValue(component, parameterName) {
   }
   return [];
 }
+var BlockFormatError = class _BlockFormatError extends Error {
+  constructor(componentPath, propertyId, blockValue) {
+    super(
+      `${componentPath} has an invalid block property value on ${propertyId}. Block values must be arrays of blocks (BlockValue type), but received ${blockValue === null ? "null" : typeof blockValue}`
+    );
+    this.componentPath = componentPath;
+    this.propertyId = propertyId;
+    this.blockValue = blockValue;
+    Object.setPrototypeOf(this, _BlockFormatError.prototype);
+  }
+};
 
 // src/enhancement/enhance.ts
 async function enhance({
@@ -1588,6 +1714,366 @@ function findParameterInNodeTree(data, predicate) {
   return results;
 }
 
+// src/enhancement/visibility/evaluateVisibilityCriteriaGroup.ts
+function evaluateVisibilityCriteriaGroup(options) {
+  const { criteriaGroup, simplifyCriteria } = options;
+  const earlyExitResult = criteriaGroup.op === "&" || !criteriaGroup.op ? false : true;
+  let hasIndeterminateClauses = false;
+  for (let index = criteriaGroup.clauses.length - 1; index >= 0; index--) {
+    const clause = criteriaGroup.clauses[index];
+    const criteriaResult = evaluateCriterion(clause, options);
+    if (criteriaResult === null) {
+      hasIndeterminateClauses = true;
+    } else if (criteriaResult === earlyExitResult) {
+      return earlyExitResult;
+    } else if (criteriaResult !== null && simplifyCriteria) {
+      criteriaGroup.clauses.splice(index, 1);
+    }
+  }
+  return hasIndeterminateClauses ? null : !earlyExitResult;
+}
+function evaluateCriterion(clause, rootOptions) {
+  var _a;
+  if ("clauses" in clause) {
+    return evaluateVisibilityCriteriaGroup({
+      ...rootOptions,
+      criteriaGroup: clause
+    });
+  }
+  const lhs = (_a = clause.source) != null ? _a : clause.rule;
+  const rhs = Array.isArray(clause.value) ? clause.value : clause.value !== void 0 ? [clause.value] : void 0;
+  if (hasReferencedVariables(lhs) > 0 || (rhs == null ? void 0 : rhs.some((rhv) => hasReferencedVariables(rhv) > 0))) {
+    return null;
+  }
+  const rule = rootOptions.rules[clause.rule];
+  if (rule) {
+    return rule(clause);
+  }
+  return null;
+}
+
+// src/enhancement/visibility/evaluateNodeVisibilityParameter.ts
+function evaluateNodeVisibilityParameter({
+  parameter,
+  ...evaluateGroupOptions
+}) {
+  if (parameter == null ? void 0 : parameter.explicitlyHidden) {
+    return false;
+  }
+  if (!(parameter == null ? void 0 : parameter.criteria)) {
+    return true;
+  }
+  const result = evaluateVisibilityCriteriaGroup({
+    ...evaluateGroupOptions,
+    criteriaGroup: parameter.criteria
+  });
+  return result;
+}
+
+// src/enhancement/visibility/evaluatePropertyCriteria.ts
+function evaluatePropertyCriteria({
+  baseValue,
+  conditionalValues,
+  keepIndeterminate,
+  ...evaluateGroupOptions
+}) {
+  let authoritative = true;
+  const result = {
+    currentValue: baseValue,
+    remainingConditionalValues: evaluateGroupOptions.simplifyCriteria && conditionalValues ? [...conditionalValues] : conditionalValues,
+    currentConditionIndex: -1
+  };
+  if (!conditionalValues) {
+    return result;
+  }
+  const conditionIndexesToRemove = [];
+  for (let i = 0; i < conditionalValues.length; i++) {
+    const conditionalVariant = conditionalValues[i];
+    if (result.matched) {
+      conditionIndexesToRemove.push(i);
+      continue;
+    }
+    const evaluationResult = evaluateVisibilityCriteriaGroup({
+      ...evaluateGroupOptions,
+      criteriaGroup: conditionalVariant.when
+    });
+    if (evaluationResult === null) {
+      if (keepIndeterminate) {
+        authoritative = false;
+      } else {
+        conditionIndexesToRemove.push(i);
+      }
+    } else if (evaluationResult === true) {
+      result.matched = conditionalVariant;
+      result.currentValue = conditionalVariant.value;
+      result.currentConditionIndex = i;
+      conditionIndexesToRemove.push(i);
+    } else {
+      conditionIndexesToRemove.push(i);
+    }
+  }
+  if (evaluateGroupOptions.simplifyCriteria) {
+    for (let i = conditionIndexesToRemove.length - 1; i >= 0; i--) {
+      result.remainingConditionalValues.splice(conditionIndexesToRemove[i], 1);
+    }
+  }
+  if (authoritative) {
+    result.remainingConditionalValues = void 0;
+  }
+  return result;
+}
+
+// src/enhancement/visibility/types.ts
+var CANVAS_VIZ_CONTROL_PARAM = "$viz";
+
+// src/enhancement/visibility/evaluateNodeVisibility.ts
+function evaluateNodeVisibility({
+  node,
+  ...evaluateGroupOptions
+}) {
+  var _a;
+  const properties = getPropertiesValue(node);
+  const vizCriteria = (_a = properties == null ? void 0 : properties[CANVAS_VIZ_CONTROL_PARAM]) == null ? void 0 : _a.value;
+  const result = evaluateNodeVisibilityParameter({
+    ...evaluateGroupOptions,
+    parameter: vizCriteria
+  });
+  if ((vizCriteria == null ? void 0 : vizCriteria.criteria) && vizCriteria.criteria.clauses.length === 0 && evaluateGroupOptions.simplifyCriteria) {
+    properties == null ? true : delete properties[CANVAS_VIZ_CONTROL_PARAM];
+  }
+  return result;
+}
+
+// src/enhancement/visibility/evaluateWalkTreeNodeVisibility.ts
+function evaluateWalkTreeNodeVisibility({
+  rules,
+  showIndeterminate,
+  context
+}) {
+  const { type, node, actions } = context;
+  if (type !== "component") {
+    return;
+  }
+  const result = evaluateNodeVisibility({ node, rules, simplifyCriteria: true });
+  if (result === null && !showIndeterminate || result === false) {
+    actions.remove();
+    return false;
+  }
+  return true;
+}
+
+// src/enhancement/visibility/evaluateWalkTreePropertyCriteria.ts
+function evaluateWalkTreePropertyCriteria({
+  rules,
+  node,
+  keepIndeterminate
+}) {
+  const properties = getPropertiesValue(node);
+  if (!properties) {
+    return;
+  }
+  Object.entries(properties).forEach(([propertyName, property]) => {
+    var _a, _b, _c;
+    if (property.locales || property.localesConditions) {
+      const localesDefined = [
+        ...Object.keys((_a = property.locales) != null ? _a : {}),
+        ...Object.keys((_b = property.localesConditions) != null ? _b : {})
+      ];
+      localesDefined.forEach((locale) => {
+        var _a2, _b2, _c2, _d, _e, _f;
+        const { currentValue, remainingConditionalValues } = evaluatePropertyCriteria({
+          baseValue: (_a2 = property.locales) == null ? void 0 : _a2[locale],
+          conditionalValues: (_b2 = property.localesConditions) == null ? void 0 : _b2[locale],
+          rules,
+          simplifyCriteria: true,
+          keepIndeterminate
+        });
+        if (currentValue === null || currentValue === void 0) {
+          (_c2 = property.locales) == null ? true : delete _c2[locale];
+        } else {
+          (_d = property.locales) != null ? _d : property.locales = {};
+          property.locales[locale] = currentValue;
+        }
+        if (!(remainingConditionalValues == null ? void 0 : remainingConditionalValues.length)) {
+          (_e = property.localesConditions) == null ? true : delete _e[locale];
+        } else {
+          (_f = property.localesConditions) != null ? _f : property.localesConditions = {};
+          property.localesConditions[locale] = remainingConditionalValues;
+        }
+      });
+      if (!Object.keys((_c = property.localesConditions) != null ? _c : {}).length) {
+        delete property.localesConditions;
+      }
+      if (!property.locales && !property.localesConditions) {
+        delete properties[propertyName];
+      }
+    } else {
+      const { currentValue, remainingConditionalValues } = evaluatePropertyCriteria({
+        baseValue: property.value,
+        conditionalValues: property.conditions,
+        rules,
+        simplifyCriteria: true,
+        keepIndeterminate
+      });
+      if (currentValue === null) {
+        delete properties[propertyName];
+      } else {
+        if (currentValue !== void 0) {
+          property.value = currentValue;
+        } else {
+          delete property.value;
+        }
+      }
+      if (remainingConditionalValues === void 0) {
+        delete property.conditions;
+      } else {
+        property.conditions = remainingConditionalValues;
+      }
+    }
+  });
+}
+
+// src/enhancement/visibility/rules/evaluateStringMatch.ts
+var isEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.includes(matchValue);
+  }
+  return criteria === matchValue;
+};
+var containsEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.includes(criterion));
+  }
+  return matchValue.includes(criteria);
+};
+var startsWithEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.startsWith(criterion));
+  }
+  return matchValue.startsWith(criteria);
+};
+var endsWithEvaluator = (criteria, matchValue) => {
+  if (Array.isArray(criteria)) {
+    return criteria.some((criterion) => matchValue.endsWith(criterion));
+  }
+  return matchValue.endsWith(criteria);
+};
+var emptyEvaluator = (_, matchValue) => {
+  return matchValue === "";
+};
+var stringOperatorEvaluators = {
+  is: isEvaluator,
+  has: containsEvaluator,
+  startswith: startsWithEvaluator,
+  endswith: endsWithEvaluator,
+  empty: emptyEvaluator
+};
+function evaluateStringMatch(criteria, matchValue, allow) {
+  const { op, value } = criteria;
+  if (allow && !allow.has(op)) {
+    return null;
+  }
+  let opMatch = op;
+  const negation = op.startsWith("!");
+  if (negation) {
+    opMatch = opMatch.slice(1);
+  }
+  const evaluator = stringOperatorEvaluators[opMatch];
+  if (!evaluator) {
+    return null;
+  }
+  const result = evaluator(value, matchValue);
+  return negation ? !result : result;
+}
+
+// src/enhancement/visibility/rules/createDynamicInputVisibilityRule.ts
+var dynamicInputVisibilityOperators = /* @__PURE__ */ new Set([
+  "is",
+  "!is",
+  "has",
+  "!has",
+  "startswith",
+  "!startswith",
+  "endswith",
+  "!endswith",
+  "empty",
+  "!empty"
+]);
+var CANVAS_VIZ_DI_RULE = "$di";
+function createDynamicInputVisibilityRule(dynamicInputs) {
+  return {
+    [CANVAS_VIZ_DI_RULE]: (criterion) => {
+      const { source } = criterion;
+      const diValue = source ? dynamicInputs[source] : void 0;
+      return evaluateStringMatch(criterion, diValue != null ? diValue : "", dynamicInputVisibilityOperators);
+    }
+  };
+}
+
+// src/enhancement/visibility/rules/createDynamicTokenVisibilityRule.ts
+var dynamicTokenVisibilityOperators = /* @__PURE__ */ new Set([
+  "is",
+  "!is",
+  "has",
+  "!has",
+  "startswith",
+  "!startswith",
+  "endswith",
+  "!endswith",
+  "empty",
+  "!empty"
+]);
+var CANVAS_VIZ_DYNAMIC_TOKEN_RULE = "$dt";
+function createDynamicTokenVisibilityRule() {
+  return {
+    [CANVAS_VIZ_DYNAMIC_TOKEN_RULE]: (criterion) => {
+      var _a;
+      if (hasReferencedVariables(criterion.source)) {
+        return null;
+      }
+      return evaluateStringMatch(criterion, (_a = criterion.source) != null ? _a : "", dynamicTokenVisibilityOperators);
+    }
+  };
+}
+
+// src/enhancement/visibility/rules/createLocaleVisibilityRule.ts
+var localeVisibilityOperators = /* @__PURE__ */ new Set(["is", "!is"]);
+var CANVAS_VIZ_LOCALE_RULE = "$locale";
+function createLocaleVisibilityRule(currentLocale) {
+  return {
+    [CANVAS_VIZ_LOCALE_RULE]: (criterion) => {
+      if (!currentLocale) {
+        return false;
+      }
+      return evaluateStringMatch(criterion, currentLocale, localeVisibilityOperators);
+    }
+  };
+}
+
+// src/enhancement/visibility/rules/createQuirksVisibilityRule.ts
+var quirksVisibilityOperators = /* @__PURE__ */ new Set([
+  "is",
+  "!is",
+  "has",
+  "!has",
+  "startswith",
+  "!startswith",
+  "endswith",
+  "!endswith",
+  "empty",
+  "!empty"
+]);
+var CANVAS_VIZ_QUIRKS_RULE = "$qk";
+function createQuirksVisibilityRule(quirks) {
+  return {
+    [CANVAS_VIZ_QUIRKS_RULE]: (criterion) => {
+      const { source } = criterion;
+      const quirkValue = source ? quirks[source] : void 0;
+      return evaluateStringMatch(criterion, quirkValue != null ? quirkValue : "", quirksVisibilityOperators);
+    }
+  };
+}
+
 // src/enhancement/localize.ts
 function extractLocales({ component }) {
   var _a;
@@ -1606,17 +2092,29 @@ function extractLocales({ component }) {
 function localize(options) {
   const nodes = "nodes" in options ? options.nodes : options.composition;
   const locale = options.locale;
-  walkNodeTree(nodes, ({ type, node, actions }) => {
+  const isUsingModernOptions = typeof locale === "string";
+  const vizControlLocaleRule = isUsingModernOptions ? createLocaleVisibilityRule(locale) : {};
+  walkNodeTree(nodes, (context) => {
+    const { type, node, actions } = context;
     if (type !== "component") {
-      if (typeof locale === "string") {
-        localizeProperties(node.fields, locale);
+      if (isUsingModernOptions) {
+        localizeProperties(node, locale, vizControlLocaleRule);
       }
       return;
     }
-    const shouldRunPropertyLocalization = typeof locale === "string";
+    if (isUsingModernOptions) {
+      const result = evaluateWalkTreeNodeVisibility({
+        context,
+        rules: vizControlLocaleRule,
+        showIndeterminate: true
+      });
+      if (!result) {
+        return;
+      }
+    }
     if (node.type === CANVAS_LOCALIZATION_TYPE) {
       const locales = extractLocales({ component: node });
-      const resolvedLocale = typeof locale === "string" ? locale : locale == null ? void 0 : locale({ component: node, locales });
+      const resolvedLocale = isUsingModernOptions ? locale : locale == null ? void 0 : locale({ component: node, locales });
       let replaceComponent;
       if (resolvedLocale) {
         replaceComponent = locales[resolvedLocale];
@@ -1624,8 +2122,8 @@ function localize(options) {
       if (replaceComponent == null ? void 0 : replaceComponent.length) {
         replaceComponent.forEach((component) => {
           removeLocaleProperty(component);
-          if (shouldRunPropertyLocalization) {
-            localizeProperties(getPropertiesValue(component), locale);
+          if (isUsingModernOptions) {
+            localizeProperties(component, locale, vizControlLocaleRule);
           }
         });
         const [first, ...rest] = replaceComponent;
@@ -1636,8 +2134,8 @@ function localize(options) {
       } else {
         actions.remove();
       }
-    } else if (shouldRunPropertyLocalization) {
-      localizeProperties(getPropertiesValue(node), locale);
+    } else if (isUsingModernOptions) {
+      localizeProperties(node, locale, vizControlLocaleRule);
     }
   });
 }
@@ -1656,36 +2154,51 @@ function removeLocaleProperty(component) {
     }
   }
 }
-function localizeProperties(properties, locale) {
+function localizeProperties(node, locale, rules) {
+  const properties = getPropertiesValue(node);
   if (!properties) {
     return void 0;
   }
-  Object.entries(properties).forEach(([key, property]) => {
-    var _a;
+  Object.entries(properties).forEach(([propertyId, propertyValue]) => {
+    var _a, _b;
     if (!locale) {
-      delete property.locales;
+      delete propertyValue.locales;
+      delete propertyValue.localesConditions;
     }
-    const currentLocaleValue = locale ? (_a = property.locales) == null ? void 0 : _a[locale] : void 0;
+    const currentLocaleValue = locale ? (_a = propertyValue.locales) == null ? void 0 : _a[locale] : void 0;
     if (currentLocaleValue !== void 0) {
-      property.value = currentLocaleValue;
+      propertyValue.value = currentLocaleValue;
+    }
+    const currentLocaleConditionalValues = locale ? (_b = propertyValue.localesConditions) == null ? void 0 : _b[locale] : void 0;
+    if (currentLocaleConditionalValues !== void 0) {
+      propertyValue.conditions = currentLocaleConditionalValues;
     }
-    delete property.locales;
-    if (property.value === void 0) {
-      delete properties[key];
+    delete propertyValue.locales;
+    delete propertyValue.localesConditions;
+    if (propertyValue.value === void 0 && propertyValue.conditions === void 0) {
+      delete properties[propertyId];
     }
   });
+  evaluateWalkTreePropertyCriteria({
+    node,
+    rules,
+    keepIndeterminate: true
+  });
 }
 
 // src/enhancement/UniqueBatchEntries.ts
 var UniqueBatchEntries = class {
   constructor(entries, uniqueKeySelector) {
-    this.groups = entries.reduce((acc, task) => {
-      var _a;
-      const key = uniqueKeySelector(task.args);
-      acc[key] = (_a = acc[key]) != null ? _a : [];
-      acc[key].push(task);
-      return acc;
-    }, {});
+    this.groups = entries.reduce(
+      (acc, task) => {
+        var _a;
+        const key = uniqueKeySelector(task.args);
+        acc[key] = (_a = acc[key]) != null ? _a : [];
+        acc[key].push(task);
+        return acc;
+      },
+      {}
+    );
   }
   /** Resolves all entries in a group key with the same result value. */
   resolveKey(key, result) {
@@ -1715,8 +2228,7 @@ function walkComponentTree(component, visitor, initialContext) {
   const childContexts = /* @__PURE__ */ new Map();
   do {
     const currentQueueEntry = componentQueue.pop();
-    if (!currentQueueEntry)
-      continue;
+    if (!currentQueueEntry) continue;
     const currentComponent = currentQueueEntry.ancestorsAndSelf[0];
     let visitDescendants = true;
     let descendantContext = (_a = childContexts.get(currentComponent.component)) != null ? _a : currentQueueEntry.context;
@@ -1821,10 +2333,25 @@ function walkComponentTree(component, visitor, initialContext) {
   } while (componentQueue.length > 0);
 }
 
-// src/LocaleClient.ts
+// src/EntityReleasesClient.ts
 import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
+var releaseContentsUrl = "/api/v1/entity-releases";
+var EntityReleasesClient = class extends ApiClient6 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches entity across all releases (and base) */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(releaseContentsUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+};
+
+// src/LocaleClient.ts
+import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
 var localesUrl = "/api/v1/locales";
-var LocaleClient = class extends ApiClient6 {
+var LocaleClient = class extends ApiClient7 {
   constructor(options) {
     super(options);
   }
@@ -1930,6 +2457,9 @@ var isRequestComponentSuggestionMessage = (message) => {
 var isSuggestComponentMessage = (message) => {
   return message.type === "suggest-component";
 };
+var isContextStorageUpdatedMessage = (message) => {
+  return message.type === "context-storage-command-executed";
+};
 var createCanvasChannel = ({
   listenTo,
   broadcastTo
@@ -1939,6 +2469,12 @@ var createCanvasChannel = ({
   const broadcastToItems = [...broadcastTo];
   const postMessage = (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 = {
@@ -1979,15 +2515,17 @@ var createCanvasChannel = ({
       hash: generateHash({
         composition,
         secret
-      })
+      }),
+      eventTimestamp: Date.now()
     };
     postMessage(message);
   };
-  const updateCompositionInternal = (composition, hash) => {
+  const updateCompositionInternal = (composition, hash, eventTimestamp) => {
     const message = {
       type: "update-composition-internal",
       composition,
-      hash
+      hash,
+      eventTimestamp: eventTimestamp != null ? eventTimestamp : Date.now()
     };
     postMessage(message);
   };
@@ -2102,6 +2640,13 @@ var createCanvasChannel = ({
     };
     postMessage(message);
   };
+  const contextStorageUpdated = (options) => {
+    const message = {
+      ...options,
+      type: "context-storage-command-executed"
+    };
+    postMessage(message);
+  };
   const messageEventListener = (event) => {
     if (typeof event.data !== "string") {
       return;
@@ -2129,6 +2674,7 @@ var createCanvasChannel = ({
     listenTo.forEach((item) => item.removeEventListener("message", messageEventListener));
   };
   return {
+    broadcastTo,
     ready,
     destroy,
     triggerComponentAction,
@@ -2150,7 +2696,8 @@ var createCanvasChannel = ({
     editorStateUpdated,
     updateComponentReferences,
     requestComponentSuggestion,
-    suggestComponent
+    suggestComponent,
+    contextStorageUpdated
   };
 };
 
@@ -2233,9 +2780,9 @@ function subscribeToComposition({
 }
 
 // src/PromptClient.ts
-import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
 var PromptsUrl = "/api/v1/prompts";
-var PromptClient = class extends ApiClient7 {
+var PromptClient = class extends ApiClient8 {
   constructor(options) {
     super(options);
   }
@@ -2266,9 +2813,9 @@ var PromptClient = class extends ApiClient7 {
 };
 
 // src/RelationshipClient.ts
-import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
 var RELATIONSHIPS_URL = "/api/v1/relationships";
-var RelationshipClient = class extends ApiClient8 {
+var RelationshipClient = class extends ApiClient9 {
   constructor(options) {
     super(options);
     this.get = async (options) => {
@@ -2276,56 +2823,13 @@ var RelationshipClient = class extends ApiClient8 {
       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";
+import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
 var releasesUrl = "/api/v1/releases";
-var ReleaseClient = class extends ApiClient9 {
+var ReleaseClient = class extends ApiClient10 {
   constructor(options) {
     super(options);
   }
@@ -2365,21 +2869,21 @@ var ReleaseClient = class extends ApiClient9 {
 };
 
 // src/ReleaseContentsClient.ts
-import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
-var releaseContentsUrl = "/api/v1/release-contents";
-var ReleaseContentsClient = class extends ApiClient10 {
+import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
+var releaseContentsUrl2 = "/api/v1/release-contents";
+var ReleaseContentsClient = class extends ApiClient11 {
   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 });
+    const fetchUri = this.createUrl(releaseContentsUrl2, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
   /** Removes a release content from a release */
   async remove(body) {
-    const fetchUri = this.createUrl(releaseContentsUrl);
+    const fetchUri = this.createUrl(releaseContentsUrl2);
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -2389,9 +2893,9 @@ var ReleaseContentsClient = class extends ApiClient10 {
 };
 
 // src/RouteClient.ts
-import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient12 } from "@uniformdev/context/api";
 var ROUTE_URL = "/api/v1/route";
-var RouteClient = class extends ApiClient11 {
+var RouteClient = class extends ApiClient12 {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -2454,7 +2958,9 @@ function convertEntryToPutEntry(entry) {
     pattern: entry.pattern,
     state: entry.state,
     projectId: entry.projectId,
-    releaseId: entry.releaseId
+    releaseId: entry.releaseId,
+    workflowId: entry.workflowId,
+    workflowStageId: entry.workflowStageId
   };
 }
 
@@ -2500,8 +3006,7 @@ var isSystemComponentDefinition = (componentType) => {
 
 // src/utils/mapSlotToPersonalizedVariations.ts
 function mapSlotToPersonalizedVariations(slot) {
-  if (!slot)
-    return [];
+  if (!slot) return [];
   return slot.map((v, i) => {
     var _a, _b;
     const contextTag = (_b = (_a = v.parameters) == null ? void 0 : _a[CANVAS_PERSONALIZATION_PARAM]) == null ? void 0 : _b.value;
@@ -2516,8 +3021,7 @@ function mapSlotToPersonalizedVariations(slot) {
 
 // src/utils/mapSlotToTestVariations.ts
 function mapSlotToTestVariations(slot) {
-  if (!slot)
-    return [];
+  if (!slot) return [];
   return slot.map((v, i) => {
     var _a, _b, _c;
     const contextTag = (_b = (_a = v.parameters) == null ? void 0 : _a[CANVAS_TEST_VARIANT_PARAM]) == null ? void 0 : _b.value;
@@ -2542,7 +3046,7 @@ var isComponentPlaceholderId = (id) => {
   return id == null ? void 0 : id.startsWith(PLACEHOLDER_ID);
 };
 var generateComponentPlaceholderId = (randomId, sdkVersion, parent) => {
-  if (typeof sdkVersion === "undefined" || sdkVersion === 1) {
+  if (sdkVersion === 1) {
     return PLACEHOLDER_ID;
   }
   let idParts = [PLACEHOLDER_ID, randomId];
@@ -2568,72 +3072,6 @@ var parseComponentPlaceholderId = (id) => {
   return result;
 };
 
-// src/utils/variables/parseVariableExpression.ts
-var escapeCharacter = "\\";
-var variablePrefix = "${";
-var variableSuffix = "}";
-function parseVariableExpression(serialized, onToken) {
-  let bufferStartIndex = 0;
-  let bufferEndIndex = 0;
-  let tokenCount = 0;
-  const handleToken = (token, type) => {
-    tokenCount++;
-    return onToken == null ? void 0 : onToken(token, type);
-  };
-  let state = "text";
-  for (let index = 0; index < serialized.length; index++) {
-    const char = serialized[index];
-    if (bufferStartIndex > bufferEndIndex) {
-      bufferEndIndex = bufferStartIndex;
-    }
-    if (char === variablePrefix[0] && serialized[index + 1] === variablePrefix[1]) {
-      if (serialized[index - 1] === escapeCharacter) {
-        bufferEndIndex -= escapeCharacter.length;
-        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
-          return tokenCount;
-        }
-        bufferStartIndex = index;
-        bufferEndIndex = index + 1;
-        continue;
-      }
-      state = "variable";
-      if (bufferEndIndex > bufferStartIndex) {
-        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
-          return tokenCount;
-        }
-        bufferStartIndex = bufferEndIndex;
-      }
-      index += variablePrefix.length - 1;
-      bufferStartIndex += variablePrefix.length;
-      continue;
-    }
-    if (char === variableSuffix && state === "variable") {
-      if (serialized[index - 1] === escapeCharacter) {
-        bufferEndIndex++;
-        continue;
-      }
-      state = "text";
-      if (bufferEndIndex > bufferStartIndex) {
-        const unescapedVariableName = serialized.substring(bufferStartIndex, bufferEndIndex).replace(/\\([${}])/g, "$1");
-        if (handleToken(unescapedVariableName, "variable") === false) {
-          return tokenCount;
-        }
-        bufferStartIndex = bufferEndIndex + variableSuffix.length;
-      }
-      continue;
-    }
-    bufferEndIndex++;
-  }
-  if (bufferEndIndex > bufferStartIndex) {
-    if (state === "variable") {
-      state = "text";
-      bufferStartIndex -= variablePrefix.length;
-    }
-    handleToken(serialized.substring(bufferStartIndex), state);
-  }
-  return tokenCount;
-}
-
 // src/utils/variables/bindVariables.ts
 function bindVariables({
   variables,
@@ -2671,7 +3109,7 @@ function bindVariables({
 }
 
 // src/utils/variables/bindVariablesToObject.ts
-import { produce } from "immer";
+import { isDraft, produce } from "immer";
 
 // src/utils/variables/createVariableReference.ts
 function createVariableReference(variableName) {
@@ -2699,7 +3137,11 @@ function bindVariablesToObjectRecursive({
   if (richTextNodeResult !== void 0) {
     return richTextNodeResult;
   }
-  const result = produce(value, (draft) => {
+  const produceToUse = !isDraft(value) ? produce : (produceValue, producer) => {
+    producer(produceValue);
+    return produceValue;
+  };
+  const result = produceToUse(value, (draft) => {
     Object.entries(draft).forEach(([property, oldValue]) => {
       const currentObjectPath = recursivePath ? `${recursivePath}.${property}` : property;
       if (typeof oldValue === "string") {
@@ -2757,6 +3199,41 @@ function handleRichTextNodeBinding(object, options) {
 
 // src/index.ts
 import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
+
+// src/WorkflowClient.ts
+import { ApiClient as ApiClient13 } from "@uniformdev/context/api";
+var workflowsUrl = "/api/v1/workflows";
+var WorkflowClient = class extends ApiClient13 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches workflows for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(workflowsUrl, { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates a workflow definition */
+  async upsert(body) {
+    const fetchUri = this.createUrl(workflowsUrl);
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a workflow definition */
+  async remove(body) {
+    const fetchUri = this.createUrl(workflowsUrl);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/index.ts
 var CanvasClientError = ApiClientError2;
 export {
   ASSETS_SOURCE_CUSTOM_URL,
@@ -2770,6 +3247,7 @@ export {
   ATTRIBUTE_PLACEHOLDER,
   ApiClientError2 as ApiClientError,
   BatchEntry,
+  BlockFormatError,
   CANVAS_BLOCK_PARAM_TYPE,
   CANVAS_DRAFT_STATE,
   CANVAS_EDITOR_STATE,
@@ -2787,6 +3265,11 @@ export {
   CANVAS_TEST_SLOT,
   CANVAS_TEST_TYPE,
   CANVAS_TEST_VARIANT_PARAM,
+  CANVAS_VIZ_CONTROL_PARAM,
+  CANVAS_VIZ_DI_RULE,
+  CANVAS_VIZ_DYNAMIC_TOKEN_RULE,
+  CANVAS_VIZ_LOCALE_RULE,
+  CANVAS_VIZ_QUIRKS_RULE,
   CanvasClient,
   CanvasClientError,
   CategoryClient,
@@ -2800,6 +3283,7 @@ export {
   EDGE_MIN_CACHE_TTL,
   EMPTY_COMPOSITION,
   EnhancerBuilder,
+  EntityReleasesClient,
   IN_CONTEXT_EDITOR_COMPONENT_END_ROLE,
   IN_CONTEXT_EDITOR_COMPONENT_START_ROLE,
   IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM,
@@ -2821,17 +3305,27 @@ export {
   UncachedCategoryClient,
   UncachedContentClient,
   UniqueBatchEntries,
+  WorkflowClient,
   bindVariables,
   bindVariablesToObject,
   compose,
   convertEntryToPutEntry,
   createBatchEnhancer,
   createCanvasChannel,
+  createDynamicInputVisibilityRule,
+  createDynamicTokenVisibilityRule,
   createEventBus,
   createLimitPolicy,
+  createLocaleVisibilityRule,
+  createQuirksVisibilityRule,
   createUniformApiEnhancer,
   createVariableReference,
   enhance,
+  evaluateNodeVisibilityParameter,
+  evaluatePropertyCriteria,
+  evaluateVisibilityCriteriaGroup,
+  evaluateWalkTreeNodeVisibility,
+  evaluateWalkTreePropertyCriteria,
   extractLocales,
   findParameterInNodeTree,
   flattenValues,
@@ -2841,19 +3335,23 @@ export {
   getChannelName,
   getComponentJsonPointer,
   getComponentPath,
+  getLocalizedPropertyValues,
   getNounForLocation,
   getNounForNode,
   getParameterAttributes,
   getPropertiesValue,
   getPropertyValue,
+  hasReferencedVariables,
   isAddComponentMessage,
   isAllowedReferrer,
   isAssetParamValue,
   isAssetParamValueItem,
   isComponentActionMessage,
   isComponentPlaceholderId,
+  isContextStorageUpdatedMessage,
   isDismissPlaceholderMessage,
   isEntryData,
+  isLinkParamValue,
   isMovingComponentMessage,
   isNestedNodeType,
   isOpenParameterEditorMessage,