@qrvey/widget-configurability 0.0.0-beta.4589 → 0.0.0-beta.4657

package/dist/esm/index.mjs

@@ -128,6 +128,7 @@ var fontSizeMinMaxValue = /* @__PURE__ */ __name((minSize, maxSize) => (value) =
   return `${closestSize}px`;
 }, "fontSizeMinMaxValue");
 var fontColorValue = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "string") return void 0;
   const normalizedColor = value.toLowerCase();
   return normalizedColor;
 }, "fontColorValue");
@@ -1060,9 +1061,9 @@ __name(checkConditions, "checkConditions");
 
 // src/utils/merge.helpers.ts
 function mergeDeep(obj1, obj2, settings) {
-  var _a, _b;
+  var _a2, _b;
   const defaultSettings = {
-    mergeExistingValues: (_a = settings == null ? void 0 : settings.mergeExistingValues) != null ? _a : true,
+    mergeExistingValues: (_a2 = settings == null ? void 0 : settings.mergeExistingValues) != null ? _a2 : true,
     mergeMissingProperties: (_b = settings == null ? void 0 : settings.mergeMissingProperties) != null ? _b : true
   };
   if (!isValid(obj1, obj2)) return objectCopy(obj1);
@@ -1111,6 +1112,164 @@ function isObject(value) {
 }
 __name(isObject, "isObject");
 
+// src/utils/layers.helpers.ts
+var SUBMODULES_KEY = "subModules";
+var isPlainObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]", "isPlainObject");
+var stringList = /* @__PURE__ */ __name((value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0, "stringList");
+function normalizeCondition(value) {
+  if (!isPlainObject(value)) return void 0;
+  const { field, operator, value: conditionValue } = value;
+  if (typeof field !== "string") return void 0;
+  if (!allowedOperators.includes(operator)) return void 0;
+  if (typeof conditionValue !== "string" && typeof conditionValue !== "number") return void 0;
+  return {
+    field,
+    operator,
+    value: conditionValue
+  };
+}
+__name(normalizeCondition, "normalizeCondition");
+function normalizeSubmodules(value) {
+  if (!isPlainObject(value)) return void 0;
+  const result = {};
+  Object.keys(value).forEach((name) => {
+    const submodule = normalizeLayer(value[name]);
+    if (submodule) result[name] = submodule;
+  });
+  return result;
+}
+__name(normalizeSubmodules, "normalizeSubmodules");
+function normalizeLayer(value, allowViews = true) {
+  if (!isPlainObject(value)) return void 0;
+  const layer = {};
+  const remove = stringList(value.remove);
+  const keep = stringList(value.keep);
+  if (remove) layer.remove = remove;
+  if (keep) layer.keep = keep;
+  if (isPlainObject(value.defaults)) layer.defaults = value.defaults;
+  const subModules = normalizeSubmodules(value.subModules);
+  if (subModules) layer.subModules = subModules;
+  if (Array.isArray(value.conditional)) {
+    layer.conditional = value.conditional.flatMap((item) => {
+      const condition = isPlainObject(item) ? normalizeCondition(item.condition) : void 0;
+      const rest = condition ? normalizeLayer(item, false) : void 0;
+      return condition && rest ? [
+        __spreadProps(__spreadValues({}, rest), {
+          condition
+        })
+      ] : [];
+    });
+  }
+  if (allowViews && isPlainObject(value.views)) {
+    const views = value.views;
+    layer.views = {};
+    Object.keys(views).forEach((view) => {
+      const viewLayer = normalizeLayer(views[view], false);
+      if (viewLayer) layer.views[view] = viewLayer;
+    });
+  }
+  return layer;
+}
+__name(normalizeLayer, "normalizeLayer");
+function mergeDefaults(previous, next) {
+  if (!isPlainObject(next)) return previous;
+  return previous ? mergeDeep(previous, next) : next;
+}
+__name(mergeDefaults, "mergeDefaults");
+function mergeLayerDefaults(layers) {
+  var _a2;
+  const last = (_a2 = layers[layers.length - 1]) != null ? _a2 : {};
+  const viewNames = new Set(layers.flatMap((layer) => {
+    var _a3;
+    return Object.keys((_a3 = layer.views) != null ? _a3 : {});
+  }));
+  const rootDefaults = layers.reduce((merged, layer) => mergeDefaults(merged, layer.defaults), void 0);
+  const views = __spreadValues({}, last.views);
+  viewNames.forEach((view) => {
+    var _a3;
+    const viewDefaults = layers.reduce((merged, layer) => {
+      var _a4, _b;
+      return mergeDefaults(mergeDefaults(merged, layer.defaults), (_b = (_a4 = layer.views) == null ? void 0 : _a4[view]) == null ? void 0 : _b.defaults);
+    }, void 0);
+    if (viewDefaults) {
+      views[view] = __spreadProps(__spreadValues({}, (_a3 = last.views) == null ? void 0 : _a3[view]), {
+        defaults: viewDefaults
+      });
+    }
+  });
+  const effective = __spreadValues({}, last);
+  if (rootDefaults) effective.defaults = rootDefaults;
+  if (viewNames.size) effective.views = views;
+  return effective;
+}
+__name(mergeLayerDefaults, "mergeLayerDefaults");
+var isSubmodulesKey = /* @__PURE__ */ __name((key) => key === SUBMODULES_KEY || key.endsWith(`::${SUBMODULES_KEY}`), "isSubmodulesKey");
+var asItemObject = /* @__PURE__ */ __name((value) => isPlainObject(value) ? value : {}, "asItemObject");
+function intersectItem(current, other) {
+  var _a2, _b, _c;
+  const item = asItemObject(current);
+  const otherItem = asItemObject(other);
+  const childMap = item.childMap ? intersectViewMaps(item.childMap, (_a2 = otherItem.childMap) != null ? _a2 : {}) : void 0;
+  const conditions = [
+    ...(_b = otherItem.conditions) != null ? _b : [],
+    ...(_c = item.conditions) != null ? _c : []
+  ];
+  const hasDefaults = !!item.defaults && Object.keys(item.defaults).length > 0;
+  const hasChildMap = !!childMap && Object.keys(childMap).length > 0;
+  if (!hasDefaults && !hasChildMap && !conditions.length) {
+    return isPlainObject(current) ? true : current;
+  }
+  return __spreadValues(__spreadValues(__spreadValues({}, hasDefaults && {
+    defaults: item.defaults
+  }), hasChildMap && {
+    childMap
+  }), conditions.length && {
+    conditions
+  });
+}
+__name(intersectItem, "intersectItem");
+function intersectViewMaps(current, other) {
+  const result = {};
+  Object.keys(current).forEach((key) => {
+    if (isSubmodulesKey(key)) {
+      result[key] = current[key];
+    } else if (key in other) {
+      result[key] = intersectItem(current[key], other[key]);
+    }
+  });
+  return result;
+}
+__name(intersectViewMaps, "intersectViewMaps");
+function collectSubmoduleLayers(maps) {
+  const result = {};
+  maps.forEach((map) => {
+    Object.keys(map).filter(isSubmodulesKey).forEach((key) => {
+      const collection = map[key];
+      if (!isPlainObject(collection)) return;
+      Object.keys(collection).forEach((name) => {
+        var _a2, _b;
+        const submodule = collection[name];
+        if (!isPlainObject(submodule)) return;
+        if (!Object.keys(submodule).length) return;
+        result[key] = (_a2 = result[key]) != null ? _a2 : {};
+        result[key][name] = [
+          ...(_b = result[key][name]) != null ? _b : [],
+          submodule
+        ];
+      });
+    });
+  });
+  return Object.keys(result).length ? result : void 0;
+}
+__name(collectSubmoduleLayers, "collectSubmoduleLayers");
+
+// src/utils/logger.helpers.ts
+var LOG_PREFIX = "[widget-configurability]";
+function logWarning(message) {
+  console.warn(`${LOG_PREFIX} ${message}`);
+}
+__name(logWarning, "logWarning");
+
 // src/utils/structural.helpers.ts
 function getWidgetStructure(config, customization, validationMap, options) {
   return calculateViewMap(config.baseStructure, customization, validationMap, __spreadProps(__spreadValues({}, options), {
@@ -1220,8 +1379,8 @@ function canInsertInCustomization(key, customization, validateKeepOption, keepAl
 }
 __name(canInsertInCustomization, "canInsertInCustomization");
 function evalInsertKey(key, { viewKeys, viewPrefix = "", hasKeepOption, keepAliases }, customization) {
-  var _a;
-  const customizationView = (_a = customization == null ? void 0 : customization.views) == null ? void 0 : _a[viewPrefix];
+  var _a2;
+  const customizationView = (_a2 = customization == null ? void 0 : customization.views) == null ? void 0 : _a2[viewPrefix];
   const custCanInsert = customization ? canInsertInCustomization(key, customization, hasKeepOption === "root", keepAliases) : {
     canInsert: true,
     conditionAffect: false
@@ -1352,9 +1511,9 @@ function getConditionsForKey(key, conditionMaps) {
 }
 __name(getConditionsForKey, "getConditionsForKey");
 function calculateConditions(config, customization, view, keepAliases) {
-  var _a, _b, _c;
+  var _a2, _b, _c;
   const rootConditionals = customization == null ? void 0 : customization.conditional;
-  const viewConditionals = view ? (_b = (_a = customization == null ? void 0 : customization.views) == null ? void 0 : _a[view]) == null ? void 0 : _b.conditional : void 0;
+  const viewConditionals = view ? (_b = (_a2 = customization == null ? void 0 : customization.views) == null ? void 0 : _a2[view]) == null ? void 0 : _b.conditional : void 0;
   if (!rootConditionals && !viewConditionals) return void 0;
   const customConditionals = [
     ...rootConditionals != null ? rootConditionals : [],
@@ -1370,16 +1529,16 @@ function calculateConditions(config, customization, view, keepAliases) {
 }
 __name(calculateConditions, "calculateConditions");
 function calculateSubmodules(config, customization, view) {
-  var _a, _b;
-  const viewSubmodules = view ? (_b = (_a = customization == null ? void 0 : customization.views) == null ? void 0 : _a[view]) == null ? void 0 : _b.subModules : void 0;
+  var _a2, _b;
+  const viewSubmodules = view ? (_b = (_a2 = customization == null ? void 0 : customization.views) == null ? void 0 : _a2[view]) == null ? void 0 : _b.subModules : void 0;
   const customRootSubmodules = customization == null ? void 0 : customization.subModules;
   const customSubmodules = viewSubmodules ? mergeObjects(customRootSubmodules, viewSubmodules) : customRootSubmodules;
   return mergeObjects(config.subModules, customSubmodules);
 }
 __name(calculateSubmodules, "calculateSubmodules");
 function calculateCustomDefaults(customization, view, validationMap, sanitize) {
-  var _a, _b, _c;
-  const viewDefaults = view ? (_b = (_a = customization == null ? void 0 : customization.views) == null ? void 0 : _a[view]) == null ? void 0 : _b.defaults : void 0;
+  var _a2, _b, _c;
+  const viewDefaults = view ? (_b = (_a2 = customization == null ? void 0 : customization.views) == null ? void 0 : _a2[view]) == null ? void 0 : _b.defaults : void 0;
   const customRootDefaults = (_c = customization == null ? void 0 : customization.defaults) != null ? _c : {};
   const defaultObj = viewDefaults ? mergeObjects(customRootDefaults, viewDefaults) : customRootDefaults;
   if (!defaultObj || !validationMap && !sanitize) return defaultObj;
@@ -1416,7 +1575,7 @@ function mapArrayKeys(configValue, { viewPrefix, pathPrefix }) {
 }
 __name(mapArrayKeys, "mapArrayKeys");
 function nodeHasKeepOption(configValue, customization, { viewPrefix, pathPrefix }) {
-  var _a;
+  var _a2;
   if (!customization) return;
   const nodeKeys = Array.isArray(configValue) ? mapArrayKeys(configValue, {
     viewPrefix,
@@ -1424,7 +1583,7 @@ function nodeHasKeepOption(configValue, customization, { viewPrefix, pathPrefix
   }) : mapObjKeys(configValue, {
     pathPrefix
   });
-  const customizationView = viewPrefix ? (_a = customization == null ? void 0 : customization.views) == null ? void 0 : _a[viewPrefix] : void 0;
+  const customizationView = viewPrefix ? (_a2 = customization == null ? void 0 : customization.views) == null ? void 0 : _a2[viewPrefix] : void 0;
   for (const key of nodeKeys) {
     if (keyIsIncludedInKeep(key, customization)) {
       return "root";
@@ -1480,9 +1639,9 @@ __name(calculatePermissionMapArray, "calculatePermissionMapArray");
 
 // src/structural-manager.ts
 function getWidgetConfig(widget, version) {
-  var _a;
+  var _a2;
   const versionSet = version != null ? version : WidgetVersion.latest;
-  const widgetConfigurability = (_a = widgetConfigs[widget]) == null ? void 0 : _a[versionSet];
+  const widgetConfigurability = (_a2 = widgetConfigs[widget]) == null ? void 0 : _a2[versionSet];
   if (!widgetConfigurability) {
     throw new Error(`No config found for widget ${widget} and version ${version}`);
   }
@@ -1490,20 +1649,45 @@ function getWidgetConfig(widget, version) {
 }
 __name(getWidgetConfig, "getWidgetConfig");
 function buildStructure(widget, customization, version, options) {
-  var _a;
+  var _a2, _b;
   const config = getWidgetConfig(widget, version);
-  const validationMap = (_a = options == null ? void 0 : options.validationMap) != null ? _a : widgetValidators[widget];
+  const validationMap = (_a2 = options == null ? void 0 : options.validationMap) != null ? _a2 : widgetValidators[widget];
+  const layers = ((_b = options == null ? void 0 : options.layers) != null ? _b : []).map((layer) => normalizeLayer(layer)).filter((layer) => !!layer);
+  if (layers.length) {
+    try {
+      return buildLayeredStructure(config, layers, customization, validationMap, options);
+    } catch (error) {
+      logWarning(`ignoring the ${widget} customization layers: ${error.message}`);
+    }
+  }
   const structureMap = getWidgetStructure(config, customization, validationMap, options);
   const rootDefaults = config.baseStructure.views ? void 0 : calculateRootDefaults(config.baseStructure, customization, validationMap, options == null ? void 0 : options.sanitize);
   return new WidgetStructureInstance(structureMap, rootDefaults);
 }
 __name(buildStructure, "buildStructure");
+function buildLayeredStructure(config, layers, customization, validationMap, options) {
+  const inline = isPlainObject(customization) ? customization : {};
+  const effective = mergeLayerDefaults([
+    ...layers,
+    inline
+  ]);
+  const engineOptions = {
+    viewConditionals: options == null ? void 0 : options.viewConditionals
+  };
+  const layerMaps = layers.map((layer) => getWidgetStructure(config, layer, void 0, engineOptions));
+  const structureMap = layerMaps.reduce((result, layerMap) => intersectViewMaps(result, layerMap), getWidgetStructure(config, effective, validationMap, options));
+  const rootDefaults = config.baseStructure.views ? void 0 : calculateRootDefaults(config.baseStructure, effective, validationMap, options == null ? void 0 : options.sanitize);
+  return new WidgetStructureInstance(structureMap, rootDefaults, collectSubmoduleLayers(layerMaps));
+}
+__name(buildLayeredStructure, "buildLayeredStructure");
 var _WidgetStructureInstance = class _WidgetStructureInstance {
-  constructor(viewMap, rootDefaults) {
+  constructor(viewMap, rootDefaults, submoduleLayers) {
     __publicField(this, "viewMap");
     __publicField(this, "rootDefaults");
+    __publicField(this, "submoduleLayers");
     this.viewMap = viewMap;
     this.rootDefaults = rootDefaults;
+    this.submoduleLayers = submoduleLayers;
   }
   getValue(key) {
     return this.viewMap[key];
@@ -1526,6 +1710,14 @@ var _WidgetStructureInstance = class _WidgetStructureInstance {
     const value = this.getValue(key);
     return value == null ? void 0 : value[module2];
   }
+  /**
+   * Submodule customizations of the stored layers, to pass as layers when building the embedded widget (structureFromSubmodule).
+   */
+  getSubmoduleLayers(module2, view) {
+    var _a2, _b;
+    const key = `${view ? view + "::" : ""}subModules`;
+    return (_b = (_a2 = this.submoduleLayers) == null ? void 0 : _a2[key]) == null ? void 0 : _b[module2];
+  }
   getDefaults(key) {
     const value = this.getValue(key);
     if (!value || typeof value === "boolean" || typeof value === "string" || !value.defaults) return void 0;
@@ -1538,10 +1730,10 @@ var _WidgetStructureInstance = class _WidgetStructureInstance {
    * Re-roots a resolved section (`design::downloadModal`) as plain JSON another bundle can rebuild a structure from.
    */
   scope(prefixKey, options = {}) {
-    var _a;
+    var _a2;
     const { widget, version, state } = options;
     const present = this.isVisible(prefixKey, state);
-    const sectionPath = (_a = prefixKey.split(STRUCTURE_VIEW_NAME_SEPARATOR).pop()) != null ? _a : prefixKey;
+    const sectionPath = (_a2 = prefixKey.split(STRUCTURE_VIEW_NAME_SEPARATOR).pop()) != null ? _a2 : prefixKey;
     const namespace = options.defaultsNamespace === void 0 ? sectionPath.split(STRUCTURE_SECTION_NAME_SEPARATOR).pop() : options.defaultsNamespace;
     const sectionDefaults = present ? this.getDefaults(prefixKey) : void 0;
     const defaults = namespace ? sectionDefaults == null ? void 0 : sectionDefaults[namespace] : sectionDefaults;
@@ -1577,14 +1769,14 @@ __name(_WidgetStructureInstance, "WidgetStructureInstance");
 var WidgetStructureInstance = _WidgetStructureInstance;
 
 // src/utils/scope.helpers.ts
-var isPlainObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isPlainObject");
+var isPlainObject2 = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isPlainObject");
 function isWidgetStructureScope(value) {
-  return isPlainObject(value) && value.kind === WIDGET_STRUCTURE_SCOPE_KIND;
+  return isPlainObject2(value) && value.kind === WIDGET_STRUCTURE_SCOPE_KIND;
 }
 __name(isWidgetStructureScope, "isWidgetStructureScope");
 function scopeToCustomization(scope) {
-  var _a;
-  const remove = scope.present ? Object.keys((_a = scope.map) != null ? _a : {}).filter((key) => scope.map[key] === false) : [
+  var _a2;
+  const remove = scope.present ? Object.keys((_a2 = scope.map) != null ? _a2 : {}).filter((key) => scope.map[key] === false) : [
     "*"
   ];
   return __spreadValues(__spreadValues({}, remove.length ? {
@@ -1602,8 +1794,8 @@ function extractCustomization(host, customization, prefixKey, target, options) {
 }
 __name(extractCustomization, "extractCustomization");
 function submoduleOf(input, module2, view) {
-  var _a, _b, _c, _d;
-  const root = (_a = input.subModules) == null ? void 0 : _a[module2];
+  var _a2, _b, _c, _d;
+  const root = (_a2 = input.subModules) == null ? void 0 : _a2[module2];
   const fromView = view ? (_d = (_c = (_b = input.views) == null ? void 0 : _b[view]) == null ? void 0 : _c.subModules) == null ? void 0 : _d[module2] : void 0;
   if (!fromView) return root;
   return root ? mergeDeep(root, fromView) : fromView;
@@ -1612,7 +1804,7 @@ __name(submoduleOf, "submoduleOf");
 function structureFrom(widget, input, view, version) {
   if (input === void 0 || input === null) return void 0;
   try {
-    if (!isPlainObject(input)) {
+    if (!isPlainObject2(input)) {
       throw new Error("expected an object");
     }
     if ("kind" in input) {
@@ -1638,14 +1830,640 @@ function structureFrom(widget, input, view, version) {
 }
 __name(structureFrom, "structureFrom");
 function structureFromSubmodule(parent, module2, view, options) {
+  var _a2;
   const widget = Object.keys(WIDGET_SUBMODULE_NAMES).find((key) => WIDGET_SUBMODULE_NAMES[key] === module2);
   if (!widget) {
     throw new Error(`No widget registered for the submodule ${module2}`);
   }
-  return buildStructure(widget, parent.getSubmodule(module2, view), void 0, options);
+  const layers = parent.getSubmoduleLayers(module2, view);
+  return buildStructure(widget, parent.getSubmodule(module2, view), void 0, layers ? __spreadProps(__spreadValues({}, options), {
+    layers: [
+      ...(_a2 = options == null ? void 0 : options.layers) != null ? _a2 : [],
+      ...layers
+    ]
+  }) : options);
 }
 __name(structureFromSubmodule, "structureFromSubmodule");
 
+// src/validation/customization.validator.ts
+var ROOT_PROPERTIES = [
+  "remove",
+  "keep",
+  "defaults",
+  "subModules",
+  "conditional",
+  "views"
+];
+var VIEW_PROPERTIES = [
+  "remove",
+  "keep",
+  "defaults",
+  "subModules",
+  "conditional"
+];
+var CONDITIONAL_PROPERTIES = [
+  "condition",
+  "remove",
+  "keep",
+  "defaults",
+  "subModules"
+];
+var CONDITION_PROPERTIES = [
+  "field",
+  "operator",
+  "value"
+];
+var KEY_CHARS = /^[A-Za-z0-9_.-]+$/;
+var ROOT_SCOPE = "";
+var oneOf = /* @__PURE__ */ __name((values) => (value) => typeof value === "string" && values.includes(value) ? value : void 0, "oneOf");
+var DX_WRITE_VALIDATOR_MAP = {
+  changeLayout: validateBoolean,
+  removeElement: validateBoolean,
+  dragElement: validateBoolean,
+  resizeElement: validateBoolean,
+  assetListViewMode: oneOf([
+    "card",
+    "table"
+  ]),
+  "downloadModal.exportVersion": oneOf([
+    "saved",
+    "unsaved"
+  ])
+};
+var writeValidators = {
+  [Widget.DASHBOARD]: __spreadValues(__spreadValues({}, widgetValidators[Widget.DASHBOARD]), DX_WRITE_VALIDATOR_MAP)
+};
+var keyCache = /* @__PURE__ */ new Map();
+function structureKeys(config) {
+  const cached = keyCache.get(config);
+  if (cached) return cached;
+  const byView = /* @__PURE__ */ new Map([
+    [
+      ROOT_SCOPE,
+      /* @__PURE__ */ new Set()
+    ]
+  ]);
+  Object.keys(calculateViewMap(config.baseStructure)).forEach((entry) => {
+    const separator = entry.indexOf(STRUCTURE_VIEW_NAME_SEPARATOR);
+    const view = separator >= 0 ? entry.slice(0, separator) : ROOT_SCOPE;
+    const key = separator >= 0 ? entry.slice(separator + STRUCTURE_VIEW_NAME_SEPARATOR.length) : entry;
+    if (key === "subModules") return;
+    if (!byView.has(view)) byView.set(view, /* @__PURE__ */ new Set());
+    byView.get(view).add(key);
+    byView.get(ROOT_SCOPE).add(key);
+  });
+  keyCache.set(config, byView);
+  return byView;
+}
+__name(structureKeys, "structureKeys");
+function resolveConfig(widget, version) {
+  const versions = widgetConfigs[widget];
+  if (!versions) return void 0;
+  if (!version) return versions[WidgetVersion.latest];
+  const match = Object.keys(versions).find((key) => {
+    var _a2;
+    return key === version || ((_a2 = versions[key]) == null ? void 0 : _a2.version) === version;
+  });
+  return match ? versions[match] : void 0;
+}
+__name(resolveConfig, "resolveConfig");
+function createScope(widget, config) {
+  var _a2, _b;
+  return {
+    widget,
+    config,
+    keys: structureKeys(config),
+    views: Object.keys((_a2 = config.baseStructure.views) != null ? _a2 : {}),
+    subModules: Object.keys((_b = config.baseStructure.subModules) != null ? _b : {})
+  };
+}
+__name(createScope, "createScope");
+function levenshtein(a, b) {
+  const previous = Array.from({
+    length: b.length + 1
+  }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = previous[j];
+      previous[j] = Math.min(previous[j] + 1, previous[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return previous[b.length];
+}
+__name(levenshtein, "levenshtein");
+function suggestKey(key, candidates) {
+  const leaf = key.split(".").pop();
+  let best;
+  let bestDistance = Math.max(2, Math.floor(key.length * 0.3)) + 1;
+  for (const candidate of candidates) {
+    if (candidate.split(".").pop() === leaf && candidate !== key) return candidate;
+    const distance = levenshtein(key.toLowerCase(), candidate.toLowerCase());
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+__name(suggestKey, "suggestKey");
+function formatCustomizationPath(path) {
+  return path.reduce((result, part) => typeof part === "number" ? `${result}[${part}]` : result ? `${result}.${part}` : part, "");
+}
+__name(formatCustomizationPath, "formatCustomizationPath");
+var _a;
+var Collector = (_a = class {
+  constructor() {
+    __publicField(this, "errors", []);
+  }
+  add(path, code, message, suggestion) {
+    this.errors.push(__spreadValues({
+      path,
+      code,
+      severity: "error",
+      message
+    }, suggestion && {
+      suggestion
+    }));
+  }
+}, __name(_a, "Collector"), _a);
+var describeScope = /* @__PURE__ */ __name((scope, view) => {
+  const owner = scope.widget === Widget.DASHBOARD ? "" : ` of the ${scope.widget}`;
+  if (view !== ROOT_SCOPE) return `in the ${view} view${owner}`;
+  return scope.views.length ? `in any view${owner}` : `in the ${scope.widget} structure`;
+}, "describeScope");
+function patternError(pattern) {
+  if (!pattern.trim()) return "Empty key";
+  if (!pattern.includes("*")) {
+    return KEY_CHARS.test(pattern) && !pattern.includes("..") ? void 0 : `Key '${pattern}' contains characters that are not allowed`;
+  }
+  if (pattern === "*") return void 0;
+  const inner = pattern.replace(/^\*/, "").replace(/\*$/, "");
+  if (!inner || inner.includes("*") || !KEY_CHARS.test(inner) || inner.includes("..")) {
+    return `Pattern '${pattern}' is not a valid wildcard; use *text, text* or *text*`;
+  }
+  return void 0;
+}
+__name(patternError, "patternError");
+function validateKeyList(collector, value, path, scope, view) {
+  var _a2;
+  if (!Array.isArray(value)) {
+    collector.add(path, "INVALID_TYPE", `'${path[path.length - 1]}' must be an array of keys`);
+    return;
+  }
+  const keys = (_a2 = scope.keys.get(view)) != null ? _a2 : /* @__PURE__ */ new Set();
+  value.forEach((item, index) => {
+    const itemPath = [
+      ...path,
+      index
+    ];
+    if (typeof item !== "string") {
+      collector.add(itemPath, "INVALID_TYPE", "Each key must be a string");
+      return;
+    }
+    const invalid = patternError(item);
+    if (invalid) {
+      collector.add(itemPath, "INVALID_PATTERN", invalid);
+    } else if (!item.includes("*") && !keys.has(item)) {
+      collector.add(itemPath, "UNKNOWN_KEY", `Key '${item}' does not exist ${describeScope(scope, view)}`, suggestKey(item, keys));
+    }
+  });
+}
+__name(validateKeyList, "validateKeyList");
+function safeValidate(validator, value) {
+  try {
+    return validator(value);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeValidate, "safeValidate");
+function validateDefaultsObject(collector, value, path, validators) {
+  if (!isPlainObject(value)) {
+    collector.add(path, "INVALID_TYPE", "'defaults' must be an object");
+    return;
+  }
+  const walk = /* @__PURE__ */ __name((node, parents) => {
+    Object.keys(node).forEach((key) => {
+      const keyPath = [
+        ...parents,
+        key
+      ];
+      const current = node[key];
+      const validator = validators == null ? void 0 : validators[keyPath.join(".")];
+      if (isPlainObject(current)) {
+        walk(current, keyPath);
+      } else if (validator && current !== void 0 && safeValidate(validator, current) === void 0) {
+        collector.add([
+          ...path,
+          ...keyPath
+        ], "INVALID_DEFAULT", `Default '${keyPath.join(".")}' does not accept the value ${JSON.stringify(current)}`);
+      }
+    });
+  }, "walk");
+  walk(value, []);
+}
+__name(validateDefaultsObject, "validateDefaultsObject");
+function validateProperties(collector, value, path, allowed) {
+  Object.keys(value).filter((key) => !allowed.includes(key)).forEach((key) => collector.add([
+    ...path,
+    key
+  ], "UNKNOWN_PROPERTY", `Property '${key}' is not part of the customization grammar; valid properties: ${allowed.join(", ")}`));
+}
+__name(validateProperties, "validateProperties");
+function validateCondition(collector, value, path) {
+  if (!isPlainObject(value)) {
+    collector.add(path, "INVALID_CONDITION", "A conditional needs a 'condition' object with field, operator and value");
+    return;
+  }
+  validateProperties(collector, value, path, CONDITION_PROPERTIES);
+  if (typeof value.field !== "string" || !value.field) {
+    collector.add([
+      ...path,
+      "field"
+    ], "INVALID_CONDITION", "The condition 'field' must be a non-empty string");
+  }
+  if (!allowedOperators.includes(value.operator)) {
+    collector.add([
+      ...path,
+      "operator"
+    ], "INVALID_CONDITION", `Unknown operator ${JSON.stringify(value.operator)}; valid operators: ${allowedOperators.join(", ")}`);
+  }
+  if (typeof value.value !== "string" && typeof value.value !== "number") {
+    collector.add([
+      ...path,
+      "value"
+    ], "INVALID_CONDITION", "The condition 'value' must be a string or a number");
+  }
+}
+__name(validateCondition, "validateCondition");
+function validateBlock(collector, value, path, scope, view, allowed) {
+  if (!isPlainObject(value)) {
+    collector.add(path, "INVALID_TYPE", "A customization must be an object");
+    return;
+  }
+  validateProperties(collector, value, path, allowed);
+  const has = /* @__PURE__ */ __name((property) => property in value && allowed.includes(property), "has");
+  if ("remove" in value) validateKeyList(collector, value.remove, [
+    ...path,
+    "remove"
+  ], scope, view);
+  if ("keep" in value) validateKeyList(collector, value.keep, [
+    ...path,
+    "keep"
+  ], scope, view);
+  if ("defaults" in value) {
+    validateDefaultsObject(collector, value.defaults, [
+      ...path,
+      "defaults"
+    ], writeValidators[scope.widget]);
+  }
+  if ("subModules" in value) validateSubmodules(collector, value.subModules, [
+    ...path,
+    "subModules"
+  ], scope);
+  if (has("conditional")) {
+    if (!Array.isArray(value.conditional)) {
+      collector.add([
+        ...path,
+        "conditional"
+      ], "INVALID_TYPE", "'conditional' must be an array");
+    } else {
+      value.conditional.forEach((item, index) => {
+        const itemPath = [
+          ...path,
+          "conditional",
+          index
+        ];
+        if (!isPlainObject(item)) {
+          collector.add(itemPath, "INVALID_CONDITION", "Each conditional must be an object");
+          return;
+        }
+        validateCondition(collector, item.condition, [
+          ...itemPath,
+          "condition"
+        ]);
+        validateBlock(collector, item, itemPath, scope, view, CONDITIONAL_PROPERTIES);
+      });
+    }
+  }
+  if (has("views")) validateViews(collector, value.views, [
+    ...path,
+    "views"
+  ], scope);
+}
+__name(validateBlock, "validateBlock");
+function validateViews(collector, value, path, scope) {
+  if (!isPlainObject(value)) {
+    collector.add(path, "INVALID_TYPE", "'views' must be an object");
+    return;
+  }
+  Object.keys(value).forEach((view) => {
+    if (!scope.views.includes(view)) {
+      const valid = scope.views.length ? `valid views: ${scope.views.join(", ")}` : `the ${scope.widget} widget has no views`;
+      collector.add([
+        ...path,
+        view
+      ], "UNKNOWN_VIEW", `View '${view}' does not exist; ${valid}`);
+      return;
+    }
+    validateBlock(collector, value[view], [
+      ...path,
+      view
+    ], scope, view, VIEW_PROPERTIES);
+  });
+}
+__name(validateViews, "validateViews");
+function validateSubmodules(collector, value, path, scope) {
+  if (!isPlainObject(value)) {
+    collector.add(path, "INVALID_TYPE", "'subModules' must be an object");
+    return;
+  }
+  Object.keys(value).forEach((name) => {
+    const subPath = [
+      ...path,
+      name
+    ];
+    if (!scope.subModules.includes(name)) {
+      const valid = scope.subModules.length ? `valid submodules: ${scope.subModules.join(", ")}` : `the ${scope.widget} widget has no submodules`;
+      collector.add(subPath, "UNKNOWN_SUBMODULE", `Submodule '${name}' does not exist; ${valid}`);
+      return;
+    }
+    const widget = Object.keys(WIDGET_SUBMODULE_NAMES).find((key) => WIDGET_SUBMODULE_NAMES[key] === name);
+    const config = widget ? resolveConfig(widget) : void 0;
+    if (!widget || !config) {
+      if (!isPlainObject(value[name])) {
+        collector.add(subPath, "INVALID_TYPE", "A customization must be an object");
+      }
+      return;
+    }
+    validateBlock(collector, value[name], subPath, createScope(widget, config), ROOT_SCOPE, ROOT_PROPERTIES);
+  });
+}
+__name(validateSubmodules, "validateSubmodules");
+function isEmptyCustomization(value) {
+  if (!isPlainObject(value)) return true;
+  const hasItems = /* @__PURE__ */ __name((list) => Array.isArray(list) && list.length > 0, "hasItems");
+  if (hasItems(value.remove) || hasItems(value.keep)) return false;
+  if (isPlainObject(value.defaults) && Object.keys(value.defaults).length) return false;
+  const nested = [
+    ...Array.isArray(value.conditional) ? value.conditional : [],
+    ...isPlainObject(value.views) ? Object.values(value.views) : [],
+    ...isPlainObject(value.subModules) ? Object.values(value.subModules) : []
+  ];
+  return nested.every(isEmptyCustomization);
+}
+__name(isEmptyCustomization, "isEmptyCustomization");
+function validateCustomization(widget, customization, options = {}) {
+  const collector = new Collector();
+  if (!widgetConfigs[widget]) {
+    collector.add([], "UNKNOWN_WIDGET", `Widget '${widget}' has no customization structure`);
+    return {
+      valid: false,
+      errors: collector.errors
+    };
+  }
+  const config = resolveConfig(widget, options.version);
+  if (!config) {
+    collector.add([], "UNKNOWN_VERSION", `Structure version '${options.version}' does not exist for widget '${widget}'`);
+    return {
+      valid: false,
+      errors: collector.errors
+    };
+  }
+  validateBlock(collector, customization, [], createScope(widget, config), ROOT_SCOPE, ROOT_PROPERTIES);
+  if (!collector.errors.length && !options.allowEmpty && isEmptyCustomization(customization)) {
+    collector.add([], "EMPTY_CUSTOMIZATION", "The customization has no rules: add a remove, keep or defaults entry");
+  }
+  return {
+    valid: collector.errors.length === 0,
+    errors: collector.errors
+  };
+}
+__name(validateCustomization, "validateCustomization");
+
+// src/remote/remote-customization.loader.ts
+var CUSTOMIZATIONS_API_PATH = "/api/admin/v5/customizations/widgets";
+var DEFAULT_CUSTOMIZATION_ID = "default";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var WIDGET_PATTERN = /^[a-z][a-z0-9-]{0,99}$/;
+var CONTEXT_PATTERN = /^[a-z][a-z0-9-]{0,99}$/;
+var CUSTOMIZATION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+var TIMEOUT = Symbol("timeout");
+var requestCache = /* @__PURE__ */ new Map();
+function clearRemoteCustomizationCache() {
+  requestCache.clear();
+}
+__name(clearRemoteCustomizationCache, "clearRemoteCustomizationCache");
+var isValidCustomizationId = /* @__PURE__ */ __name((value) => typeof value === "string" && CUSTOMIZATION_ID_PATTERN.test(value), "isValidCustomizationId");
+function baseUrl({ apiDomain, domain }) {
+  return `${(apiDomain || domain || "").replace(/\/+$/, "")}${CUSTOMIZATIONS_API_PATH}`;
+}
+__name(baseUrl, "baseUrl");
+function buildHeaders({ apiKey, qvToken }) {
+  const headers = {
+    Accept: "application/json"
+  };
+  if (qvToken) headers.Authorization = `Bearer ${qvToken}`;
+  if (apiKey) headers["x-api-key"] = apiKey;
+  return headers;
+}
+__name(buildHeaders, "buildHeaders");
+var isDefinition = /* @__PURE__ */ __name((body) => isPlainObject(body) && isPlainObject(body.customization), "isDefinition");
+async function request(url, options) {
+  var _a2, _b;
+  const fetchFn = (_a2 = options.fetchFn) != null ? _a2 : globalThis.fetch;
+  if (typeof fetchFn !== "function") {
+    return {
+      kind: "error",
+      error: {
+        code: "NETWORK",
+        message: "fetch is not available"
+      }
+    };
+  }
+  const timeoutMs = (_b = options.timeoutMs) != null ? _b : DEFAULT_TIMEOUT_MS;
+  const controller = typeof AbortController === "function" ? new AbortController() : void 0;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller == null ? void 0 : controller.abort();
+      reject(TIMEOUT);
+    }, timeoutMs);
+  });
+  timeout.catch(() => void 0);
+  try {
+    const response = await Promise.race([
+      fetchFn(url, {
+        method: "GET",
+        headers: buildHeaders(options),
+        signal: controller == null ? void 0 : controller.signal
+      }),
+      timeout
+    ]);
+    if (response.status === 404) return {
+      kind: "not-found"
+    };
+    if (!response.ok) {
+      return {
+        kind: "error",
+        error: {
+          code: "HTTP",
+          status: response.status,
+          message: `Request failed with status ${response.status}`
+        }
+      };
+    }
+    const body = await Promise.race([
+      response.json(),
+      timeout
+    ]).catch((error) => {
+      if (error === TIMEOUT) throw error;
+      return void 0;
+    });
+    if (!isDefinition(body)) {
+      return {
+        kind: "error",
+        error: {
+          code: "INVALID_RESPONSE",
+          message: "The response is not a customization definition"
+        }
+      };
+    }
+    return {
+      kind: "found",
+      definition: body
+    };
+  } catch (error) {
+    return error === TIMEOUT ? {
+      kind: "error",
+      error: {
+        code: "TIMEOUT",
+        message: `No response after ${timeoutMs} ms`
+      }
+    } : {
+      kind: "error",
+      error: {
+        code: "NETWORK",
+        message: "The customization could not be requested"
+      }
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+__name(request, "request");
+function cachedRequest(url, options) {
+  const useCache = options.cache !== false;
+  const cached = useCache ? requestCache.get(url) : void 0;
+  if (cached) return cached;
+  const pending = request(url, options).then((result) => {
+    if (result.kind === "error") requestCache.delete(url);
+    return result;
+  });
+  if (useCache) requestCache.set(url, pending);
+  return pending;
+}
+__name(cachedRequest, "cachedRequest");
+var definitionUrl = /* @__PURE__ */ __name((options, id) => `${baseUrl(options)}/${encodeURIComponent(options.widget)}/${encodeURIComponent(id)}`, "definitionUrl");
+var contextUrl = /* @__PURE__ */ __name((options, context) => `${baseUrl(options)}/${encodeURIComponent(options.widget)}?context=${encodeURIComponent(context)}`, "contextUrl");
+async function loadDefault(options, foundStatus, explicit) {
+  const result = await cachedRequest(definitionUrl(options, DEFAULT_CUSTOMIZATION_ID), options);
+  if (result.kind === "found") return {
+    status: foundStatus,
+    definition: result.definition
+  };
+  if (result.kind === "not-found") {
+    logWarning(`the ${DEFAULT_CUSTOMIZATION_ID} ${options.widget} customization was not found; no remote layer`);
+    return {
+      status: "none"
+    };
+  }
+  if (!explicit) {
+    logWarning(`the ${DEFAULT_CUSTOMIZATION_ID} ${options.widget} customization could not be read (${result.error.code}); no remote layer`);
+    return {
+      status: "none",
+      error: result.error
+    };
+  }
+  return {
+    status: "error",
+    error: result.error
+  };
+}
+__name(loadDefault, "loadDefault");
+async function loadRemoteCustomization(options) {
+  if (typeof (options == null ? void 0 : options.widget) !== "string" || !WIDGET_PATTERN.test(options.widget)) {
+    return {
+      status: "error",
+      error: {
+        code: "INVALID_INPUT",
+        message: "Invalid widget"
+      }
+    };
+  }
+  if (!options.domain && !options.apiDomain) {
+    return {
+      status: "error",
+      error: {
+        code: "INVALID_INPUT",
+        message: "A domain is required"
+      }
+    };
+  }
+  const { customizationId, context } = options;
+  if (customizationId !== void 0 && customizationId !== null && customizationId !== "") {
+    if (!isValidCustomizationId(customizationId)) {
+      logWarning(`invalid customizationId; using ${DEFAULT_CUSTOMIZATION_ID}`);
+      return loadDefault(options, "fallback", true);
+    }
+    const result = await cachedRequest(definitionUrl(options, customizationId), options);
+    if (result.kind === "found") return {
+      status: "found",
+      definition: result.definition
+    };
+    if (result.kind === "error") return {
+      status: "error",
+      error: result.error
+    };
+    logWarning(`customization '${customizationId}' not found; using ${DEFAULT_CUSTOMIZATION_ID}`);
+    return customizationId === DEFAULT_CUSTOMIZATION_ID ? {
+      status: "none"
+    } : loadDefault(options, "fallback", true);
+  }
+  if (context) {
+    if (!CONTEXT_PATTERN.test(context)) {
+      return {
+        status: "error",
+        error: {
+          code: "INVALID_INPUT",
+          message: "Invalid context"
+        }
+      };
+    }
+    const result = await cachedRequest(contextUrl(options, context), options);
+    if (result.kind === "found") return {
+      status: "found",
+      definition: result.definition
+    };
+    if (result.kind === "error") return {
+      status: "error",
+      error: result.error
+    };
+    return loadDefault(options, "fallback", true);
+  }
+  return loadDefault(options, "found", false);
+}
+__name(loadRemoteCustomization, "loadRemoteCustomization");
+function remoteCustomizationLayers(result) {
+  return (result == null ? void 0 : result.definition) ? [
+    result.definition.customization
+  ] : [];
+}
+__name(remoteCustomizationLayers, "remoteCustomizationLayers");
+
 // src/doc/dashboard.structure.doc.ts
 var dashboard_structure_doc_exports = {};
 __export(dashboard_structure_doc_exports, {
@@ -2262,6 +3080,6 @@ _ts_decorate([
   _ts_metadata("design:type", typeof SubModulesDto === "undefined" ? Object : SubModulesDto)
 ], BaseDashboardV1StructureDto.prototype, "subModules", void 0);
 
-export { DOWNLOAD_MODAL_V1_DEFAULTS, DOWNLOAD_MODAL_V1_KEYS, DOWNLOAD_MODAL_VALIDATOR_MAP, DX_VALIDATOR_MAP, dashboard_structure_doc_exports as DashboardDoc, WIDGET_STRUCTURE_SCOPE_FORMAT, WIDGET_STRUCTURE_SCOPE_KIND, WIDGET_SUBMODULE_NAMES, Widget, WidgetStructureInstance, WidgetVersion, buildStructure, calculateRootDefaults, calculateViewMap, checkConditions, evaluateCondition, extractCustomization, getWidgetConfig, getWidgetStructure, hostKeepInheritance, isWidgetStructureScope, scopeToCustomization, structureFrom, structureFromSubmodule, validateBoolean, validateDefaults };
+export { CUSTOMIZATIONS_API_PATH, DEFAULT_CUSTOMIZATION_ID, DOWNLOAD_MODAL_V1_DEFAULTS, DOWNLOAD_MODAL_V1_KEYS, DOWNLOAD_MODAL_VALIDATOR_MAP, DX_VALIDATOR_MAP, dashboard_structure_doc_exports as DashboardDoc, WIDGET_STRUCTURE_SCOPE_FORMAT, WIDGET_STRUCTURE_SCOPE_KIND, WIDGET_SUBMODULE_NAMES, Widget, WidgetStructureInstance, WidgetVersion, buildStructure, calculateRootDefaults, calculateViewMap, checkConditions, clearRemoteCustomizationCache, evaluateCondition, extractCustomization, formatCustomizationPath, getWidgetConfig, getWidgetStructure, hostKeepInheritance, isEmptyCustomization, isValidCustomizationId, isWidgetStructureScope, loadRemoteCustomization, remoteCustomizationLayers, scopeToCustomization, structureFrom, structureFromSubmodule, validateBoolean, validateCustomization, validateDefaults };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map