@domql/element 2.31.30 → 2.31.32

package/create.js

@@ -91,12 +91,11 @@ export const create = async (
     return await onlyResolveExtends(element, parent, key, options)
   }
 
+  await triggerEventOn('eventStart', element, options)
   await triggerEventOn('start', element, options)
 
   switchDefaultOptions(element, parent, options)
-
   addCaching(element, parent, options)
-
   addMethods(element, parent, options)
 
   createScope(element, parent, options)
@@ -137,6 +136,7 @@ export const create = async (
   addElementIntoParentChildren(element, parent)
 
   await triggerEventOn('complete', element, options)
+  await triggerEventOn('eventComplete', element, options)
 
   return element
 }

package/dist/cjs/create.js

@@ -67,6 +67,7 @@ const create = async (element, parent2, key, options = import_options.OPTIONS.cr
   if (options.onlyResolveExtends) {
     return await onlyResolveExtends(element, parent2, key, options);
   }
+  await (0, import_event.triggerEventOn)("eventStart", element, options);
   await (0, import_event.triggerEventOn)("start", element, options);
   switchDefaultOptions(element, parent2, options);
   addCaching(element, parent2, options);
@@ -91,6 +92,7 @@ const create = async (element, parent2, key, options = import_options.OPTIONS.cr
   await renderElement(element, parent2, options, attachOptions);
   addElementIntoParentChildren(element, parent2);
   await (0, import_event.triggerEventOn)("complete", element, options);
+  await (0, import_event.triggerEventOn)("eventComplete", element, options);
   return element;
 };
 const createBasedOnType = (element, parent2, key, options) => {

package/dist/cjs/methods/index.js

@@ -332,7 +332,7 @@ function call(fnKey, ...args) {
     }
     return result;
   } catch (error2) {
-    console.error(`Error calling '${fnKey}'`);
+    console.error(`Error calling function: '${fnKey}'`);
     throw new Error(error2);
   }
 }

package/dist/cjs/update.js

@@ -48,39 +48,22 @@ const update = async function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
   const options = (0, import_utils.deepClone)(
     (0, import_utils.isObject)(opts) ? (0, import_utils2.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
-    { exclude: ["calleeElement"] }
+    { exclude: ["calleeElement", "updatingCalleeElement"] }
   );
   const element = this;
-  options.calleeElement = calleeElementCache || this;
+  options.calleeElement = calleeElementCache;
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
-  if (ref.__stormAbortion && !options.allowStorm) {
-    const stormAbortion = setTimeout(() => {
-      delete ref.__stormAbortion;
-      clearTimeout(stormAbortion);
-    }, 1e3);
-    return;
-  }
-  if (this === options.calleeElement && !options.allowStorm) {
-    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
-    else ref.__selfCallIteration++;
-    if (ref.__selfCallIteration > 100) {
-      ref.__selfCallIteration = 0;
-      ref.__stormAbortion = true;
-      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
   );
   if (snapshotHasUpdated) return;
+  if (checkIfStorm(element, options)) return;
+  if (!options.preventListeners)
+    await (0, import_event.triggerEventOn)("eventStart", element, options);
   if (!options.preventListeners)
     await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
   if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
@@ -168,7 +151,36 @@ const update = async function(params = {}, opts) {
       }) : await childUpdateCall();
     }
   }
