@webiny/website-builder-sdk 6.3.0 → 6.4.0-beta.1

package/ConstraintEvaluator.js

@@ -1,395 +1,288 @@
 class ConstraintBlockError extends Error {
-  constructor(message) {
-    super(message);
-  }
+    constructor(message){
+        super(message);
+    }
 }
 function block(message) {
-  throw new ConstraintBlockError(message);
+    throw new ConstraintBlockError(message);
 }
-/**
- * Build a regex pattern from a slot path, replacing the numeric index with \d+.
- * E.g., "steps/2/step" → /^steps\/\d+\/step$/
- * Returns undefined if the slot has no index segment.
- */
 function buildSlotPattern(slot) {
-  const match = slot.match(/\/(\d+)\//);
-  if (!match) {
-    return undefined;
-  }
-  return new RegExp("^" + slot.replace(/\/\d+\//, "/\\d+/") + "$");
+    const match = slot.match(/\/(\d+)\//);
+    if (!match) return;
+    return new RegExp("^" + slot.replace(/\/\d+\//, "/\\d+/") + "$");
 }
-
-/**
- * Find the actual index and sibling count for an element in its parent's bindings.
- * Instead of trusting element.parent.slot (which may be stale after reordering),
- * we scan the parent's binding keys to find which slot holds this element's ID.
- * Returns { index, count } or undefined if not in a list slot.
- */
 function findChildPosition(element, document) {
-  if (!element.parent?.id || !element.parent.slot) {
-    return undefined;
-  }
-  const inputs = document.bindings[element.parent.id]?.inputs;
-  if (!inputs) {
-    return undefined;
-  }
-
-  // Try direct list slot format: binding key = slot name, static = array of IDs.
-  // Only when the slot path itself is NOT an indexed sub-key (e.g., "steps", not "steps/0/step").
-  const slotName = element.parent.slot;
-  if (!/\/\d+\//.test(slotName)) {
-    const directBinding = inputs[slotName];
-    if (directBinding && Array.isArray(directBinding.static)) {
-      const index = directBinding.static.indexOf(element.id);
-      if (index !== -1) {
-        return {
-          index,
-          count: directBinding.static.length
-        };
-      }
+    if (!element.parent?.id || !element.parent.slot) return;
+    const inputs = document.bindings[element.parent.id]?.inputs;
+    if (!inputs) return;
+    const slotName = element.parent.slot;
+    if (!/\/\d+\//.test(slotName)) {
+        const directBinding = inputs[slotName];
+        if (directBinding && Array.isArray(directBinding.static)) {
+            const index = directBinding.static.indexOf(element.id);
+            if (-1 !== index) return {
+                index,
+                count: directBinding.static.length
+            };
+        }
     }
-  }
-
-  // Fall back to indexed sub-key format: steps/0/step, steps/1/step, etc.
-  const pattern = buildSlotPattern(slotName);
-  if (!pattern) {
-    return undefined;
-  }
-  const siblingKeys = [];
-  for (const key in inputs) {
-    if (pattern.test(key)) {
-      const m = key.match(/\/(\d+)\//);
-      if (m) {
-        siblingKeys.push({
-          key,
-          idx: parseInt(m[1], 10)
+    const pattern = buildSlotPattern(slotName);
+    if (!pattern) return;
+    const siblingKeys = [];
+    for(const key in inputs)if (pattern.test(key)) {
+        const m = key.match(/\/(\d+)\//);
+        if (m) siblingKeys.push({
+            key,
+            idx: parseInt(m[1], 10)
         });
-      }
     }
-  }
-  siblingKeys.sort((a, b) => a.idx - b.idx);
-  const position = siblingKeys.findIndex(({
-    key
-  }) => {
-    const val = inputs[key]?.static;
-    if (Array.isArray(val)) {
-      return val.includes(element.id);
-    }
-    return val === element.id;
-  });
-  if (position === -1) {
-    return undefined;
-  }
-  return {
-    index: position,
-    count: siblingKeys.length
-  };
+    siblingKeys.sort((a, b)=>a.idx - b.idx);
+    const position = siblingKeys.findIndex(({ key })=>{
+        const val = inputs[key]?.static;
+        if (Array.isArray(val)) return val.includes(element.id);
+        return val === element.id;
+    });
+    if (-1 === position) return;
+    return {
+        index: position,
+        count: siblingKeys.length
+    };
 }
-export function buildElementContext(element, components, document) {
-  const manifest = components[element.component.name];
-  if (!manifest) {
-    return undefined;
-  }
-  return {
-    name: element.component.name,
-    tags: manifest.tags ?? [],
-    getParent() {
-      if (!element.parent?.id) {
-        return undefined;
-      }
-      const parentEl = document.elements[element.parent.id];
-      if (!parentEl) {
-        return undefined;
-      }
-      return buildElementContext(parentEl, components, document);
-    },
-    childIndex() {
-      const pos = findChildPosition(element, document);
-      return pos ? pos.index : -1;
-    },
-    childCount() {
-      const pos = findChildPosition(element, document);
-      return pos ? pos.count : -1;
-    },
-    isLastChild() {
-      const pos = findChildPosition(element, document);
-      return pos !== undefined && pos.index === pos.count - 1;
-    },
-    isFirstChild() {
-      const pos = findChildPosition(element, document);
-      return pos !== undefined && pos.index === 0;
-    }
-  };
+function buildElementContext(element, components, document) {
+    const manifest = components[element.component.name];
+    if (!manifest) return;
+    return {
+        name: element.component.name,
+        tags: manifest.tags ?? [],
+        getParent () {
+            if (!element.parent?.id) return;
+            const parentEl = document.elements[element.parent.id];
+            if (!parentEl) return;
+            return buildElementContext(parentEl, components, document);
+        },
+        childIndex () {
+            const pos = findChildPosition(element, document);
+            return pos ? pos.index : -1;
+        },
+        childCount () {
+            const pos = findChildPosition(element, document);
+            return pos ? pos.count : -1;
+        },
+        isLastChild () {
+            const pos = findChildPosition(element, document);
+            return void 0 !== pos && pos.index === pos.count - 1;
+        },
+        isFirstChild () {
+            const pos = findChildPosition(element, document);
+            return void 0 !== pos && 0 === pos.index;
+        }
+    };
 }
-export function buildAncestors(parentElement, components, document) {
-  const ancestors = [];
-  let current = parentElement;
-  while (current) {
-    const manifest = components[current.component.name];
-    if (manifest) {
-      ancestors.push({
-        element: current,
-        manifest
-      });
-    }
-    if (current.parent?.id) {
-      current = document.elements[current.parent.id];
-    } else {
-      break;
+function buildAncestors(parentElement, components, document) {
+    const ancestors = [];
+    let current = parentElement;
+    while(current){
+        const manifest = components[current.component.name];
+        if (manifest) ancestors.push({
+            element: current,
+            manifest
+        });
+        if (current.parent?.id) current = document.elements[current.parent.id];
+        else break;
     }
-  }
-  return ancestors;
+    return ancestors;
 }
 function countInstances(document, componentName) {
-  let count = 0;
-  for (const id in document.elements) {
-    if (document.elements[id].component.name === componentName) {
-      count++;
-    }
-  }
-  return count;
+    let count = 0;
+    for(const id in document.elements)if (document.elements[id].component.name === componentName) count++;
+    return count;
 }
 function hasDescendantWithTag(document, components, elementId, tag) {
-  for (const id in document.elements) {
-    const el = document.elements[id];
-    if (id === elementId) {
-      continue;
-    }
-    // Walk up parent chain to see if elementId is an ancestor.
-    let current = el.parent?.id ? document.elements[el.parent.id] : undefined;
-    let isDescendant = false;
-    while (current) {
-      if (current.id === elementId) {
-        isDescendant = true;
-        break;
-      }
-      current = current.parent?.id ? document.elements[current.parent.id] : undefined;
-    }
-    if (!isDescendant) {
-      continue;
-    }
-    const elManifest = components[el.component.name];
-    if (elManifest?.tags?.includes(tag)) {
-      return true;
+    for(const id in document.elements){
+        const el = document.elements[id];
+        if (id === elementId) continue;
+        let current = el.parent?.id ? document.elements[el.parent.id] : void 0;
+        let isDescendant = false;
+        while(current){
+            if (current.id === elementId) {
+                isDescendant = true;
+                break;
+            }
+            current = current.parent?.id ? document.elements[current.parent.id] : void 0;
+        }
+        if (!isDescendant) continue;
+        const elManifest = components[el.component.name];
+        if (elManifest?.tags?.includes(tag)) return true;
     }
-  }
-  return false;
+    return false;
 }
-export function evaluateConstraints(params) {
-  const {
-    componentName,
-    parentId,
-    slot,
-    document,
-    components
-  } = params;
-  const componentManifest = components[componentName];
-  if (!componentManifest) {
-    return {
-      allowed: true
+function evaluateConstraints(params) {
+    const { componentName, parentId, slot, document, components } = params;
+    const componentManifest = components[componentName];
+    if (!componentManifest) return {
+        allowed: true
     };
-  }
-  const parentElement = document.elements[parentId];
-  if (!parentElement) {
-    return {
-      allowed: true
+    const parentElement = document.elements[parentId];
+    if (!parentElement) return {
+        allowed: true
     };
-  }
-  const parentCtx = buildElementContext(parentElement, components, document);
-  if (!parentCtx) {
-    return {
-      allowed: true
+    const parentCtx = buildElementContext(parentElement, components, document);
+    if (!parentCtx) return {
+        allowed: true
     };
-  }
-  const ancestors = buildAncestors(parentElement, components, document);
-  const parentInputs = document.bindings[parentElement.id]?.inputs ?? {};
-  const ctx = {
-    component: {
-      name: componentManifest.name,
-      tags: componentManifest.tags ?? [],
-      // During placement, the element doesn't exist yet — position is unknown.
-      getParent: () => parentCtx,
-      childIndex: () => -1,
-      childCount: () => -1,
-      isLastChild: () => false,
-      isFirstChild: () => false
-    },
-    parent: parentCtx,
-    slot,
-    isChildOf: name => parentElement.component.name === name,
-    isDescendantOf: name => ancestors.some(a => a.manifest.name === name),
-    getAncestor: name => {
-      const found = ancestors.find(a => a.manifest.name === name);
-      return found ? buildElementContext(found.element, components, document) : undefined;
-    },
-    hasTag: tag => componentManifest.tags?.includes(tag) ?? false,
-    slotChildCount: () => {
-      const items = parentInputs[slot]?.static;
-      return Array.isArray(items) ? items.length : 0;
-    },
-    countInstances: name => countInstances(document, name),
-    // Element doesn't exist yet during placement — no descendants or inputs to check.
-    hasDescendantWithTag: () => false,
-    getAncestorInputs: () => undefined,
-    getElementInputs: () => ({}),
-    log: (...args) => console.log(...args),
-    block
-  };
-  const runConstraint = (constraint, fallbackMessage) => {
-    try {
-      constraint(ctx);
-    } catch (err) {
-      if (err instanceof ConstraintBlockError) {
-        return {
-          message: err.message
-        };
-      }
-      return {
-        message: err instanceof Error && err.message ? err.message : fallbackMessage
-      };
-    }
-    return undefined;
-  };
-
-  // Evaluate the placed component's own constraints.
-  if (componentManifest.constraints) {
-    for (const constraint of componentManifest.constraints) {
-      const violation = runConstraint(constraint, `Cannot place ${componentManifest.label} here.`);
-      if (violation) {
-        return {
-          allowed: false,
-          violation
+    const ancestors = buildAncestors(parentElement, components, document);
+    const parentInputs = document.bindings[parentElement.id]?.inputs ?? {};
+    const ctx = {
+        component: {
+            name: componentManifest.name,
+            tags: componentManifest.tags ?? [],
+            getParent: ()=>parentCtx,
+            childIndex: ()=>-1,
+            childCount: ()=>-1,
+            isLastChild: ()=>false,
+            isFirstChild: ()=>false
+        },
+        parent: parentCtx,
+        slot,
+        isChildOf: (name)=>parentElement.component.name === name,
+        isDescendantOf: (name)=>ancestors.some((a)=>a.manifest.name === name),
+        getAncestor: (name)=>{
+            const found = ancestors.find((a)=>a.manifest.name === name);
+            return found ? buildElementContext(found.element, components, document) : void 0;
+        },
+        hasTag: (tag)=>componentManifest.tags?.includes(tag) ?? false,
+        slotChildCount: ()=>{
+            const items = parentInputs[slot]?.static;
+            return Array.isArray(items) ? items.length : 0;
+        },
+        countInstances: (name)=>countInstances(document, name),
+        hasDescendantWithTag: ()=>false,
+        getAncestorInputs: ()=>void 0,
+        getElementInputs: ()=>({}),
+        log: (...args)=>console.log(...args),
+        block: block
+    };
+    const runConstraint = (constraint, fallbackMessage)=>{
+        try {
+            constraint(ctx);
+        } catch (err) {
+            if (err instanceof ConstraintBlockError) return {
+                message: err.message
+            };
+            return {
+                message: err instanceof Error && err.message ? err.message : fallbackMessage
+            };
+        }
+    };
+    if (componentManifest.constraints) for (const constraint of componentManifest.constraints){
+        const violation = runConstraint(constraint, `Cannot place ${componentManifest.label} here.`);
+        if (violation) return {
+            allowed: false,
+            violation
         };
-      }
     }
-  }
-
-  // Evaluate descendantConstraints from all ancestors (including direct parent).
-  for (const ancestor of ancestors) {
-    if (ancestor.manifest.descendantConstraints) {
-      for (const constraint of ancestor.manifest.descendantConstraints) {
+    for (const ancestor of ancestors)if (ancestor.manifest.descendantConstraints) for (const constraint of ancestor.manifest.descendantConstraints){
         const violation = runConstraint(constraint, `Cannot place ${componentName} inside ${ancestor.manifest.label}.`);
-        if (violation) {
-          return {
+        if (violation) return {
             allowed: false,
             violation
-          };
-        }
-      }
+        };
     }
-  }
-  return {
-    allowed: true
-  };
-}
-export function evaluateDeleteConstraint(params) {
-  const {
-    elementId,
-    document,
-    components
-  } = params;
-  const element = document.elements[elementId];
-  if (!element) {
     return {
-      allowed: true
+        allowed: true
     };
-  }
-  const manifest = components[element.component.name];
-  if (!manifest) {
-    return {
-      allowed: true
+}
+function evaluateDeleteConstraint(params) {
+    const { elementId, document, components } = params;
+    const element = document.elements[elementId];
+    if (!element) return {
+        allowed: true
     };
-  }
-  const {
-    canDelete
-  } = manifest;
-
-  // undefined or true → allowed
-  if (canDelete === undefined || canDelete === true) {
-    return {
-      allowed: true
+    const manifest = components[element.component.name];
+    if (!manifest) return {
+        allowed: true
     };
-  }
-
-  // false → blocked
-  if (canDelete === false) {
-    return {
-      allowed: false,
-      violation: {
-        message: `${manifest.label} cannot be deleted.`
-      }
+    const { canDelete } = manifest;
+    if (void 0 === canDelete || true === canDelete) return {
+        allowed: true
     };
-  }
-
-  // ComponentConstraint → evaluate dynamically
-  const parentElement = element.parent?.id ? document.elements[element.parent.id] : undefined;
-  const parentCtx = parentElement ? buildElementContext(parentElement, components, document) : undefined;
-  const ancestors = parentElement ? buildAncestors(parentElement, components, document) : [];
-  const parentInputs = parentElement ? document.bindings[parentElement.id]?.inputs ?? {} : {};
-  const slot = element.parent?.slot ?? "";
-  const elementCtx = buildElementContext(element, components, document);
-  const ctx = {
-    component: elementCtx,
-    parent: parentCtx ?? {
-      name: "",
-      tags: [],
-      getParent: () => undefined,
-      childIndex: () => -1,
-      childCount: () => -1,
-      isLastChild: () => false,
-      isFirstChild: () => false
-    },
-    slot,
-    isChildOf: name => parentElement?.component.name === name,
-    isDescendantOf: name => ancestors.some(a => a.manifest.name === name),
-    getAncestor: name => {
-      const found = ancestors.find(a => a.manifest.name === name);
-      return found ? buildElementContext(found.element, components, document) : undefined;
-    },
-    hasTag: tag => manifest.tags?.includes(tag) ?? false,
-    slotChildCount: () => {
-      const items = parentInputs[slot]?.static;
-      return Array.isArray(items) ? items.length : 0;
-    },
-    countInstances: name => countInstances(document, name),
-    hasDescendantWithTag: tag => hasDescendantWithTag(document, components, element.id, tag),
-    getAncestorInputs: name => {
-      const found = ancestors.find(a => a.manifest.name === name);
-      if (!found) {
-        return undefined;
-      }
-      const bindings = document.bindings[found.element.id]?.inputs ?? {};
-      return Object.fromEntries(Object.entries(bindings).map(([k, v]) => [k, v?.static]));
-    },
-    getElementInputs: () => {
-      const bindings = document.bindings[element.id]?.inputs ?? {};
-      return Object.fromEntries(Object.entries(bindings).map(([k, v]) => [k, v?.static]));
-    },
-    log: (...args) => console.log(...args),
-    block
-  };
-  const fallbackMessage = `${manifest.label} cannot be deleted.`;
-  try {
-    canDelete(ctx);
-  } catch (err) {
-    if (err instanceof ConstraintBlockError) {
-      return {
+    if (false === canDelete) return {
         allowed: false,
         violation: {
-          message: err.message
+            message: `${manifest.label} cannot be deleted.`
         }
-      };
+    };
+    const parentElement = element.parent?.id ? document.elements[element.parent.id] : void 0;
+    const parentCtx = parentElement ? buildElementContext(parentElement, components, document) : void 0;
+    const ancestors = parentElement ? buildAncestors(parentElement, components, document) : [];
+    const parentInputs = parentElement ? document.bindings[parentElement.id]?.inputs ?? {} : {};
+    const slot = element.parent?.slot ?? "";
+    const elementCtx = buildElementContext(element, components, document);
+    const ctx = {
+        component: elementCtx,
+        parent: parentCtx ?? {
+            name: "",
+            tags: [],
+            getParent: ()=>void 0,
+            childIndex: ()=>-1,
+            childCount: ()=>-1,
+            isLastChild: ()=>false,
+            isFirstChild: ()=>false
+        },
+        slot,
+        isChildOf: (name)=>parentElement?.component.name === name,
+        isDescendantOf: (name)=>ancestors.some((a)=>a.manifest.name === name),
+        getAncestor: (name)=>{
+            const found = ancestors.find((a)=>a.manifest.name === name);
+            return found ? buildElementContext(found.element, components, document) : void 0;
+        },
+        hasTag: (tag)=>manifest.tags?.includes(tag) ?? false,
+        slotChildCount: ()=>{
+            const items = parentInputs[slot]?.static;
+            return Array.isArray(items) ? items.length : 0;
+        },
+        countInstances: (name)=>countInstances(document, name),
+        hasDescendantWithTag: (tag)=>hasDescendantWithTag(document, components, element.id, tag),
+        getAncestorInputs: (name)=>{
+            const found = ancestors.find((a)=>a.manifest.name === name);
+            if (!found) return;
+            const bindings = document.bindings[found.element.id]?.inputs ?? {};
+            return Object.fromEntries(Object.entries(bindings).map(([k, v])=>[
+                    k,
+                    v?.static
+                ]));
+        },
+        getElementInputs: ()=>{
+            const bindings = document.bindings[element.id]?.inputs ?? {};
+            return Object.fromEntries(Object.entries(bindings).map(([k, v])=>[
+                    k,
+                    v?.static
+                ]));
+        },
+        log: (...args)=>console.log(...args),
+        block: block
+    };
+    const fallbackMessage = `${manifest.label} cannot be deleted.`;
+    try {
+        canDelete(ctx);
+    } catch (err) {
+        if (err instanceof ConstraintBlockError) return {
+            allowed: false,
+            violation: {
+                message: err.message
+            }
+        };
+        return {
+            allowed: false,
+            violation: {
+                message: err instanceof Error && err.message ? err.message : fallbackMessage
+            }
+        };
     }
     return {
-      allowed: false,
-      violation: {
-        message: err instanceof Error && err.message ? err.message : fallbackMessage
-      }
+        allowed: true
     };
-  }
-  return {
-    allowed: true
-  };
 }
+export { buildAncestors, buildElementContext, evaluateConstraints, evaluateDeleteConstraint };
 
 //# sourceMappingURL=ConstraintEvaluator.js.map