@domql/element 2.5.205 → 2.5.207

package/dist/esm/set.js

@@ -5,8 +5,7 @@ import { registry } from "./mixins/index.js";
 import { removeContent } from "./mixins/content.js";
 import { triggerEventOn, triggerEventOnUpdate } from "@domql/event";
 const resetElement = async (params, element, options) => {
-  if (!options.preventRemove)
-    removeContent(element, options);
+  if (!options.preventRemove) removeContent(element, options);
   const { __ref: ref } = element;
   await create(params, element, ref.contentElementKey || "content", {
     ignoreChildExtend: true,
@@ -32,24 +31,19 @@ const set = async function(params, options = {}, el) {
   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 (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 (beforeUpdateReturns === false) return element;
     }
-    if (content == null ? void 0 : content.update)
-      await content.update();
-    if (!options.preventUpdateListener)
-      await triggerEventOn("update", element, options);
+    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 = {};
+    if (!props) props = params.props = {};
     if (!childExtend && element.childExtend) {
       params.childExtend = element.childExtend;
       props.ignoreChildExtend = true;
@@ -62,11 +56,10 @@ const set = async function(params, options = {}, el) {
       window.requestAnimationFrame(async () => {
         await resetElement(params, element, options);
         if (!options.preventUpdateListener) {
-          triggerEventOn("lazyLoad", element, options);
+          await triggerEventOn("lazyLoad", element, options);
         }
       });
-    } else
-      await resetElement(params, element, options);
+    } else await resetElement(params, element, options);
   }
   return element;
 };

package/dist/esm/update.js

@@ -42,47 +42,37 @@ const update = async function(params = {}, opts) {
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
-  if (!ref)
-    ref = element.__ref = {};
+  if (!ref) ref = element.__ref = {};
   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 (!excludes)
-    merge(options, UPDATE_DEFAULT_OPTIONS);
+  if (snapshotHasUpdated) 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 };
   }
   const inheritState = await inheritStateUpdates(element, options);
-  if (inheritState === false)
-    return;
+  if (inheritState === false) return;
   const ifFails = checkIfOnUpdate(element, parent, options);
-  if (ifFails)
-    return;
+  if (ifFails) return;
   if (ref.__if && !options.preventPropsUpdate) {
     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 (props) updateProps(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
     const beforeUpdateReturns = await triggerEventOnUpdate("beforeUpdate", params, element, options);
-    if (beforeUpdateReturns === false)
-      return element;
+    if (beforeUpdateReturns === false) return element;
   }
   overwriteDeep(element, params, { exclude: METHODS_EXL });
   throughExecProps(element);
   throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   throughUpdatedDefine(element);
   if (!options.isForced && !options.preventListeners) {
-    triggerEventOn("beforeClassAssign", element, options);
+    await triggerEventOn("beforeClassAssign", element, options);
   }
-  if (!ref.__if)
-    return false;
+  if (!ref.__if) return false;
   if (!node) {
     return;
   }
@@ -97,30 +87,23 @@ 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;
-    else
-      options.preventUpdateAfterCount++;
+    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
+    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
+    else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
     const prop = element[param];
-    if (!Object.hasOwnProperty.call(element, param))
-      continue;
+    if (!Object.hasOwnProperty.call(element, param)) continue;
     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 (preventStateUpdate === "once")
-      options.preventStateUpdate = false;
+    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) {
       const { hasDefine, hasContextDefine } = isElement;
       const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
-      if (!canUpdate)
-        continue;
+      if (!canUpdate) continue;
       const lazyLoad = element.props.lazyLoad || options.lazyLoad;
       if (options.onEachUpdate) {
         options.onEachUpdate(param, element, element.state, element.context);
@@ -133,13 +116,12 @@ const update = async function(params = {}, opts) {
       lazyLoad ? window.requestAnimationFrame(async () => {
         await childUpdateCall();
         if (!options.preventUpdateListener) {
-          triggerEventOn("lazyLoad", element, options);
+          await triggerEventOn("lazyLoad", element, options);
         }
       }) : await childUpdateCall();
     }
   }
-  if (!preventUpdateListener)
-    await triggerEventOn("update", element, options);
+  if (!preventUpdateListener) await triggerEventOn("update", element, options);
 };
 const captureSnapshot = (element, options) => {
   const ref = element.__ref;
@@ -158,8 +140,7 @@ 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 itWasFalse = ref.__if !== true;
@@ -184,8 +165,7 @@ 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;
@@ -214,8 +194,7 @@ const inheritStateUpdates = async (element, options) => {
   const stateKey = ref.__state;
   const { parent, state } = element;
   const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
-  if (preventUpdateTriggerStateUpdate)
-    return;
+  if (preventUpdateTriggerStateUpdate) return;
   if (!stateKey && !ref.__hasRootState) {
     element.state = parent && parent.state || {};
     return;
@@ -227,25 +206,22 @@ const inheritStateUpdates = async (element, options) => {
     return;
   }
   const keyInParentState = findInheritedState(element, element.parent);
-  if (!keyInParentState || options.preventInheritedStateUpdate)
-    return;
+  if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
     const initStateReturns = await triggerEventOnUpdate("beforeStateUpdate", keyInParentState, element, options);
-    if (initStateReturns === false)
-      return element;
+    if (initStateReturns === false) return element;
   }
-  const newState = createStateUpdate(element, parent, options);
+  const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
     await triggerEventOnUpdate("stateUpdate", newState.parse(), element, options);
   }
 };
-const createStateUpdate = (element, parent, options) => {
+const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = createState(element, parent);
+  const newState = await createState(element, parent);
   element.state = newState;
   for (const child in __stateChildren) {
-    if (newState[child])
-      newState.__children[child] = __stateChildren[child];
+    if (newState[child]) newState.__children[child] = __stateChildren[child];
     Object.getPrototypeOf(__stateChildren[child]).parent = newState;
   }
   return newState;

package/dist/esm/utils/applyParam.js

@@ -9,8 +9,7 @@ const applyParam = async (param, element, options) => {
   const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
   const hasDefine = element.define && element.define[param];
   const hasContextDefine = context && context.define && context.define[param];
-  if (!ref.__if)
-    return;
+  if (!ref.__if) return;
   const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
   if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
     if (isFunction(isGlobalTransformer)) {

package/dist/esm/utils/component.js

@@ -29,8 +29,7 @@ const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
 };
 const overwriteVariant = (element, variant, variantProps) => {
   let variantElement = element[variant];
-  if (!variantElement)
-    return;
+  if (!variantElement) return;
   const props = isObject(variantProps) ? variantProps : {};
   if (isString(variantElement)) {
     variantElement = {
@@ -45,16 +44,14 @@ const overwriteVariant = (element, variant, variantProps) => {
 };
 const applyVariant = (element) => {
   const { props } = element;
-  if (!hasVariantProp(element))
-    return element;
+  if (!hasVariantProp(element)) return element;
   const { variant } = props;
   overwriteVariant(element, `.${variant}`);
   const elKeys = Object.keys(element).filter((key) => isVariant(key));
   elKeys.forEach((variant2) => {
     const slicedVariantElementKey = variant2.slice(1);
     const variantElementProps = props[slicedVariantElementKey];
-    if (variantElementProps)
-      overwriteVariant(element, variant2, variantElementProps);
+    if (variantElementProps) overwriteVariant(element, variant2, variantElementProps);
   });
   return element;
 };

package/dist/esm/utils/extendUtils.js

@@ -32,21 +32,16 @@ const deepExtend = (extend, stack, context) => {
   return stack;
 };
 const flattenExtend = (extend, stack, context) => {
-  if (!extend)
-    return stack;
-  if (isArray(extend))
-    return extractArrayExtend(extend, stack, context);
-  if (isString(extend))
-    extend = fallbackStringExtend(extend, context);
+  if (!extend) return stack;
+  if (isArray(extend)) return extractArrayExtend(extend, stack, context);
+  if (isString(extend)) extend = fallbackStringExtend(extend, context);
   stack.push(extend);
-  if (extend.extend)
-    deepExtend(extend, stack, context);
+  if (extend.extend) deepExtend(extend, stack, context);
   return stack;
 };
 const deepMergeExtend = (element, extend) => {
   for (const e in extend) {
-    if (["parent", "node", "__element"].indexOf(e) > -1)
-      continue;
+    if (["parent", "node", "__element"].indexOf(e) > -1) continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if (elementProp === void 0) {
@@ -75,10 +70,8 @@ const fallbackStringExtend = (extend, context, options = {}, variant) => {
   if (isString(extend)) {
     const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
     const pageExists = PAGES && extend.startsWith("/") && PAGES[extend];
-    if (componentExists)
-      return componentExists;
-    else if (pageExists)
-      return pageExists;
+    if (componentExists) return componentExists;
+    else if (pageExists) return pageExists;
     else {
       if (options.verbose && (ENV === "testing" || ENV === "development")) {
         console.warn("Extend is string but component was not found:", extend);
@@ -92,10 +85,8 @@ const jointStacks = (extendStack, childExtendStack) => {
   return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
 };
 const getExtendStack = (extend, context) => {
-  if (!extend)
-    return [];
-  if (extend.__hash)
-    return getHashedExtend(extend) || [];
+  if (!extend) return [];
+  if (extend.__hash) return getHashedExtend(extend) || [];
   const stack = flattenExtend(extend, [], context);
   return getExtendStackRegistry(extend, stack);
 };

package/dist/esm/utils/object.js

@@ -63,8 +63,7 @@ const METHODS_EXL = joinArrays(
 );
 const deepMerge = (element, extend, exclude = METHODS_EXL) => {
   for (const e in extend) {
-    if (exclude.includes(e))
-      continue;
+    if (exclude.includes(e)) continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if (elementProp === void 0) {
@@ -78,8 +77,7 @@ const deepMerge = (element, extend, exclude = METHODS_EXL) => {
 const clone = (obj, exclude = METHODS_EXL) => {
   const o = {};
   for (const e in obj) {
-    if (exclude.includes(e))
-      continue;
+    if (exclude.includes(e)) continue;
     o[e] = obj[e];
   }
   return o;
@@ -89,31 +87,27 @@ const overwrite = (element, params, options) => {
   const { __ref } = element;
   const { __exec, __cached } = __ref;
   for (const e in params) {
-    if (e === "props" || e === "state" || e === "__ref")
-      continue;
+    if (e === "props" || e === "state" || e === "__ref") continue;
     const elementProp = element[e];
     const paramsProp = params[e];
     if (paramsProp !== void 0) {
       __cached[e] = changes[e] = elementProp;
       element[e] = paramsProp;
     }
-    if (options.cleanExec)
-      delete __exec[e];
+    if (options.cleanExec) delete __exec[e];
   }
   return changes;
 };
 const overwriteShallow = (obj, params, exclude = METHODS_EXL) => {
   for (const e in params) {
-    if (exclude.includes(e))
-      continue;
+    if (exclude.includes(e)) continue;
     obj[e] = params[e];
   }
   return obj;
 };
 const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
   for (const e in params) {
-    if (exclude.includes(e))
-      continue;
+    if (exclude.includes(e)) continue;
     const objProp = obj[e];
     const paramsProp = params[e];
     if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
@@ -125,8 +119,7 @@ const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
   return obj;
 };
 const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b))
-    return deepMerge(a, b);
+  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b);
   return a || b;
 };
 const mergeArray = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
@@ -139,8 +132,7 @@ const flattenRecursive = (param, prop, stack = []) => {
   const objectized = mergeAndCloneIfArray(param);
   stack.push(objectized);
   const extendOfExtend = objectized[prop];
-  if (extendOfExtend)
-    flattenRecursive(extendOfExtend, prop, stack);
+  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack);
   delete objectized[prop];
   return stack;
 };

package/dist/esm/utils/onlyResolveExtends.js

@@ -13,24 +13,15 @@ const onlyResolveExtends = (element, parent, key, options) => {
   element.tag = detectTag(element);
   {
     const { __ref: ref2 } = element;
-    if (!ref2.__cached)
-      ref2.__cached = {};
-    if (!ref2.__defineCache)
-      ref2.__defineCache = {};
-    if (!ref2.__exec)
-      ref2.__exec = {};
-    if (!ref2.__execProps)
-      ref2.__execProps = {};
-    if (!ref2.__class)
-      ref2.__class = {};
-    if (!ref2.__classNames)
-      ref2.__classNames = {};
-    if (!ref2.__attr)
-      ref2.__attr = {};
-    if (!ref2.__changes)
-      ref2.__changes = [];
-    if (!ref2.__children)
-      ref2.__children = [];
+    if (!ref2.__cached) ref2.__cached = {};
+    if (!ref2.__defineCache) ref2.__defineCache = {};
+    if (!ref2.__exec) ref2.__exec = {};
+    if (!ref2.__execProps) ref2.__execProps = {};
+    if (!ref2.__class) ref2.__class = {};
+    if (!ref2.__classNames) ref2.__classNames = {};
+    if (!ref2.__attr) ref2.__attr = {};
+    if (!ref2.__changes) ref2.__changes = [];
+    if (!ref2.__children) ref2.__children = [];
   }
   addMethods(element, parent, options);
   createState(element, parent);
@@ -39,10 +30,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     const ifPassed = element.if(element, element.state, element.context);
     if (!ifPassed) {
       delete ref.__if;
-    } else
-      ref.__if = true;
-  } else
-    ref.__if = true;
+    } else ref.__if = true;
+  } else ref.__if = true;
   if (element.node && ref.__if) {
     parent[key || element.key] = element;
   }
@@ -53,8 +42,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     throughInitialExec(element);
     for (const param in element) {
       const prop = element[param];
-      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param))
-        continue;
+      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)) continue;
       const hasDefine = element.define && element.define[param];
       const contextHasDefine = element.context && element.context.define && element.context.define[param];
       const optionsHasDefine = options.define && options.define[param];
@@ -72,8 +60,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     delete element.props.update;
     delete element.props.__element;
   }
-  if (!options.keepRef)
-    delete element.__ref;
+  if (!options.keepRef) delete element.__ref;
   return element;
 };
 export {

package/dist/esm/utils/propEvents.js

@@ -9,11 +9,9 @@ const propagateEventsFromProps = (element) => {
     if (isFunction(origEvent)) {
       on[eventName] = (...args) => {
         const originalEventRetunrs = origEvent(...args);
-        if (originalEventRetunrs !== false)
-          funcFromProps(...args);
+        if (originalEventRetunrs !== false) funcFromProps(...args);
       };
-    } else
-      on[eventName] = funcFromProps;
+    } else on[eventName] = funcFromProps;
   });
 };
 export {

package/methods/index.js

@@ -101,7 +101,7 @@ export function setNodeStyles (params = {}) {
   return el
 }
 
-export function remove (opts) {
+export async function remove (opts) {
   const element = this
   const beforeRemoveReturns = triggerEventOn('beforeRemove', element, opts)
   if (beforeRemoveReturns === false) return element
@@ -112,7 +112,7 @@ export function remove (opts) {
   }
   delete element.parent[element.key]
   if (element.parent.__ref) element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key)
-  triggerEventOn('remove', element, opts)
+  await triggerEventOn('remove', element, opts)
 }
 
 export function get (param) {

package/mixins/state.js

@@ -3,7 +3,7 @@
 import { IGNORE_STATE_PARAMS } from '@domql/state'
 import { exec, isObject } from '@domql/utils'
 
-export function state (params, element, node) {
+export async function state (params, element, node) {
   const state = exec(params, element)
 
   if (isObject(state)) {

package/node.js

@@ -34,7 +34,7 @@ export const createNode = async (element, options) => {
     } else node = element.node = cacheNode(element)
 
     // trigger `on.attachNode`
-    triggerEventOn('attachNode', element, options)
+    await triggerEventOn('attachNode', element, options)
   }
   // node.dataset // .key = element.key
 
@@ -72,7 +72,7 @@ export const createNode = async (element, options) => {
       isObject(REGISTRY[param])
     ) continue
 
-    const isElement = applyParam(param, element, options)
+    const isElement = await applyParam(param, element, options)
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement
       if (element[param] && !hasDefine && !hasContextDefine) {
@@ -85,7 +85,7 @@ export const createNode = async (element, options) => {
             await createAsync()
             // handle lazy load
             if (!options.preventUpdateListener) {
-              triggerEventOn('lazyLoad', element, options)
+              await triggerEventOn('lazyLoad', element, options)
             }
           })
         } else await createAsync()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.5.205",
+  "version": "2.5.207",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -29,10 +29,10 @@
   "dependencies": {
     "@domql/event": "^2.5.203",
     "@domql/render": "^2.5.203",
-    "@domql/state": "^2.5.203",
+    "@domql/state": "^2.5.206",
     "@domql/utils": "^2.5.203"
   },
-  "gitHead": "0e199902ea51b67aa7c0ca0446aae8e492d49789",
+  "gitHead": "f3418e9788c06eae1f37e1fbcc0fc0075f5b2742",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/props/create.js

@@ -24,7 +24,7 @@ const createPropsStack = (element, parent) => {
   return propsStack
 }
 
-export const syncProps = (props, element, opts) => {
+export const syncProps = async (props, element, opts) => {
   element.props = {}
   const mergedProps = {}
 
@@ -45,7 +45,7 @@ export const syncProps = (props, element, opts) => {
   })
   element.props = mergedProps
 
-  const methods = { update: update.bind(element.props), __element: element }
+  const methods = { update: await update.bind(element.props), __element: element }
   Object.setPrototypeOf(element.props, methods)
 
   return element.props
@@ -81,7 +81,7 @@ export const createProps = function (element, parent, options) {
   return element
 }
 
-function update (props, options) {
+async function update (props, options) {
   const element = this.__element
-  element.update({ props }, options)
+  await element.update({ props }, options)
 }

package/set.js

@@ -67,7 +67,7 @@ export const set = async function (params, options = {}, el) {
         await resetElement(params, element, options)
         // handle lazy load
         if (!options.preventUpdateListener) {
-          triggerEventOn('lazyLoad', element, options)
+          await triggerEventOn('lazyLoad', element, options)
         }
       })
     } else await resetElement(params, element, options)

package/update.js

@@ -90,7 +90,7 @@ export const update = async function (params = {}, opts) {
   throughUpdatedDefine(element)
 
   if (!options.isForced && !options.preventListeners) {
-    triggerEventOn('beforeClassAssign', element, options)
+    await triggerEventOn('beforeClassAssign', element, options)
   }
 
   if (!ref.__if) return false
@@ -155,7 +155,7 @@ export const update = async function (params = {}, opts) {
         await childUpdateCall()
         // handle lazy load
         if (!options.preventUpdateListener) {
-          triggerEventOn('lazyLoad', element, options)
+          await triggerEventOn('lazyLoad', element, options)
         }
       }) : await childUpdateCall()
     }
@@ -294,7 +294,7 @@ const inheritStateUpdates = async (element, options) => {
   }
 
   // Recreate the state again
-  const newState = createStateUpdate(element, parent, options)
+  const newState = await createStateUpdate(element, parent, options)
 
   // Trigger on.stateUpdate event
   if (!options.preventStateUpdateListener && !options.preventListeners) {
@@ -302,9 +302,9 @@ const inheritStateUpdates = async (element, options) => {
   }
 }
 
-const createStateUpdate = (element, parent, options) => {
+const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children
-  const newState = createState(element, parent)
+  const newState = await createState(element, parent)
   element.state = newState
   for (const child in __stateChildren) {
     // check this for inherited states