@domql/element 2.28.41 → 2.28.44

package/create.js

@@ -78,7 +78,7 @@ export const create = async (
   element.key = key
 
   if (options.onlyResolveExtends) {
-    return onlyResolveExtends(element, parent, key, options)
+    return await onlyResolveExtends(element, parent, key, options)
   }
 
   await triggerEventOn('start', element, options)
@@ -386,7 +386,7 @@ const addCaching = (element, parent) => {
   // }
 }
 
-const onlyResolveExtends = (element, parent, key, options) => {
+const onlyResolveExtends = async (element, parent, key, options) => {
   const { __ref: ref } = element
   if (!ref.__skipCreate) {
     addCaching(element, parent)
@@ -416,8 +416,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
   }
 
   if (element.tag !== 'string' && element.tag !== 'fragment') {
-    throughInitialDefine(element)
-    throughInitialExec(element)
+    await throughInitialDefine(element)
+    await throughInitialExec(element)
 
     for (const k in element) {
       if (

package/dist/cjs/create.js

@@ -55,7 +55,7 @@ const create = async (element, parent, key, options = import_options.OPTIONS.cre
   }
   element.key = key;
   if (options.onlyResolveExtends) {
-    return onlyResolveExtends(element, parent, key, options);
+    return await onlyResolveExtends(element, parent, key, options);
   }
   await (0, import_event.triggerEventOn)("start", element, options);
   switchDefaultOptions(element, parent, options);
@@ -257,7 +257,7 @@ const addCaching = (element, parent) => {
   if (!parentRef.path) parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
-const onlyResolveExtends = (element, parent, key, options) => {
+const onlyResolveExtends = async (element, parent, key, options) => {
   const { __ref: ref } = element;
   if (!ref.__skipCreate) {
     addCaching(element, parent);
@@ -277,8 +277,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     addElementIntoParentChildren(element, parent);
   }
   if (element.tag !== "string" && element.tag !== "fragment") {
-    (0, import_iterate.throughInitialDefine)(element);
-    (0, import_iterate.throughInitialExec)(element);
+    await (0, import_iterate.throughInitialDefine)(element);
+    await (0, import_iterate.throughInitialExec)(element);
     for (const k in element) {
       if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)((import_mixins.registry.default || import_mixins.registry)[k]) || (0, import_utils.isVariant)(k))
         continue;

package/dist/cjs/iterate.js

@@ -28,25 +28,29 @@ module.exports = __toCommonJS(iterate_exports);
 var import_utils = require("@domql/utils");
 var import_utils2 = require("./utils/index.js");
 var import_methods = require("./methods/index.js");
-const throughInitialExec = (element, exclude = {}) => {
+const throughInitialExec = async (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
     if (exclude[param]) continue;
     const prop = element[param];
     if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = prop;
-      element[param] = prop(element, element.state, element.context);
+      element[param] = await prop(element, element.state, element.context);
     }
   }
 };
-const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS_EXL }) => {
+const throughUpdatedExec = async (element, options = { excludes: import_utils2.METHODS_EXL }) => {
   const { __ref: ref } = element;
   const changes = {};
   for (const param in ref.__exec) {
     const prop = element[param];
     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 = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
     if (prop && prop.node && execReturnsString) {
       (0, import_utils2.overwrite)(prop, { text: newExec }, options);
@@ -76,7 +80,7 @@ const throughExecProps = (element) => {
     }
   }
 };
-const throughInitialDefine = (element) => {
+const throughInitialDefine = async (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
@@ -86,18 +90,23 @@ const throughInitialDefine = (element) => {
     let elementProp = element[param];
     if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = elementProp;
-      const execParam2 = elementProp = (0, import_utils.exec)(elementProp, element);
+      const execParam2 = elementProp = await (0, import_utils.exec)(elementProp, element);
       if (execParam2) {
         elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
         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;
 };
-const throughUpdatedDefine = (element) => {
+const throughUpdatedDefine = async (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
@@ -105,9 +114,19 @@ const throughUpdatedDefine = (element) => {
   if ((0, import_utils.isObject)(context && context.define)) obj = { ...obj, ...context.define };
   for (const param in obj) {
     const execParam = ref.__exec[param];
-    if (execParam) ref.__defineCache[param] = execParam(element, element.state, element.context);
-    const cached = (0, import_utils.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 (0, import_utils.exec)(ref.__defineCache[param], element);
+    const newExecParam = await obj[param](
+      cached,
+      element,
+      element.state,
+      element.context
+    );
     if (newExecParam) element[param] = newExecParam;
   }
   return changes;

package/dist/cjs/methods/index.js

@@ -23,6 +23,7 @@ __export(methods_exports, {
   defineSetter: () => defineSetter,
   error: () => error,
   get: () => get,
+  getChildren: () => getChildren,
   getPath: () => getPath,
   getRef: () => getRef,
   isMethod: () => isMethod,
@@ -156,9 +157,14 @@ function setProps(param, options) {
   element.update({ props: param }, options);
   return element;
 }
-function getRef() {
+function getRef(key) {
+  if (key) return this.__ref && this.__ref[key];
   return this.__ref;
 }
+function getChildren() {
+  const __children = this.getRef("__children");
+  return __children.map((k) => this[k]);
+}
 function getPath() {
   return this.getRef().path;
 }
@@ -315,6 +321,7 @@ const METHODS = [
   "lookdown",
   "lookdownAll",
   "getRef",
+  "getChildren",
   "getPath",
   "setNodeStyles",
   "spotByPath",

package/dist/cjs/node.js

@@ -48,8 +48,8 @@ const createNode = async (element, options) => {
     if ((0, import_utils.isFunction)(node.setAttribute)) node.setAttribute("key", element.key);
   }
   (0, import_iterate.throughExecProps)(element);
-  (0, import_iterate.throughInitialDefine)(element);
-  (0, import_iterate.throughInitialExec)(element);
+  await (0, import_iterate.throughInitialDefine)(element);
+  await (0, import_iterate.throughInitialExec)(element);
   if (element.tag !== "string" && element.tag !== "fragment") {
     (0, import_propEvents.propagateEventsFromProps)(element);
     if (isNewNode && (0, import_utils.isObject)(element.on)) {

package/dist/cjs/update.js

@@ -46,17 +46,25 @@ const UPDATE_DEFAULT_OPTIONS = {
 };
 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"] });
+  const options = (0, import_utils.deepClone)(
+    (0, import_utils.isObject)(opts) ? (0, import_utils2.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 (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return;
+  if (!options.preventListeners)
+    await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return;
   if (!excludes) (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
   if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
     params = { text: params };
@@ -72,13 +80,18 @@ const update = async function(params = {}, opts) {
     if (props) (0, import_props.updateProps)(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
+    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
     if (beforeUpdateReturns === false) return element;
   }
   (0, import_utils.overwriteDeep)(element, params, { exclude: import_utils2.METHODS_EXL });
   (0, import_iterate.throughExecProps)(element);
-  (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
-  (0, import_iterate.throughUpdatedDefine)(element);
+  await (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  await (0, import_iterate.throughUpdatedDefine)(element);
   if (!options.isForced && !options.preventListeners) {
     await (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
@@ -97,8 +110,10 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
-    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
+    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount)
+      return;
+    else if (options.preventUpdateAfterCount === void 0)
+      options.preventUpdateAfterCount = 1;
     else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
@@ -107,7 +122,8 @@ const update = async function(params = {}, opts) {
     const isInPreventUpdate = (0, import_utils.isArray)(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = (0, import_utils.isArray)(preventDefineUpdate) && preventDefineUpdate.includes(param);
     const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || (0, import_utils.isVariant)(param)) continue;
+    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || (0, import_utils.isVariant)(param))
+      continue;
     if (preventStateUpdate === "once") options.preventStateUpdate = false;
     const isElement = await (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {
@@ -150,9 +166,15 @@ const captureSnapshot = (element, options) => {
 };
 const checkIfOnUpdate = (element, parent, options) => {
   var _a, _b, _c;
-  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent) return;
+  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.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;
@@ -175,7 +197,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;
@@ -188,7 +211,13 @@ const checkIfOnUpdate = (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = (0, import_create.create)(element, parent, element.key, import_options.OPTIONS.create, attachOptions);
+      const createdElement = (0, import_create.create)(
+        element,
+        parent,
+        element.key,
+        import_options.OPTIONS.create,
+        attachOptions
+      );
       if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
         (0, import_event.applyEvent)(element.on.update, createdElement, createdElement.state);
       }
@@ -212,18 +241,33 @@ const inheritStateUpdates = async (element, options) => {
   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 });
+    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) {
-    const initStateReturns = await (0, import_event.triggerEventOnUpdate)("beforeStateUpdate", keyInParentState, element, options);
+    const initStateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeStateUpdate",
+      keyInParentState,
+      element,
+      options
+    );
     if (initStateReturns === false) return element;
   }
   const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await (0, import_event.triggerEventOnUpdate)("stateUpdate", newState.parse(), element, options);
+    await (0, import_event.triggerEventOnUpdate)(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
   }
 };
 const createStateUpdate = async (element, parent, options) => {

package/dist/esm/create.js

@@ -51,7 +51,7 @@ const create = async (element, parent, key, options = OPTIONS.create || {}, atta
   }
   element.key = key;
   if (options.onlyResolveExtends) {
-    return onlyResolveExtends(element, parent, key, options);
+    return await onlyResolveExtends(element, parent, key, options);
   }
   await triggerEventOn("start", element, options);
   switchDefaultOptions(element, parent, options);
@@ -253,7 +253,7 @@ const addCaching = (element, parent) => {
   if (!parentRef.path) parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
-const onlyResolveExtends = (element, parent, key, options) => {
+const onlyResolveExtends = async (element, parent, key, options) => {
   const { __ref: ref } = element;
   if (!ref.__skipCreate) {
     addCaching(element, parent);
@@ -273,8 +273,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     addElementIntoParentChildren(element, parent);
   }
   if (element.tag !== "string" && element.tag !== "fragment") {
-    throughInitialDefine(element);
-    throughInitialExec(element);
+    await throughInitialDefine(element);
+    await throughInitialExec(element);
     for (const k in element) {
       if (isUndefined(element[k]) || isMethod(k, element) || isObject((registry.default || registry)[k]) || isVariant(k))
         continue;

package/dist/esm/iterate.js

@@ -10,25 +10,29 @@ import {
 } from "@domql/utils";
 import { METHODS_EXL, overwrite } from "./utils/index.js";
 import { isMethod } from "./methods/index.js";
-const throughInitialExec = (element, exclude = {}) => {
+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);
     }
   }
 };
-const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
+const throughUpdatedExec = async (element, options = { excludes: METHODS_EXL }) => {
   const { __ref: ref } = element;
   const changes = {};
   for (const param in ref.__exec) {
     const prop = element[param];
     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) {
       overwrite(prop, { text: newExec }, options);
@@ -58,7 +62,7 @@ const throughExecProps = (element) => {
     }
   }
 };
-const throughInitialDefine = (element) => {
+const throughInitialDefine = async (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && isObject(context.define);
@@ -68,18 +72,23 @@ const throughInitialDefine = (element) => {
     let elementProp = element[param];
     if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
       ref.__exec[param] = elementProp;
-      const execParam2 = elementProp = exec(elementProp, element);
+      const execParam2 = elementProp = await exec(elementProp, element);
       if (execParam2) {
         elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
         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;
 };
-const throughUpdatedDefine = (element) => {
+const throughUpdatedDefine = async (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
@@ -87,9 +96,19 @@ const throughUpdatedDefine = (element) => {
   if (isObject(context && context.define)) obj = { ...obj, ...context.define };
   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/dist/esm/methods/index.js

@@ -119,9 +119,14 @@ function setProps(param, options) {
   element.update({ props: param }, options);
   return element;
 }
-function getRef() {
+function getRef(key) {
+  if (key) return this.__ref && this.__ref[key];
   return this.__ref;
 }
+function getChildren() {
+  const __children = this.getRef("__children");
+  return __children.map((k) => this[k]);
+}
 function getPath() {
   return this.getRef().path;
 }
@@ -278,6 +283,7 @@ const METHODS = [
   "lookdown",
   "lookdownAll",
   "getRef",
+  "getChildren",
   "getPath",
   "setNodeStyles",
   "spotByPath",
@@ -305,6 +311,7 @@ export {
   defineSetter,
   error,
   get,
+  getChildren,
   getPath,
   getRef,
   isMethod,

package/dist/esm/node.js

@@ -34,8 +34,8 @@ const createNode = async (element, options) => {
     if (isFunction(node.setAttribute)) node.setAttribute("key", element.key);
   }
   throughExecProps(element);
-  throughInitialDefine(element);
-  throughInitialExec(element);
+  await throughInitialDefine(element);
+  await throughInitialExec(element);
   if (element.tag !== "string" && element.tag !== "fragment") {
     propagateEventsFromProps(element);
     if (isNewNode && isObject(element.on)) {