@domql/element 2.31.25 → 2.31.27

package/dist/cjs/set.js

@@ -33,7 +33,6 @@ var import_event = require("@domql/event");
 const resetElement = async (params, element, options) => {
   if (!options.preventRemove) (0, import_content.removeContent)(element, options);
   const { __ref: ref } = element;
-  if (params instanceof Promise) console.log(params, params instanceof Promise);
   await (0, import_create.create)(params, element, ref.contentElementKey || "content", {
     ignoreChildExtend: true,
     ...import_mixins.registry.defaultOptions,
@@ -53,32 +52,14 @@ const reset = async (options) => {
 const set = async function(params, options = {}, el) {
   var _a, _b, _c;
   const element = el || this;
-  const { __ref: ref } = element;
   if (options.preventContentUpdate || options.preventUpdate && ((_b = (_a = options.preventUpdate).includes) == null ? void 0 : _b.call(_a, "content")))
     return;
   if (options.routerContentElement && options.lastElement) {
     if (options.routerContentElement !== options.lastElement.content) return;
   }
-  const content = (0, import_utils.setContentKey)(element, options);
-  const __contentRef = content && content.__ref;
   const lazyLoad = element.props && element.props.lazyLoad;
   const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
   if (options.preventContentUpdate === true && !hasCollection) return;
-  if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && (0, import_utils.deepContains)(params, content)) {
-    if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-      const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
-        "beforeUpdate",
-        params,
-        element,
-        options
-      );
-      if (beforeUpdateReturns === false) return element;
-    }
-    if (content == null ? void 0 : content.update) await content.update();
-    if (!options.preventUpdateListener)
-      await (0, import_event.triggerEventOn)("update", element, options);
-    return;
-  }
   if (params) {
     let { childExtend, props } = params;
     if (!props) props = params.props = {};

package/dist/cjs/update.js

@@ -50,12 +50,24 @@ const update = async function(params = {}, opts) {
     (0, import_utils.isObject)(opts) ? (0, import_utils2.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
     { exclude: ["calleeElement"] }
   );
-  options.calleeElement = calleeElementCache;
   const element = this;
+  options.calleeElement = calleeElementCache || this;
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
+  if (this === options.calleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
+    else ref.__selfCallIteration++;
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0;
+      return this.error("Potential self calling loop in update detected", opts);
+    }
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0;
+      clearTimeout(stormTimeout);
+    }, 350);
+  }
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
     element,
     options
@@ -116,7 +128,8 @@ const update = async function(params = {}, opts) {
       options.preventUpdateAfterCount = 1;
     else options.preventUpdateAfterCount++;
   }
-  for (const param in element) {
+  const keys = Object.keys(element);
+  for (const param of keys) {
     const prop = element[param];
     if (!Object.hasOwnProperty.call(element, param)) continue;
     const isInPreventUpdate = (0, import_utils.isArray)(preventUpdate) && preventUpdate.includes(param);
@@ -272,7 +285,7 @@ const inheritStateUpdates = async (element, options) => {
 };
 const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = await (0, import_state.createState)(element, parent);
+  const newState = await (0, import_state.createState)(element, parent, options);
   element.state = newState;
   for (const child in __stateChildren) {
     if (newState[child]) newState.__children[child] = __stateChildren[child];

package/dist/esm/create.js

@@ -21,7 +21,7 @@ import {
 import { applyAnimationFrame, triggerEventOn } from "@domql/event";
 import { assignNode } from "@domql/render";
 import { createState } from "@domql/state";
-import { isMethod } from "./methods/index.js";
+import { error, isMethod } from "./methods/index.js";
 import { createProps } from "./props/index.js";
 import { applyExtend } from "./extend.js";
 import { REGISTRY, registry } from "./mixins/index.js";
@@ -34,58 +34,68 @@ import {
   createValidDomqlObjectFromSugar
 } from "./utils/component.js";
 import { isNotProduction } from "@domql/utils/env.js";
-const create = async (element, parent, key, options = OPTIONS.create || {}, attachOptions) => {
+const create = async (element, parent2, key, options = OPTIONS.create || {}, attachOptions) => {
+  const isValid = validateElement(element, options);
+  if (!isValid) {
+    error.call(
+      element,
+      "Error while creating element: Not valid type",
+      element,
+      options
+    );
+    return;
+  }
   cacheOptions(element, options);
   if (checkIfPrimitive(element)) {
-    element = applyValueAsText(element, parent, key);
+    element = applyValueAsText(element, parent2, key);
   }
-  element = redefineElement(element, parent, key, options);
-  parent = redefineParent(element, parent, key);
-  key = createKey(element, parent, key);
-  const ref = addRef(element, parent, key);
+  element = redefineElement(element, parent2, key, options);
+  parent2 = redefineParent(element, parent2, key);
+  key = createKey(element, parent2, key);
+  const ref = addRef(element, parent2, key);
   ref.__initialProps = deepClone(element.props);
-  applyContext(element, parent, options);
-  applyComponentFromContext(element, parent, options);
+  applyContext(element, parent2, options);
+  applyComponentFromContext(element, parent2, options);
   if (!ref.__skipCreate) {
-    applyExtend(element, parent, options);
+    applyExtend(element, parent2, options);
   }
   element.key = key;
   if (options.onlyResolveExtends) {
-    return await onlyResolveExtends(element, parent, key, options);
+    return await onlyResolveExtends(element, parent2, key, options);
   }
   await triggerEventOn("start", element, options);
-  switchDefaultOptions(element, parent, options);
-  addCaching(element, parent);
-  addMethods(element, parent, options);
-  createScope(element, parent);
-  await createState(element, parent);
+  switchDefaultOptions(element, parent2, options);
+  addCaching(element, parent2, options);
+  addMethods(element, parent2, options);
+  createScope(element, parent2, options);
+  await createState(element, parent2, options);
   if (element.scope === "state") element.scope = element.state;
-  createIfConditionFlag(element, parent);
-  createProps(element, parent, options);
+  createIfConditionFlag(element, parent2);
+  createProps(element, parent2, options);
   if (element.scope === "props" || element.scope === true)
     element.scope = element.props;
-  createIfConditionFlag(element, parent);
+  createIfConditionFlag(element, parent2);
   if (element.node && ref.__if) {
-    return assignNode(element, parent, key, attachOptions);
+    return assignNode(element, parent2, key, attachOptions);
   }
-  applyVariant(element, parent);
-  addChildrenIfNotInOriginal(element, parent, key);
+  applyVariant(element, parent2);
+  addChildrenIfNotInOriginal(element, parent2, key);
   const onInit = await triggerEventOn("init", element, options);
   if (onInit === false) return element;
   await triggerEventOn("beforeClassAssign", element, options);
   assignKeyAsClassname(element);
-  await renderElement(element, parent, options, attachOptions);
-  addElementIntoParentChildren(element, parent);
+  await renderElement(element, parent2, options, attachOptions);
+  addElementIntoParentChildren(element, parent2);
   await triggerEventOn("complete", element, options);
   return element;
 };
-const createBasedOnType = (element, parent, key, options) => {
+const createBasedOnType = (element, parent2, key, options) => {
   if (element === void 0) {
     if (isNotProduction()) {
       console.warn(
         key,
         "element is undefined in",
-        parent && parent.__ref && parent.__ref.path
+        parent2 && parent2.__ref && parent2.__ref.path
       );
     }
     return {};
@@ -100,30 +110,86 @@ const createBasedOnType = (element, parent, key, options) => {
   if (element.__hash) {
     return { extend: element };
   }
+  if (typeof Node !== "undefined" && element instanceof Node || typeof DocumentFragment !== "undefined" && element instanceof DocumentFragment)
+    return { node: element };
   return element;
 };
-const redefineElement = (element, parent, key, options) => {
-  const elementWrapper = createBasedOnType(element, parent, key, options);
-  if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent && parent.props && parent.props.syntaxv3) {
+const redefineElement = (element, parent2, key, options) => {
+  const elementWrapper = createBasedOnType(element, parent2, key, options);
+  if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent2 && parent2.props && parent2.props.syntaxv3) {
     if (element.props) element.props.syntaxv3 = true;
     else element.syntaxv3 = true;
-    return createValidDomqlObjectFromSugar(element, parent, key, options);
+    return createValidDomqlObjectFromSugar(element, parent2, key, options);
   } else if (checkIfKeyIsComponent(key)) {
-    return applyKeyComponentAsExtend(elementWrapper, parent, key);
+    return applyKeyComponentAsExtend(elementWrapper, parent2, key);
   }
   if (checkIfMedia(key)) {
-    return applyMediaProps(elementWrapper, parent, key);
+    return applyMediaProps(elementWrapper, parent2, key);
   }
   return elementWrapper;
 };
-const redefineParent = (element, parent, key, options) => {
-  if (!parent) return ROOT;
-  if (isNode(parent)) {
-    const parentNodeWrapper = { key: ":root", node: parent };
+const redefineParent = (element, parent2, key, options) => {
+  if (!parent2) return ROOT;
+  if (isNode(parent2)) {
+    const parentNodeWrapper = { key: ":root", node: parent2 };
     ROOT[`${key}_parent`] = parentNodeWrapper;
     return parentNodeWrapper;
   }
-  return parent;
+  return parent2;
+};
+const validateElement = (value, options) => {
+  if (value == null) return false;
+  const t = typeof value;
+  if (t === "function" || t === "symbol" || t === "bigint") return false;
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity)
+    return false;
+  const unsafeGlobals = [
+    typeof window !== "undefined" && window,
+    typeof document !== "undefined" && document,
+    typeof globalThis !== "undefined" && globalThis,
+    typeof navigator !== "undefined" && navigator,
+    typeof location !== "undefined" && location,
+    typeof history !== "undefined" && history,
+    typeof screen !== "undefined" && screen,
+    typeof frames !== "undefined" && frames,
+    typeof parent !== "undefined" && parent,
+    typeof self !== "undefined" && self,
+    typeof top !== "undefined" && top,
+    typeof performance !== "undefined" && performance,
+    typeof console !== "undefined" && console,
+    typeof indexedDB !== "undefined" && indexedDB,
+    typeof caches !== "undefined" && caches,
+    typeof localStorage !== "undefined" && localStorage,
+    typeof sessionStorage !== "undefined" && sessionStorage,
+    typeof crypto !== "undefined" && crypto,
+    typeof visualViewport !== "undefined" && visualViewport,
+    typeof customElements !== "undefined" && customElements
+  ].filter(Boolean);
+  if (unsafeGlobals.includes(value)) return false;
+  if (typeof EventTarget !== "undefined" && value instanceof EventTarget)
+    return false;
+  if (typeof Event !== "undefined" && value instanceof Event) return false;
+  if (value === Object.prototype || value === Array.prototype || value === Function.prototype || value === Map.prototype || value === Set.prototype || value === WeakMap.prototype || value === WeakSet.prototype || value === Promise.prototype || value === Symbol.prototype)
+    return false;
+  const unsafeConstructors = [
+    typeof Worker !== "undefined" && Worker,
+    typeof SharedWorker !== "undefined" && SharedWorker,
+    typeof MessagePort !== "undefined" && MessagePort,
+    typeof BroadcastChannel !== "undefined" && BroadcastChannel,
+    typeof ReadableStream !== "undefined" && ReadableStream,
+    typeof WritableStream !== "undefined" && WritableStream,
+    typeof TransformStream !== "undefined" && TransformStream,
+    typeof File !== "undefined" && File,
+    typeof Blob !== "undefined" && Blob,
+    typeof FormData !== "undefined" && FormData,
+    typeof XMLHttpRequest !== "undefined" && XMLHttpRequest,
+    typeof AbortController !== "undefined" && AbortController,
+    typeof AbortSignal !== "undefined" && AbortSignal
+  ].filter(Boolean);
+  for (const Ctor of unsafeConstructors) {
+    if (value instanceof Ctor) return false;
+  }
+  return true;
 };
 const cacheOptions = (element, options) => {
   if (options && !OPTIONS.create) {
@@ -131,26 +197,26 @@ const cacheOptions = (element, options) => {
     OPTIONS.create.context = element.context || options.context;
   }
 };
-const createKey = (element, parent, key) => {
+const createKey = (element, parent2, key) => {
   return (exec(key, element) || key || element.key || generateKey()).toString();
 };
-const addRef = (element, parent) => {
+const addRef = (element, parent2) => {
   if (element.__ref) element.__ref.origin = element;
   else element.__ref = { origin: element };
   return element.__ref;
 };
-const switchDefaultOptions = (element, parent, options) => {
+const switchDefaultOptions = (element, parent2, options) => {
   if (Object.keys(options).length) {
     registry.defaultOptions = options;
     if (options.ignoreChildExtend) delete options.ignoreChildExtend;
   }
 };
-const addElementIntoParentChildren = (element, parent) => {
-  if (parent.__ref && parent.__ref.__children)
-    parent.__ref.__children.push(element.key);
+const addElementIntoParentChildren = (element, parent2) => {
+  if (parent2.__ref && parent2.__ref.__children)
+    parent2.__ref.__children.push(element.key);
 };
 const visitedElements = /* @__PURE__ */ new WeakMap();
-const renderElement = async (element, parent, options, attachOptions) => {
+const renderElement = async (element, parent2, options, attachOptions) => {
   var _a, _b, _c, _d;
   if (visitedElements.has(element)) {
     if (isNotProduction())
@@ -195,10 +261,10 @@ const renderElement = async (element, parent, options, attachOptions) => {
     }
   }
   if (!ref.__if) {
-    parent[key || element.key] = element;
+    parent2[key || element.key] = element;
     return element;
   }
-  assignNode(element, parent, key, attachOptions);
+  assignNode(element, parent2, key, attachOptions);
   applyAnimationFrame(element, options);
   await triggerEventOn("render", element, options);
   await triggerEventOn("renderRouter", element, options);
@@ -206,35 +272,35 @@ const renderElement = async (element, parent, options, attachOptions) => {
   await triggerEventOn("create", element, options);
 };
 const checkIfPrimitive = (element) => is(element)("string", "number");
-const applyValueAsText = (element, parent, key) => {
+const applyValueAsText = (element, parent2, key) => {
   const extendTag = element.extend && element.extend.tag;
-  const childExtendTag = parent.childExtend && parent.childExtend.tag;
-  const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+  const childExtendTag = parent2.childExtend && parent2.childExtend.tag;
+  const childPropsTag = parent2.props.childProps && parent2.props.childProps.tag;
   const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key;
   return {
     text: element,
     tag: extendTag || childExtendTag || childPropsTag || isKeyValidHTMLTag || "string"
   };
 };
-const applyContext = (element, parent, options) => {
+const applyContext = (element, parent2, options) => {
   const forcedOptionsContext = options.context && !ROOT.context && !element.context;
   if (forcedOptionsContext) ROOT.context = options.context;
   if (!element.context)
-    element.context = parent.context || options.context || ROOT.context;
+    element.context = parent2.context || options.context || ROOT.context;
 };
-const createScope = (element, parent) => {
+const createScope = (element, parent2) => {
   const { __ref: ref } = element;
-  if (!element.scope) element.scope = parent.scope || ref.root.scope || {};
+  if (!element.scope) element.scope = parent2.scope || ref.root.scope || {};
 };
-const createIfConditionFlag = (element, parent) => {
+const createIfConditionFlag = (element, parent2) => {
   const { __ref: ref } = element;
   if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
     delete ref.__if;
   } else ref.__if = true;
 };
-const addCaching = (element, parent) => {
+const addCaching = (element, parent2) => {
   const { __ref: ref, key } = element;
-  let { __ref: parentRef } = parent;
+  let { __ref: parentRef } = parent2;
   if (!element.transform) element.transform = {};
   if (!ref.__cached) ref.__cached = {};
   if (!ref.__defineCache) ref.__defineCache = {};
@@ -247,30 +313,30 @@ const addCaching = (element, parent) => {
   if (!ref.__children) ref.__children = [];
   if (checkIfKeyIsComponent(key))
     ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
-  const hasRoot = parent && parent.key === ":root";
+  const hasRoot = parent2 && parent2.key === ":root";
   if (!ref.root) ref.root = hasRoot ? element : parentRef.root;
-  if (!parentRef) parentRef = parent.ref = {};
+  if (!parentRef) parentRef = parent2.ref = {};
   if (!parentRef.path) parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
-const onlyResolveExtends = async (element, parent, key, options) => {
+const onlyResolveExtends = async (element, parent2, key, options) => {
   const { __ref: ref } = element;
   if (!ref.__skipCreate) {
-    addCaching(element, parent);
-    addMethods(element, parent, options);
-    createScope(element, parent);
-    createState(element, parent);
+    addCaching(element, parent2);
+    addMethods(element, parent2, options);
+    createScope(element, parent2);
+    createState(element, parent2, options);
     if (element.scope === "state") element.scope = element.state;
-    createIfConditionFlag(element, parent);
-    createProps(element, parent, options);
+    createIfConditionFlag(element, parent2);
+    createProps(element, parent2, options);
     if (element.scope === "props" || element.scope === true)
       element.scope = element.props;
     if (element.node && ref.__if) {
-      parent[key || element.key] = element;
+      parent2[key || element.key] = element;
     }
     if (!element.props) element.props = {};
-    applyVariant(element, parent);
-    addElementIntoParentChildren(element, parent);
+    applyVariant(element, parent2);
+    addElementIntoParentChildren(element, parent2);
   }
   if (element.tag !== "string" && element.tag !== "fragment") {
     await throughInitialDefine(element);
@@ -288,7 +354,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
       }
     }
   }
-  parent[key || element.key] = element;
+  parent2[key || element.key] = element;
   delete element.update;
   delete element.__element;
   if (element.props) {
@@ -298,7 +364,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
   return element;
 };
 const checkIfMedia = (key) => key.slice(0, 1) === "@";
-const applyMediaProps = (element, parent, key) => {
+const applyMediaProps = (element, parent2, key) => {
   const { props } = element;
   if (props) {
     props.display = "none";

package/dist/esm/extend.js

@@ -1,4 +1,4 @@
-import { isFunction, exec, isProduction } from "@domql/utils";
+import { isFunction, exec } from "@domql/utils";
 import {
   getExtendStack,
   jointStacks,

package/dist/esm/iterate.js

@@ -9,7 +9,7 @@ import {
   isVariant
 } from "@domql/utils";
 import { METHODS_EXL, overwrite } from "./utils/index.js";
-import { isMethod } from "./methods/index.js";
+import { isMethod, warn } from "./methods/index.js";
 const throughInitialExec = async (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
@@ -53,6 +53,8 @@ const throughExecProps = (element) => {
   const { props } = element;
   for (const k in props) {
     const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    if (!ref.__execProps)
+      return warn.call(element, "Element was not initiated to execute props");
     const cachedExecProp = ref.__execProps[k];
     if (isFunction(cachedExecProp)) {
       props[k] = exec(cachedExecProp, element);

package/dist/esm/methods/index.js

@@ -58,6 +58,12 @@ function lookdown(param) {
       );
     if (v === param) return childElem;
     else if (isFunction(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) {
         return childElem;
@@ -78,6 +84,12 @@ function lookdownAll(param, results = []) {
     const childElem = el[v];
     if (v === param) results.push(childElem);
     else if (isFunction(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) results.push(childElem);
     }
@@ -97,7 +109,7 @@ function setNodeStyles(params = {}) {
   }
   return el;
 }
-async function remove(opts) {
+async function remove(opts = {}) {
   const element = this;
   const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
   if (beforeRemoveReturns === false) return element;
@@ -118,10 +130,10 @@ function get(param) {
   const element = this;
   return element[param];
 }
-function setProps(param, options) {
+function setProps(param, opts = {}) {
   const element = this;
   if (!param || !element.props) return;
-  element.update({ props: param }, options);
+  element.update({ props: param }, opts);
   return element;
 }
 function getRef(key) {
@@ -212,9 +224,11 @@ function warn(...params) {
   console.warn(...params, this);
 }
 function error(...params) {
-  var _a, _b;
+  var _a, _b, _c, _d;
   if ((_a = params[params.length - 1]) == null ? void 0 : _a.debugger) debugger;
   if ((_b = params[params.length - 1]) == null ? void 0 : _b.verbose) verbose.call(this, ...params);
+  if (isFunction((_c = params[params.length - 1]) == null ? void 0 : _c.onError))
+    (_d = params[params.length - 1]) == null ? void 0 : _d.onError.call(this, ...params);
   console.error(...params, this);
 }
 function nextElement() {
@@ -225,8 +239,8 @@ function nextElement() {
   const nextChild = __children[currentIndex + 1];
   return parent[nextChild];
 }
-async function append(el, key) {
-  return await create(el, this, key);
+async function append(el, key, opts) {
+  return await create(el, this, key, opts);
 }
 function previousElement(el) {
   const element = el || this;
@@ -277,8 +291,8 @@ function call(fnKey, ...args) {
     }
     return result;
   } catch (error2) {
-    console.error(`Error calling '${fnKey}':`, error2);
-    throw error2;
+    console.error(`Error calling '${fnKey}'`);
+    throw new Error(error2);
   }
 }
 const METHODS = [

package/dist/esm/mixins/content.js

@@ -30,7 +30,7 @@ const removeContent = function(el, opts = {}) {
       else if (__cached[contentElementKey] && isFunction(__cached[contentElementKey].remove))
         __cached[contentElementKey].remove();
     }
-    ref.__children.splice(ref.__children.indexOf(element[contentElementKey]), 1);
+    ref.__children.splice(ref.__children.indexOf(contentElementKey), 1);
     delete element[contentElementKey];
   }
 };

package/dist/esm/node.js

@@ -43,11 +43,15 @@ const createNode = async (element, options) => {
       applyEventsOnNode(element, options);
     }
   }
-  for (const param in element) {
+  const keys = Object.keys(element);
+  for (const param of keys) {
     const value = element[param];
     if (!Object.hasOwnProperty.call(element, param)) continue;
     if (isUndefined(value) || isMethod(param, element) || isVariant(param) || isObject(REGISTRY[param]))
       continue;
+    if (param === "onClick") {
+      debugger;
+    }
     const isElement = await applyParam(param, element, options);
     if (!isElement) continue;
     const { hasDefine, hasContextDefine } = isElement;

package/dist/esm/set.js

@@ -1,4 +1,4 @@
-import { deepContains, setContentKey } from "@domql/utils";
+import { deepClone, deepContains, setContentKey } from "@domql/utils";
 import { OPTIONS } from "./cache/options.js";
 import { create } from "./create.js";
 import { registry } from "./mixins/index.js";
@@ -7,7 +7,6 @@ import { triggerEventOn, triggerEventOnUpdate } from "@domql/event";
 const resetElement = async (params, element, options) => {
   if (!options.preventRemove) removeContent(element, options);
   const { __ref: ref } = element;
-  if (params instanceof Promise) console.log(params, params instanceof Promise);
   await create(params, element, ref.contentElementKey || "content", {
     ignoreChildExtend: true,
     ...registry.defaultOptions,
@@ -27,32 +26,14 @@ const reset = async (options) => {
 const set = async function(params, options = {}, el) {
   var _a, _b, _c;
   const element = el || this;
-  const { __ref: ref } = element;
   if (options.preventContentUpdate || options.preventUpdate && ((_b = (_a = options.preventUpdate).includes) == null ? void 0 : _b.call(_a, "content")))
     return;
   if (options.routerContentElement && options.lastElement) {
     if (options.routerContentElement !== options.lastElement.content) return;
   }
-  const content = setContentKey(element, options);
-  const __contentRef = content && content.__ref;
   const lazyLoad = element.props && element.props.lazyLoad;
   const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
   if (options.preventContentUpdate === true && !hasCollection) return;
-  if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && deepContains(params, content)) {
-    if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-      const beforeUpdateReturns = await triggerEventOnUpdate(
-        "beforeUpdate",
-        params,
-        element,
-        options
-      );
-      if (beforeUpdateReturns === false) return element;
-    }
-    if (content == null ? void 0 : content.update) await content.update();
-    if (!options.preventUpdateListener)
-      await triggerEventOn("update", element, options);
-    return;
-  }
   if (params) {
     let { childExtend, props } = params;
     if (!props) props = params.props = {};

package/dist/esm/update.js

@@ -44,12 +44,24 @@ const update = async function(params = {}, opts) {
     isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
     { exclude: ["calleeElement"] }
   );
-  options.calleeElement = calleeElementCache;
   const element = this;
+  options.calleeElement = calleeElementCache || this;
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
+  if (this === options.calleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
+    else ref.__selfCallIteration++;
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0;
+      return this.error("Potential self calling loop in update detected", opts);
+    }
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0;
+      clearTimeout(stormTimeout);
+    }, 350);
+  }
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
     element,
     options
@@ -110,7 +122,8 @@ const update = async function(params = {}, opts) {
       options.preventUpdateAfterCount = 1;
     else options.preventUpdateAfterCount++;
   }
-  for (const param in element) {
+  const keys = Object.keys(element);
+  for (const param of keys) {
     const prop = element[param];
     if (!Object.hasOwnProperty.call(element, param)) continue;
     const isInPreventUpdate = isArray(preventUpdate) && preventUpdate.includes(param);
@@ -266,7 +279,7 @@ const inheritStateUpdates = async (element, options) => {
 };
 const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = await createState(element, parent);
+  const newState = await createState(element, parent, options);
   element.state = newState;
   for (const child in __stateChildren) {
     if (newState[child]) newState.__children[child] = __stateChildren[child];