-  if (!preventUpdateListener) await (0, import_event.triggerEventOn)("update", element, options);
+  if (!options.preventListeners) {
+    if (!preventUpdateListener) await (0, import_event.triggerEventOn)("update", element, options);
+    await (0, import_event.triggerEventOn)("eventComplete", element, options);
+  }
+};
+const checkIfStorm = (element, options) => {
+  let ref = element.__ref;
+  if (!options.updatingCalleeElement) options.updatingCalleeElement = element;
+  if (ref.__stormAbortion && !options.allowStorm) {
+    const stormAbortion = setTimeout(() => {
+      delete ref.__stormAbortion;
+      clearTimeout(stormAbortion);
+    }, 1e3);
+    element.error("Potential storm update detected", options);
+    return true;
+  }
+  if (element === options.updatingCalleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
+    else ref.__selfCallIteration++;
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0;
+      ref.__stormAbortion = true;
+      element.error("Potential self calling loop in update detected", options);
+      return true;
+    }
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0;
+      clearTimeout(stormTimeout);
+    }, 350);
+  }
 };
 const captureSnapshot = (element, options) => {
   const ref = element.__ref;
@@ -252,24 +264,13 @@ const checkIfOnUpdate = (element, parent, options) => {
 const inheritStateUpdates = async (element, options) => {
   const { __ref: ref } = element;
   const stateKey = ref.__state;
-  const { parent, state } = element;
-  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
+  const { parent } = element;
+  const { preventUpdateTriggerStateUpdate } = options;
   if (preventUpdateTriggerStateUpdate) return;
   if (!stateKey && !ref.__hasRootState) {
     element.state = parent && parent.state || {};
     return;
   }
-  const shouldForceFunctionState = (0, import_utils.isFunction)(stateKey) && !isHoisted && execStateFunction;
-  if (shouldForceFunctionState) {
-    const execState = (0, import_utils.exec)(stateKey, element);
-    state.set(execState, {
-      ...options,
-      preventUpdate: true,
-      preventStateUpdateListener: false,
-      updatedByStateFunction: true
-    });
-    return;
-  }
   const keyInParentState = (0, import_state.findInheritedState)(element, element.parent);
   if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {

package/dist/esm/create.js

@@ -63,6 +63,7 @@ const create = async (element, parent2, key, options = OPTIONS.create || {}, att
   if (options.onlyResolveExtends) {
     return await onlyResolveExtends(element, parent2, key, options);
   }
+  await triggerEventOn("eventStart", element, options);
   await triggerEventOn("start", element, options);
   switchDefaultOptions(element, parent2, options);
   addCaching(element, parent2, options);
@@ -87,6 +88,7 @@ const create = async (element, parent2, key, options = OPTIONS.create || {}, att
   await renderElement(element, parent2, options, attachOptions);
   addElementIntoParentChildren(element, parent2);
   await triggerEventOn("complete", element, options);
+  await triggerEventOn("eventComplete", element, options);
   return element;
 };
 const createBasedOnType = (element, parent2, key, options) => {

package/dist/esm/methods/index.js

@@ -291,7 +291,7 @@ function call(fnKey, ...args) {
     }
     return result;
   } catch (error2) {
-    console.error(`Error calling '${fnKey}'`);
+    console.error(`Error calling function: '${fnKey}'`);
     throw new Error(error2);
   }
 }

package/dist/esm/update.js

@@ -42,39 +42,22 @@ const update = async function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
   const options = deepClone(
     isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
-    { exclude: ["calleeElement"] }
+    { exclude: ["calleeElement", "updatingCalleeElement"] }
   );
   const element = this;
-  options.calleeElement = calleeElementCache || this;
+  options.calleeElement = calleeElementCache;
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
-  if (ref.__stormAbortion && !options.allowStorm) {
-    const stormAbortion = setTimeout(() => {
-      delete ref.__stormAbortion;
-      clearTimeout(stormAbortion);
-    }, 1e3);
-    return;
-  }
-  if (this === options.calleeElement && !options.allowStorm) {
-    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
-    else ref.__selfCallIteration++;
-    if (ref.__selfCallIteration > 100) {
-      ref.__selfCallIteration = 0;
-      ref.__stormAbortion = true;
-      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
   );
   if (snapshotHasUpdated) return;
+  if (checkIfStorm(element, options)) return;
+  if (!options.preventListeners)
+    await triggerEventOn("eventStart", element, options);
   if (!options.preventListeners)
     await triggerEventOnUpdate("startUpdate", params, element, options);
   if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
@@ -162,7 +145,36 @@ const update = async function(params = {}, opts) {
       }) : await childUpdateCall();
     }
   }
-  if (!preventUpdateListener) await triggerEventOn("update", element, options);
+  if (!options.preventListeners) {
+    if (!preventUpdateListener) await triggerEventOn("update", element, options);
+    await triggerEventOn("eventComplete", element, options);
+  }
+};
+const checkIfStorm = (element, options) => {
+  let ref = element.__ref;
+  if (!options.updatingCalleeElement) options.updatingCalleeElement = element;
+  if (ref.__stormAbortion && !options.allowStorm) {
+    const stormAbortion = setTimeout(() => {
+      delete ref.__stormAbortion;
+      clearTimeout(stormAbortion);
+    }, 1e3);
+    element.error("Potential storm update detected", options);
+    return true;
+  }
+  if (element === options.updatingCalleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
+    else ref.__selfCallIteration++;
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0;
+      ref.__stormAbortion = true;
+      element.error("Potential self calling loop in update detected", options);
+      return true;
+    }
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0;
+      clearTimeout(stormTimeout);
+    }, 350);
+  }
 };
 const captureSnapshot = (element, options) => {
   const ref = element.__ref;
@@ -246,24 +258,13 @@ const checkIfOnUpdate = (element, parent, options) => {
 const inheritStateUpdates = async (element, options) => {
   const { __ref: ref } = element;
   const stateKey = ref.__state;
-  const { parent, state } = element;
-  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
+  const { parent } = element;
+  const { preventUpdateTriggerStateUpdate } = options;
   if (preventUpdateTriggerStateUpdate) return;
   if (!stateKey && !ref.__hasRootState) {
     element.state = parent && parent.state || {};
     return;
   }
-  const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction;
-  if (shouldForceFunctionState) {
-    const execState = exec(stateKey, element);
-    state.set(execState, {
-      ...options,
-      preventUpdate: true,
-      preventStateUpdateListener: false,
-      updatedByStateFunction: true
-    });
-    return;
-  }
   const keyInParentState = findInheritedState(element, element.parent);
   if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {

package/methods/index.js

@@ -377,7 +377,7 @@ export function call(fnKey, ...args) {
     // Return synchronous results directly
     return result
   } catch (error) {
-    console.error(`Error calling '${fnKey}'`)
+    console.error(`Error calling function: '${fnKey}'`)
     throw new Error(error)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.31.30",
+  "version": "2.31.32",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -27,12 +27,12 @@
     "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.31.30",
-    "@domql/render": "^2.31.30",
-    "@domql/state": "^2.31.30",
-    "@domql/utils": "^2.31.30"
+    "@domql/event": "^2.31.32",
+    "@domql/render": "^2.31.32",
+    "@domql/state": "^2.31.32",
+    "@domql/utils": "^2.31.32"
   },
-  "gitHead": "2cf6e94eae0ea19763d2acac8bebb9b640f4dceb",
+  "gitHead": "6d278f08ee062e0e570071860d2a5662549e6cb4",
   "devDependencies": {
     "@babel/core": "^7.27.1"
   }

package/update.js

@@ -56,48 +56,27 @@ export const update = async function (params = {}, opts) {
     isObject(opts)
       ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS)
       : UPDATE_DEFAULT_OPTIONS,
-    { exclude: ['calleeElement'] }
+    { exclude: ['calleeElement', 'updatingCalleeElement'] }
   )
   const element = this
-  options.calleeElement = calleeElementCache || this
+  options.calleeElement = calleeElementCache
   const { parent, node, key } = element
   const { excludes, preventInheritAtCurrentState } = options
 
   let ref = element.__ref
   if (!ref) ref = element.__ref = {}
 
-  if (ref.__stormAbortion && !options.allowStorm) {
-    // make storm abourtion time based
-    const stormAbortion = setTimeout(() => {
-      delete ref.__stormAbortion
-      clearTimeout(stormAbortion)
-    }, 1000)
-    return
-  }
-
-  // self calling is detected
-  if (this === options.calleeElement && !options.allowStorm) {
-    if (ref.__selfCallIteration === undefined) ref.__selfCallIteration = 0
-    else ref.__selfCallIteration++
-    // prevent storm
-    if (ref.__selfCallIteration > 100) {
-      ref.__selfCallIteration = 0
-      ref.__stormAbortion = true
-      return this.error('Potential self calling loop in update detected', opts)
-    }
-    // make storm detection time based
-    const stormTimeout = setTimeout(() => {
-      ref.__selfCallIteration = 0
-      clearTimeout(stormTimeout)
-    }, 350)
-  }
-
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
     element,
     options
   )
   if (snapshotHasUpdated) return
 
+  if (checkIfStorm(element, options)) return
+
+  if (!options.preventListeners)
+    await triggerEventOn('eventStart', element, options)
+
   if (!options.preventListeners)
     await triggerEventOnUpdate('startUpdate', params, element, options)
 
@@ -241,7 +220,44 @@ export const update = async function (params = {}, opts) {
     }
   }
 
-  if (!preventUpdateListener) await triggerEventOn('update', element, options)
+  if (!options.preventListeners) {
+    if (!preventUpdateListener) await triggerEventOn('update', element, options)
+    await triggerEventOn('eventComplete', element, options)
+  }
+}
+
+const checkIfStorm = (element, options) => {
+  let ref = element.__ref
+
+  if (!options.updatingCalleeElement) options.updatingCalleeElement = element
+
+  if (ref.__stormAbortion && !options.allowStorm) {
+    // make storm abourtion time based
+    const stormAbortion = setTimeout(() => {
+      delete ref.__stormAbortion
+      clearTimeout(stormAbortion)
+    }, 1000)
+    element.error('Potential storm update detected', options)
+    return true
+  }
+
+  // self calling is detected
+  if (element === options.updatingCalleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === undefined) ref.__selfCallIteration = 0
+    else ref.__selfCallIteration++
+    // prevent storm
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0
+      ref.__stormAbortion = true
+      element.error('Potential self calling loop in update detected', options)
+      return true
+    }
+    // make storm detection time based
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0
+      clearTimeout(stormTimeout)
+    }, 350)
+  }
 }
 
 const captureSnapshot = (element, options) => {
@@ -355,7 +371,6 @@ const checkIfOnUpdate = (element, parent, options) => {
  * @param {Object} options - Configuration options for state update inheritance.
  * @param {boolean} [options.preventUpdateTriggerStateUpdate] - If true, prevent triggering state updates.
  * @param {boolean} [options.isHoisted] - Whether the state is hoisted.
- * @param {boolean} [options.execStateFunction] - Execute the state functions.
  * @param {boolean} [options.stateFunctionOverwrite] - If true, overwrite (not merge) current state with what function returns.
  * @param {boolean} [options.preventInheritedStateUpdate] - If true, prevent inheriting state updates.
  * @param {boolean} [options.preventBeforeStateUpdateListener] - If true, prevent the 'beforeStateUpdate' event listener.
@@ -365,9 +380,8 @@ const checkIfOnUpdate = (element, parent, options) => {
 const inheritStateUpdates = async (element, options) => {
   const { __ref: ref } = element
   const stateKey = ref.__state
-  const { parent, state } = element
-  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } =
-    options
+  const { parent } = element
+  const { preventUpdateTriggerStateUpdate } = options
 
   if (preventUpdateTriggerStateUpdate) return
 
@@ -377,20 +391,6 @@ const inheritStateUpdates = async (element, options) => {
     return
   }
 
-  // If state is function, decide execution and apply setting a current state
-  const shouldForceFunctionState =
-    isFunction(stateKey) && !isHoisted && execStateFunction
-  if (shouldForceFunctionState) {
-    const execState = exec(stateKey, element)
-    state.set(execState, {
-      ...options,
-      preventUpdate: true,
-      preventStateUpdateListener: false,
-      updatedByStateFunction: true
-    })
-    return
-  }
-
   // If state is string, find its value in the state tree
   const keyInParentState = findInheritedState(element, element.parent)
   if (!keyInParentState || options.preventInheritedStateUpdate) return