@domql/element 2.28.40 → 2.28.44

package/dist/esm/update.js

@@ -18,7 +18,11 @@ import { isMethod } from "./methods/index.js";
 import { updateProps } from "./props/index.js";
 import { createState, findInheritedState } from "@domql/state";
 import { create } from "./create.js";
-import { throughExecProps, throughUpdatedDefine, throughUpdatedExec } from "./iterate.js";
+import {
+  throughExecProps,
+  throughUpdatedDefine,
+  throughUpdatedExec
+} from "./iterate.js";
 import { REGISTRY } from "./mixins/index.js";
 import { applyParam } from "./utils/applyParam.js";
 import { OPTIONS } from "./cache/options.js";
@@ -36,17 +40,25 @@ const UPDATE_DEFAULT_OPTIONS = {
 };
 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"] });
+  const options = deepClone(
+    isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ["calleeElement"] }
+  );
   options.calleeElement = calleeElementCache;
   const element = this;
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
-  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
+    element,
+    options
+  );
   if (snapshotHasUpdated) return;
-  if (!options.preventListeners) await triggerEventOnUpdate("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return;
+  if (!options.preventListeners)
+    await triggerEventOnUpdate("startUpdate", params, element, options);
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return;
   if (!excludes) merge(options, UPDATE_DEFAULT_OPTIONS);
   if (isString(params) || isNumber(params)) {
     params = { text: params };
@@ -62,13 +74,18 @@ const update = async function(params = {}, opts) {
     if (props) updateProps(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await triggerEventOnUpdate("beforeUpdate", params, element, options);
+    const beforeUpdateReturns = await triggerEventOnUpdate(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
     if (beforeUpdateReturns === false) return element;
   }
   overwriteDeep(element, params, { exclude: METHODS_EXL });
   throughExecProps(element);
-  throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
-  throughUpdatedDefine(element);
+  await throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  await throughUpdatedDefine(element);
   if (!options.isForced && !options.preventListeners) {
     await triggerEventOn("beforeClassAssign", element, options);
   }
@@ -87,8 +104,10 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
-    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
+    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount)
+      return;
+    else if (options.preventUpdateAfterCount === void 0)
+      options.preventUpdateAfterCount = 1;
     else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
@@ -97,7 +116,8 @@ const update = async function(params = {}, opts) {
     const isInPreventUpdate = isArray(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = isArray(preventDefineUpdate) && preventDefineUpdate.includes(param);
     const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)) continue;
+    if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param))
+      continue;
     if (preventStateUpdate === "once") options.preventStateUpdate = false;
     const isElement = await applyParam(param, element, options);
     if (isElement) {
@@ -140,9 +160,15 @@ const captureSnapshot = (element, options) => {
 };
 const checkIfOnUpdate = (element, parent, options) => {
   var _a, _b, _c;
-  if (!isFunction(element.if) && !isFunction((_a = element.props) == null ? void 0 : _a.if) || !parent) return;
+  if (!isFunction(element.if) && !isFunction((_a = element.props) == null ? void 0 : _a.if) || !parent)
+    return;
   const ref = element.__ref;
-  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(element, element.state, element.context, options);
+  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(
+    element,
+    element.state,
+    element.context,
+    options
+  );
   const itWasFalse = ref.__if !== true;
   if (ifPassed) {
     ref.__if = true;
@@ -165,7 +191,8 @@ const checkIfOnUpdate = (element, parent, options) => {
       const contentKey = ref.contentElementKey;
       if (element.$collection || element.$stateCollection || element.$propsCollection) {
         element.removeContent();
-      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) element[contentKey] = element[contentKey].parseDeep();
+      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep)
+        element[contentKey] = element[contentKey].parseDeep();
       const previousElement = element.previousElement();
       const previousNode = previousElement == null ? void 0 : previousElement.node;
       const hasPrevious = previousNode == null ? void 0 : previousNode.parentNode;
@@ -178,7 +205,13 @@ const checkIfOnUpdate = (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = create(element, parent, element.key, OPTIONS.create, attachOptions);
+      const createdElement = create(
+        element,
+        parent,
+        element.key,
+        OPTIONS.create,
+        attachOptions
+      );
       if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
         applyEvent(element.on.update, createdElement, createdElement.state);
       }
@@ -202,18 +235,33 @@ const inheritStateUpdates = async (element, options) => {
   const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction;
   if (shouldForceFunctionState) {
     const execState = exec(stateKey, element);
-    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true });
+    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) {
-    const initStateReturns = await triggerEventOnUpdate("beforeStateUpdate", keyInParentState, element, options);
+    const initStateReturns = await triggerEventOnUpdate(
+      "beforeStateUpdate",
+      keyInParentState,
+      element,
+      options
+    );
     if (initStateReturns === false) return element;
   }
   const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await triggerEventOnUpdate("stateUpdate", newState.parse(), element, options);
+    await triggerEventOnUpdate(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
   }
 };
 const createStateUpdate = async (element, parent, options) => {

package/iterate.js

@@ -14,20 +14,23 @@ import {
 import { METHODS_EXL, overwrite } from './utils/index.js'
 import { isMethod } from './methods/index.js'
 
-export const throughInitialExec = (element, exclude = {}) => {
+export const throughInitialExec = async (element, exclude = {}) => {
   const { __ref: ref } = element
   for (const param in element) {
     if (exclude[param]) continue
     const prop = element[param]
     if (isFunction(prop) && !isMethod(param, element) && !isVariant(param)) {
       ref.__exec[param] = prop
-      element[param] = prop(element, element.state, element.context)
+      element[param] = await prop(element, element.state, element.context)
       // if (isComponent)
     }
   }
 }
 
-export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
+export const throughUpdatedExec = async (
+  element,
+  options = { excludes: METHODS_EXL }
+) => {
   const { __ref: ref } = element
   const changes = {}
 
@@ -37,7 +40,11 @@ export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL })
     const isDefinedParam = ref.__defineCache[param]
     if (isDefinedParam) continue
 
-    const newExec = ref.__exec[param](element, element.state, element.context)
+    const newExec = await ref.__exec[param](
+      element,
+      element.state,
+      element.context
+    )
     const execReturnsString = isString(newExec) || isNumber(newExec)
     // if (prop && prop.node && execReturnsString) {
     if (prop && prop.node && execReturnsString) {
@@ -58,11 +65,12 @@ export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL })
   return changes
 }
 
-export const throughExecProps = (element) => {
+export const throughExecProps = element => {
   const { __ref: ref } = element
   const { props } = element
   for (const k in props) {
-    const isDefine = k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
+    const isDefine =
+      k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
     const cachedExecProp = ref.__execProps[k]
     if (isFunction(cachedExecProp)) {
       props[k] = exec(cachedExecProp, element)
@@ -73,7 +81,7 @@ export const throughExecProps = (element) => {
   }
 }
 
-export const throughInitialDefine = (element) => {
+export const throughInitialDefine = async element => {
   const { define, context, __ref: ref } = element
 
   let defineObj = {}
@@ -84,23 +92,34 @@ export const throughInitialDefine = (element) => {
   for (const param in defineObj) {
     let elementProp = element[param]
 
-    if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
+    if (
+      isFunction(elementProp) &&
+      !isMethod(param, element) &&
+      !isVariant(param)
+    ) {
       ref.__exec[param] = elementProp
-      const execParam = elementProp = exec(elementProp, element)
+      const execParam = (elementProp = await exec(elementProp, element))
 
       if (execParam) {
-        elementProp = element[param] = execParam.parse ? execParam.parse() : execParam
+        elementProp = element[param] = execParam.parse
+          ? execParam.parse()
+          : execParam
         ref.__defineCache[param] = elementProp
       }
     }
 
-    const execParam = defineObj[param](elementProp, element, element.state, element.context)
+    const execParam = await defineObj[param](
+      elementProp,
+      element,
+      element.state,
+      element.context
+    )
     if (execParam) element[param] = execParam
   }
   return element
 }
 
-export const throughUpdatedDefine = (element) => {
+export const throughUpdatedDefine = async element => {
   const { context, define, __ref: ref } = element
   const changes = {}
 
@@ -110,9 +129,19 @@ export const throughUpdatedDefine = (element) => {
 
   for (const param in obj) {
     const execParam = ref.__exec[param]
-    if (execParam) ref.__defineCache[param] = execParam(element, element.state, element.context)
-    const cached = exec(ref.__defineCache[param], element)
-    const newExecParam = obj[param](cached, element, element.state, element.context)
+    if (execParam)
+      ref.__defineCache[param] = await execParam(
+        element,
+        element.state,
+        element.context
+      )
+    const cached = await exec(ref.__defineCache[param], element)
+    const newExecParam = await obj[param](
+      cached,
+      element,
+      element.state,
+      element.context
+    )
     if (newExecParam) element[param] = newExecParam
   }
   return changes

package/methods/index.js

@@ -145,10 +145,16 @@ export function setProps (param, options) {
   return element
 }
 
-export function getRef () {
+export function getRef (key) {
+  if (key) return this.__ref && this.__ref[key]
   return this.__ref
 }
 
+export function getChildren () {
+  const __children = this.getRef('__children')
+  return __children.map(k => this[k])
+}
+
 export function getPath () {
   return this.getRef().path
 }
@@ -354,6 +360,7 @@ export const METHODS = [
   'lookdown',
   'lookdownAll',
   'getRef',
+  'getChildren',
   'getPath',
   'setNodeStyles',
   'spotByPath',

package/node.js

@@ -52,10 +52,10 @@ export const createNode = async (element, options) => {
   throughExecProps(element)
 
   // iterate through define
-  throughInitialDefine(element)
+  await throughInitialDefine(element)
 
   // iterate through exec
-  throughInitialExec(element)
+  await throughInitialExec(element)
 
   if (element.tag !== 'string' && element.tag !== 'fragment') {
     propagateEventsFromProps(element)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.28.40",
+  "version": "2.28.44",
   "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.28.40",
-    "@domql/render": "^2.28.40",
-    "@domql/state": "^2.28.40",
-    "@domql/utils": "^2.28.40"
+    "@domql/event": "^2.28.44",
+    "@domql/render": "^2.28.44",
+    "@domql/state": "^2.28.44",
+    "@domql/utils": "^2.28.44"
   },
-  "gitHead": "dfba811a989e835291f619abfefa8c02e9c04641",
+  "gitHead": "70519611a6e66b84b628e807c95227a516a40b03",
   "devDependencies": {
     "@babel/core": "^7.26.0"
   }

package/update.js

@@ -22,7 +22,11 @@ import { updateProps } from './props/index.js'
 import { createState, findInheritedState } from '@domql/state'
 
 import { create } from './create.js'
-import { throughExecProps, throughUpdatedDefine, throughUpdatedExec } from './iterate.js'
+import {
+  throughExecProps,
+  throughUpdatedDefine,
+  throughUpdatedExec
+} from './iterate.js'
 import { REGISTRY } from './mixins/index.js'
 import { applyParam } from './utils/applyParam.js'
 import { OPTIONS } from './cache/options.js'
@@ -43,7 +47,12 @@ const UPDATE_DEFAULT_OPTIONS = {
 
 export const update = async function (params = {}, opts) {
   const calleeElementCache = opts?.calleeElement
-  const options = deepClone(isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS, { exclude: ['calleeElement'] })
+  const options = deepClone(
+    isObject(opts)
+      ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS)
+      : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ['calleeElement'] }
+  )
   options.calleeElement = calleeElementCache
   const element = this
   const { parent, node, key } = element
@@ -51,12 +60,20 @@ export const update = async function (params = {}, opts) {
 
   let ref = element.__ref
   if (!ref) ref = element.__ref = {}
-  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options)
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
+    element,
+    options
+  )
   if (snapshotHasUpdated) return
 
-  if (!options.preventListeners) await triggerEventOnUpdate('startUpdate', params, element, options)
+  if (!options.preventListeners)
+    await triggerEventOnUpdate('startUpdate', params, element, options)
 
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return
+  if (
+    preventInheritAtCurrentState &&
+    preventInheritAtCurrentState.__element === element
+  )
+    return
   if (!excludes) merge(options, UPDATE_DEFAULT_OPTIONS)
 
   if (isString(params) || isNumber(params)) {
@@ -70,14 +87,20 @@ export const update = async function (params = {}, opts) {
   if (ifFails) return
 
   if (ref.__if && !options.preventPropsUpdate) {
-    const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps)
+    const hasParentProps =
+      parent.props && (parent.props[key] || parent.props.childProps)
     const hasFunctionInProps = ref.__props.filter(v => isFunction(v))
     const props = params.props || hasParentProps || hasFunctionInProps.length
     if (props) updateProps(props, element, parent)
   }
 
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await triggerEventOnUpdate('beforeUpdate', params, element, options)
+    const beforeUpdateReturns = await triggerEventOnUpdate(
+      'beforeUpdate',
+      params,
+      element,
+      options
+    )
     if (beforeUpdateReturns === false) return element
   }
 
@@ -86,8 +109,8 @@ export const update = async function (params = {}, opts) {
 
   // exec updates
   throughExecProps(element)
-  throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
-  throughUpdatedDefine(element)
+  await throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
+  await throughUpdatedDefine(element)
 
   if (!options.isForced && !options.preventListeners) {
     await triggerEventOn('beforeClassAssign', element, options)
@@ -100,13 +123,24 @@ export const update = async function (params = {}, opts) {
   }
 
   const {
-    preventUpdate, preventDefineUpdate, preventContentUpdate, preventStateUpdate,
-    preventRecursive, preventUpdateListener, preventUpdateAfter, preventUpdateAfterCount
+    preventUpdate,
+    preventDefineUpdate,
+    preventContentUpdate,
+    preventStateUpdate,
+    preventRecursive,
+    preventUpdateListener,
+    preventUpdateAfter,
+    preventUpdateAfterCount
   } = options
 
   if (preventUpdateAfter) {
-    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return
-    else if (options.preventUpdateAfterCount === undefined) options.preventUpdateAfterCount = 1
+    if (
+      isNumber(preventUpdateAfterCount) &&
+      preventUpdateAfter <= preventUpdateAfterCount
+    )
+      return
+    else if (options.preventUpdateAfterCount === undefined)
+      options.preventUpdateAfterCount = 1
     else options.preventUpdateAfterCount++
   }
 
@@ -115,10 +149,15 @@ export const update = async function (params = {}, opts) {
 
     if (!Object.hasOwnProperty.call(element, param)) continue
 
-    const isInPreventUpdate = isArray(preventUpdate) && preventUpdate.includes(param)
-    const isInPreventDefineUpdate = isArray(preventDefineUpdate) && preventDefineUpdate.includes(param)
+    const isInPreventUpdate =
+      isArray(preventUpdate) && preventUpdate.includes(param)
+    const isInPreventDefineUpdate =
+      isArray(preventDefineUpdate) && preventDefineUpdate.includes(param)
 
-    const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection
+    const hasCollection =
+      element.$collection ||
+      element.$stateCollection ||
+      element.$propsCollection
 
     if (
       isUndefined(prop) ||
@@ -128,15 +167,19 @@ export const update = async function (params = {}, opts) {
       preventDefineUpdate === param ||
       (preventContentUpdate && param === 'content' && !hasCollection) ||
       (preventStateUpdate && param) === 'state' ||
-      isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)
-    ) continue
+      isMethod(param, element) ||
+      isObject(REGISTRY[param]) ||
+      isVariant(param)
+    )
+      continue
 
     if (preventStateUpdate === 'once') options.preventStateUpdate = false
 
     const isElement = await applyParam(param, element, options)
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement
-      const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive
+      const canUpdate =
+        isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive
       if (!canUpdate) continue
 
       const lazyLoad = element.props.lazyLoad || options.lazyLoad
@@ -145,19 +188,23 @@ export const update = async function (params = {}, opts) {
         options.onEachUpdate(param, element, element.state, element.context)
       }
 
-      const childUpdateCall = async () => await update.call(prop, params[prop], {
-        ...options,
-        currentSnapshot: snapshotOnCallee,
-        calleeElement
-      })
-
-      lazyLoad ? window.requestAnimationFrame(async () => { // eslint-disable-line
-        await childUpdateCall()
-        // handle lazy load
-        if (!options.preventUpdateListener) {
-          await triggerEventOn('lazyLoad', element, options)
-        }
-      }) : await childUpdateCall()
+      const childUpdateCall = async () =>
+        await update.call(prop, params[prop], {
+          ...options,
+          currentSnapshot: snapshotOnCallee,
+          calleeElement
+        })
+
+      lazyLoad
+        ? window.requestAnimationFrame(async () => {
+            // eslint-disable-line
+            await childUpdateCall()
+            // handle lazy load
+            if (!options.preventUpdateListener) {
+              await triggerEventOn('lazyLoad', element, options)
+            }
+          })
+        : await childUpdateCall()
     }
   }
 
@@ -185,10 +232,16 @@ const captureSnapshot = (element, options) => {
 }
 
 const checkIfOnUpdate = (element, parent, options) => {
-  if ((!isFunction(element.if) && !isFunction(element.props?.if)) || !parent) return
+  if ((!isFunction(element.if) && !isFunction(element.props?.if)) || !parent)
+    return
 
   const ref = element.__ref
-  const ifPassed = (element.if || element.props?.if)(element, element.state, element.context, options)
+  const ifPassed = (element.if || element.props?.if)(
+    element,
+    element.state,
+    element.context,
+    options
+  )
   const itWasFalse = ref.__if !== true
 
   if (ifPassed) {
@@ -214,9 +267,14 @@ const checkIfOnUpdate = (element, parent, options) => {
 
       const contentKey = ref.contentElementKey
 
-      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+      if (
+        element.$collection ||
+        element.$stateCollection ||
+        element.$propsCollection
+      ) {
         element.removeContent()
-      } else if (element[contentKey]?.parseDeep) element[contentKey] = element[contentKey].parseDeep()
+      } else if (element[contentKey]?.parseDeep)
+        element[contentKey] = element[contentKey].parseDeep()
 
       const previousElement = element.previousElement()
       const previousNode = previousElement?.node // document.body.contains(previousElement.node)
@@ -234,9 +292,19 @@ const checkIfOnUpdate = (element, parent, options) => {
 
       delete element.__ref
       delete element.parent
-      const createdElement = create(element, parent, element.key, OPTIONS.create, attachOptions)
+      const createdElement = create(
+        element,
+        parent,
+        element.key,
+        OPTIONS.create,
+        attachOptions
+      )
       // check preventUpdate for an array (Line: 87)
-      if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
+      if (
+        options.preventUpdate !== true &&
+        element.on &&
+        isFunction(element.on.update)
+      ) {
         applyEvent(element.on.update, createdElement, createdElement.state)
       }
       return createdElement
@@ -265,7 +333,8 @@ const inheritStateUpdates = async (element, options) => {
   const { __ref: ref } = element
   const stateKey = ref.__state
   const { parent, state } = element
-  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options
+  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } =
+    options
 
   if (preventUpdateTriggerStateUpdate) return
 
@@ -276,10 +345,16 @@ const inheritStateUpdates = async (element, options) => {
   }
 
   // If state is function, decide execution and apply setting a current state
-  const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction
+  const shouldForceFunctionState =
+    isFunction(stateKey) && !isHoisted && execStateFunction
   if (shouldForceFunctionState) {
     const execState = exec(stateKey, element)
-    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true })
+    state.set(execState, {
+      ...options,
+      preventUpdate: true,
+      preventStateUpdateListener: false,
+      updatedByStateFunction: true
+    })
     return
   }
 
@@ -289,7 +364,12 @@ const inheritStateUpdates = async (element, options) => {
 
   // Trigger on.beforeStateUpdate event
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
-    const initStateReturns = await triggerEventOnUpdate('beforeStateUpdate', keyInParentState, element, options)
+    const initStateReturns = await triggerEventOnUpdate(
+      'beforeStateUpdate',
+      keyInParentState,
+      element,
+      options
+    )
     if (initStateReturns === false) return element
   }
 
@@ -298,7 +378,12 @@ const inheritStateUpdates = async (element, options) => {
 
   // Trigger on.stateUpdate event
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await triggerEventOnUpdate('stateUpdate', newState.parse(), element, options)
+    await triggerEventOnUpdate(
+      'stateUpdate',
+      newState.parse(),
+      element,
+      options
+    )
   }
 }