@domql/element 2.5.198 → 3.0.0

package/dist/cjs/index.js

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var element_exports = {};
-__export(element_exports, {
+var index_exports = {};
+__export(index_exports, {
   TREE: () => import_tree.TREE,
   create: () => import_create.default,
   createNode: () => import_node.default,
@@ -35,7 +35,7 @@ __export(element_exports, {
   set: () => import_set.default,
   update: () => import_update.default
 });
-module.exports = __toCommonJS(element_exports);
+module.exports = __toCommonJS(index_exports);
 var import_tree = require("./tree");
 var import_create = __toESM(require("./create"), 1);
 var import_node = __toESM(require("./node"), 1);

package/dist/cjs/iterate.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var iterate_exports = {};
 __export(iterate_exports, {
+  isPropertyInDefines: () => isPropertyInDefines,
   throughExecProps: () => throughExecProps,
   throughInitialDefine: () => throughInitialDefine,
   throughInitialExec: () => throughInitialExec,
@@ -26,38 +27,38 @@ __export(iterate_exports, {
 });
 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 { __ref: ref } = element;
   for (const param in element) {
-    if (exclude[param])
-      continue;
+    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)) {
+    if ((0, import_utils.isFunction)(prop) && !(0, import_utils.isMethod)(param, element)) {
       ref.__exec[param] = prop;
       element[param] = prop(element, element.state, element.context);
     }
   }
 };
-const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS_EXL }) => {
+const throughUpdatedExec = (element, options = {}) => {
   const { __ref: ref } = element;
   const changes = {};
   for (const param in ref.__exec) {
     const prop = element[param];
     const isDefinedParam = ref.__defineCache[param];
-    if (isDefinedParam)
-      continue;
+    if (isDefinedParam) continue;
     const newExec = 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);
+      (0, import_utils.overwrite)(prop, { text: newExec });
     } else if (newExec !== prop) {
-      if ((0, import_utils.checkIfKeyIsComponent)(param)) {
-        const { extend, ...newElem } = (0, import_utils.extendizeByKey)(newExec, element, param);
-        (0, import_utils2.overwrite)(prop, newElem, options);
+      if ((0, import_utils.matchesComponentNaming)(param)) {
+        const { extends: extend, ...newElem } = (0, import_utils.isContextComponent)(
+          newExec,
+          element,
+          param
+        );
+        (0, import_utils.overwrite)(prop, newElem);
       } else {
-        ref.__cached[param] = changes[param] = prop;
+        changes[param] = prop;
         element[param] = newExec;
       }
     }
@@ -78,17 +79,17 @@ const throughExecProps = (element) => {
     }
   }
 };
+const isPropertyInDefines = (key, element) => {
+};
 const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
-  if ((0, import_utils.isObject)(define))
-    defineObj = { ...define };
-  if (hasGlobalDefine)
-    defineObj = { ...defineObj, ...context.define };
+  if ((0, import_utils.isObject)(define)) defineObj = { ...define };
+  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
   for (const param in defineObj) {
     let elementProp = element[param];
-    if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
+    if ((0, import_utils.isFunction)(elementProp) && !(0, import_utils.isMethod)(param, element)) {
       ref.__exec[param] = elementProp;
       const execParam2 = elementProp = (0, import_utils.exec)(elementProp, element);
       if (execParam2) {
@@ -96,9 +97,13 @@ const throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state, element.context);
-    if (execParam)
-      element[param] = execParam;
+    const execParam = defineObj[param](
+      elementProp,
+      element,
+      element.state,
+      element.context
+    );
+    if (execParam) element[param] = execParam;
   }
   return element;
 };
@@ -106,18 +111,20 @@ const throughUpdatedDefine = (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
-  if ((0, import_utils.isObject)(define))
-    obj = { ...define };
-  if ((0, import_utils.isObject)(context && context.define))
-    obj = { ...obj, ...context.define };
+  if ((0, import_utils.isObject)(define)) obj = { ...define };
+  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);
+    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 (newExecParam)
-      element[param] = newExecParam;
+    const newExecParam = typeof obj[param] === "function" ? obj[param](cached, element, element.state, element.context) : void 0;
+    if (newExecParam) element[param] = newExecParam;
   }
   return changes;
 };

package/dist/cjs/methods/set.js

@@ -24,37 +24,38 @@ module.exports = __toCommonJS(set_exports);
 var import_utils = require("@domql/utils");
 var import_set = require("../set.js");
 var import_update = require("../update.js");
-var import_content = require("../mixins/content.js");
-var import_index = require("./index.js");
+var import_methods = require("@domql/utils/methods");
 const addMethods = (element, parent, options = {}) => {
   const proto = {
     set: import_set.set,
     reset: import_set.reset,
     update: import_update.update,
-    variables: import_index.variables,
-    remove: import_index.remove,
-    updateContent: import_content.updateContent,
-    removeContent: import_content.removeContent,
-    setProps: import_index.setProps,
-    lookup: import_index.lookup,
-    lookdown: import_index.lookdown,
-    lookdownAll: import_index.lookdownAll,
-    getRef: import_index.getRef,
-    getPath: import_index.getPath,
-    setNodeStyles: import_index.setNodeStyles,
-    spotByPath: import_index.spotByPath,
-    parse: import_index.parse,
-    parseDeep: import_index.parseDeep,
-    keys: import_index.keys,
-    nextElement: import_index.nextElement,
-    previousElement: import_index.previousElement,
-    log: import_index.log,
-    verbose: import_index.verbose,
-    warn: import_index.warn,
-    error: import_index.error,
-    call: import_index.call
+    variables: import_methods.variables,
+    remove: import_methods.remove,
+    updateContent: import_set.updateContent,
+    removeContent: import_set.removeContent,
+    setProps: import_methods.setProps,
+    lookup: import_methods.lookup,
+    lookdown: import_methods.lookdown,
+    lookdownAll: import_methods.lookdownAll,
+    getRef: import_methods.getRef,
+    getPath: import_methods.getPath,
+    setNodeStyles: import_methods.setNodeStyles,
+    spotByPath: import_methods.spotByPath,
+    parse: import_methods.parse,
+    parseDeep: import_methods.parseDeep,
+    keys: import_methods.keys,
+    nextElement: import_methods.nextElement,
+    previousElement: import_methods.previousElement,
+    log: import_methods.log,
+    verbose: import_methods.verbose,
+    warn: import_methods.warn,
+    error: import_methods.error,
+    call: import_methods.call
   };
-  if (element.context.methods)
+  if (element.context.methods) {
+    ;
     (options.strict ? import_utils.merge : import_utils.overwrite)(proto, element.context.methods);
+  }
   Object.setPrototypeOf(element, proto);
 };

package/dist/cjs/methods/v2.js

@@ -28,15 +28,11 @@ __export(v2_exports, {
 });
 module.exports = __toCommonJS(v2_exports);
 var import_utils = require("@domql/utils");
-var import_mixins = require("../mixins/index.js");
 const defineSetter = (element, key, get, set) => Object.defineProperty(element, key, { get, set });
 const keys = function() {
   const element = this;
   const keys2 = [];
   for (const param in element) {
-    if (import_mixins.REGISTRY[param] && !import_mixins.parseFilters.elementKeys.includes(param)) {
-      continue;
-    }
     keys2.push(param);
   }
   return keys2;
@@ -46,19 +42,15 @@ const parse = function(excl = []) {
   const obj = {};
   const keyList = keys.call(element);
   keyList.forEach((v) => {
-    if (excl.includes(v))
-      return;
+    if (excl.includes(v)) return;
     let val = element[v];
     if (v === "state") {
-      if (element.__ref && element.__ref.__hasRootState)
-        return;
-      if ((0, import_utils.isFunction)(val && val.parse))
-        val = val.parse();
+      if (element.__ref && element.__ref.__hasRootState) return;
+      if ((0, import_utils.isFunction)(val && val.parse)) val = val.parse();
     } else if (v === "props") {
       const { __element, update, ...props } = element[v];
       obj[v] = props;
-    } else if ((0, import_utils.isDefined)(val))
-      obj[v] = val;
+    } else if ((0, import_utils.isDefined)(val)) obj[v] = val;
   });
   return obj;
 };
@@ -66,8 +58,7 @@ const parseDeep = function(excl = []) {
   const element = this;
   const obj = parse.call(element, excl);
   for (const v in obj) {
-    if (excl.includes(v))
-      return;
+    if (excl.includes(v)) return;
     if ((0, import_utils.isObjectLike)(obj[v])) {
       obj[v] = parseDeep.call(obj[v], excl);
     }
@@ -82,7 +73,7 @@ const log = function(...args) {
     args.forEach((v) => console.log(`%c${v}:
 `, "font-weight: bold", element[v]));
   } else {
-    console.log(__ref.path);
+    console.log(__ref == null ? void 0 : __ref.path);
     const keys2 = element.keys();
     keys2.forEach((v) => console.log(`%c${v}:
 `, "font-weight: bold", element[v]));
@@ -102,8 +93,7 @@ const previousElement = function(el) {
   const element = el || this;
   const { key, parent } = element;
   const { __children } = parent.__ref;
-  if (!__children)
-    return;
+  if (!__children) return;
   const currentIndex = __children.indexOf(key);
   return parent[__children[currentIndex - 1]];
 };

package/dist/cjs/mixins/attr.js

@@ -24,21 +24,18 @@ __export(attr_exports, {
 module.exports = __toCommonJS(attr_exports);
 var import_utils = require("@domql/utils");
 var import_report = require("@domql/report");
-var import_utils2 = require("../utils/index.js");
 function attr(params, element, node) {
   const { __ref: ref, props } = element;
   const { __attr } = ref;
-  if ((0, import_utils.isNot)("object"))
-    (0, import_report.report)("HTMLInvalidAttr", params);
+  if ((0, import_utils.isNot)("object")) (0, import_report.report)("HTMLInvalidAttr", params);
   if (params) {
-    if (props.attr)
-      (0, import_utils2.deepMerge)(params, props.attr);
-    for (const attr2 in params) {
-      const val = (0, import_utils.exec)(params[attr2], element);
-      if (val !== false && !(0, import_utils.isUndefined)(val) && !(0, import_utils.isNull)(val) && node.setAttribute)
+    const attrs = (0, import_utils.exec)(params, element);
+    if (props.attr) (0, import_utils.deepMerge)(attrs, props.attr);
+    for (const attr2 in attrs) {
+      const val = (0, import_utils.exec)(attrs[attr2], element);
+      if (val !== false && !(0, import_utils.isUndefined)(val) && !(0, import_utils.isNull)(val) && node.setAttribute) {
         node.setAttribute(attr2, val);
-      else if (node.removeAttribute)
-        node.removeAttribute(attr2);
+      } else if (node.removeAttribute) node.removeAttribute(attr2);
       __attr[attr2] = val;
     }
   }

package/dist/cjs/mixins/classList.js

@@ -29,8 +29,7 @@ module.exports = __toCommonJS(classList_exports);
 var import_utils = require("@domql/utils");
 const assignKeyAsClassname = (element) => {
   const { key } = element;
-  if (element.class === true)
-    element.class = key;
+  if (element.class === true) element.class = key;
   else if (!element.class && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
     element.class = key.slice(1);
   }
@@ -39,10 +38,8 @@ const classify = (obj, element) => {
   let className = "";
   for (const item in obj) {
     const param = obj[item];
-    if (typeof param === "boolean" && param)
-      className += ` ${item}`;
-    else if (typeof param === "string")
-      className += ` ${param}`;
+    if (typeof param === "boolean" && param) className += ` ${item}`;
+    else if (typeof param === "string") className += ` ${param}`;
     else if (typeof param === "function") {
       className += ` ${(0, import_utils.exec)(param, element)}`;
     }
@@ -50,18 +47,13 @@ const classify = (obj, element) => {
   return className;
 };
 const classList = (params, element) => {
-  if (!params)
-    return;
+  if (!params) return;
   const { key } = element;
-  if (params === true)
-    params = element.class = { key };
-  if ((0, import_utils.isString)(params))
-    params = element.class = { default: params };
-  if ((0, import_utils.isObject)(params))
-    params = classify(params, element);
+  if (params === true) params = element.class = { key };
+  if ((0, import_utils.isString)(params)) params = element.class = { default: params };
+  if ((0, import_utils.isObject)(params)) params = classify(params, element);
   const className = params.replace(/\s+/g, " ").trim();
-  if (element.ref)
-    element.ref.class = className;
+  if (element.ref) element.ref.class = className;
   return className;
 };
 const applyClassListOnNode = (params, element, node) => {

package/dist/cjs/mixins/data.js

@@ -26,11 +26,9 @@ var import_utils = require("@domql/utils");
 var import_report = require("@domql/report");
 function data(params, element, node) {
   if (params) {
-    if (element.props.data)
-      (0, import_utils.deepMerge)(params, element.props.data);
+    if (element.props.data) (0, import_utils.deepMerge)(params, element.props.data);
     if (params.showOnNode) {
-      if (!(0, import_utils.isObject)(params))
-        (0, import_report.report)("HTMLInvalidData", params);
+      if (!(0, import_utils.isObject)(params)) (0, import_report.report)("HTMLInvalidData", params);
       for (const dataset in params) {
         if (dataset !== "showOnNode") {
           node.dataset[dataset] = (0, import_utils.exec)(params[dataset], element);

package/dist/cjs/mixins/html.js

@@ -28,10 +28,8 @@ function html(param, element, node) {
   const prop = (0, import_utils.exec)(param, element) || (0, import_utils.exec)((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.html, element);
   const { __ref } = element;
   if (prop !== __ref.__html) {
-    if (node.nodeName === "SVG")
-      node.textContent = prop;
-    else
-      node.innerHTML = prop;
+    if (node.nodeName === "SVG") node.textContent = prop;
+    else node.innerHTML = prop;
     __ref.__html = prop;
   }
 }

package/dist/cjs/mixins/index.js

@@ -21,10 +21,8 @@ var mixins_exports = {};
 __export(mixins_exports, {
   attr: () => import_attr.attr,
   classList: () => import_classList.applyClasslist,
-  content: () => import_content.setContent,
   data: () => import_data.data,
   html: () => import_html.html,
-  registry: () => import_registry.REGISTRY,
   scope: () => import_scope.scope,
   state: () => import_state.state,
   style: () => import_style.style,
@@ -33,12 +31,10 @@ __export(mixins_exports, {
 module.exports = __toCommonJS(mixins_exports);
 var import_attr = require("./attr.js");
 var import_classList = require("./classList.js");
-var import_content = require("./content.js");
 var import_data = require("./data.js");
 var import_html = require("./html.js");
 var import_style = require("./style.js");
 var import_text = require("./text.js");
 var import_state = require("./state.js");
 var import_scope = require("./scope.js");
-var import_registry = require("./registry.js");
 __reExport(mixins_exports, require("./registry.js"), module.exports);

package/dist/cjs/mixins/registry.js

@@ -29,14 +29,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var registry_exports = {};
 __export(registry_exports, {
   REGISTRY: () => REGISTRY,
-  collectionFilters: () => collectionFilters,
-  default: () => registry_default,
-  parseFilters: () => parseFilters
+  default: () => registry_default
 });
 module.exports = __toCommonJS(registry_exports);
 var import_attr = __toESM(require("./attr.js"), 1);
 var import_classList = require("./classList.js");
-var import_content = __toESM(require("./content.js"), 1);
 var import_data = __toESM(require("./data.js"), 1);
 var import_html = __toESM(require("./html.js"), 1);
 var import_scope = __toESM(require("./scope.js"), 1);
@@ -48,88 +45,31 @@ const REGISTRY = {
   style: import_style.default,
   text: import_text.default,
   html: import_html.default,
-  content: import_content.default,
   data: import_data.default,
   class: import_classList.classList,
   state: import_state.default,
   scope: import_scope.default,
   deps: (param, el) => param || el.parent.deps,
-  extend: {},
-  childExtend: {},
-  childExtendRecursive: {},
+  extends: {},
+  children: {},
+  content: {},
+  childExtends: {},
+  childExtendsRecursive: {},
   props: {},
-  path: {},
   if: {},
   define: {},
-  transform: {},
   __name: {},
   __ref: {},
   __hash: {},
   __text: {},
-  nextElement: {},
-  previousElement: {},
   key: {},
   tag: {},
   query: {},
   parent: {},
   node: {},
-  set: {},
-  reset: {},
-  update: {},
-  error: {},
-  warn: {},
-  call: {},
-  setProps: {},
-  remove: {},
-  updateContent: {},
-  removeContent: {},
   variables: {},
-  lookup: {},
-  lookdown: {},
-  getRef: {},
-  getPath: {},
-  lookdownAll: {},
-  setNodeStyles: {},
-  spotByPath: {},
-  keys: {},
-  log: {},
-  parse: {},
-  parseDeep: {},
   on: {},
   component: {},
-  context: {},
-  $collection: {},
-  $stateCollection: {},
-  $propsCollection: {},
-  $setCollection: {},
-  $setStateCollection: {},
-  $setPropsCollection: {}
+  context: {}
 };
 var registry_default = REGISTRY;
-const parseFilters = {
-  elementKeys: [
-    "tag",
-    "text",
-    "style",
-    "attr",
-    "class",
-    "state",
-    "props",
-    "data",
-    "content",
-    "html",
-    "on",
-    "key",
-    "extend",
-    "childExtend",
-    "childExtendRecursive",
-    "scope",
-    "query",
-    "$collection",
-    "$stateCollection",
-    "$propsCollection"
-  ],
-  propsKeys: ["__element", "update"],
-  stateKeys: []
-};
-const collectionFilters = ["$collection", "$stateCollection", "$propsCollection"];

package/dist/cjs/mixins/scope.js

@@ -23,9 +23,8 @@ __export(scope_exports, {
 });
 module.exports = __toCommonJS(scope_exports);
 var import_utils = require("@domql/utils");
-function scope(params, element, node) {
-  if (!(0, import_utils.isObject)(params))
-    return;
+async function scope(params, element, node) {
+  if (!(0, import_utils.isObject)(params)) return;
   for (const scopeItem in params) {
     const value = params[scopeItem];
     if ((0, import_utils.isFunction)(value)) {

package/dist/cjs/mixins/state.js

@@ -22,16 +22,13 @@ __export(state_exports, {
   state: () => state
 });
 module.exports = __toCommonJS(state_exports);
-var import_state = require("@domql/state");
 var import_utils = require("@domql/utils");
-function state(params, element, node) {
-  const state2 = (0, import_utils.exec)(params, element);
+async function state(params, element, node) {
+  const state2 = await (0, import_utils.execPromise)(params, element);
   if ((0, import_utils.isObject)(state2)) {
     for (const param in state2) {
-      if (import_state.IGNORE_STATE_PARAMS.includes(param))
-        continue;
-      if (!Object.hasOwnProperty.call(state2, param))
-        continue;
+      if (import_utils.STATE_METHODS.includes(param)) continue;
+      if (!Object.hasOwnProperty.call(state2, param)) continue;
     }
   }
   return element;

package/dist/cjs/mixins/style.js

@@ -26,10 +26,8 @@ var import_utils = require("@domql/utils");
 var import_report = require("@domql/report");
 function style(params, element, node) {
   if (params) {
-    if ((0, import_utils.isObject)(params))
-      (0, import_utils.map)(node.style, params, element);
-    else
-      (0, import_report.report)("HTMLInvalidStyles", params);
+    if ((0, import_utils.isObject)(params)) (0, import_utils.map)(node.style, params, element);
+    else (0, import_report.report)("HTMLInvalidStyles", params);
   }
 }
 var style_default = style;

package/dist/cjs/mixins/text.js

@@ -24,8 +24,8 @@ __export(text_exports, {
 module.exports = __toCommonJS(text_exports);
 var import_create = require("../create.js");
 var import_utils = require("@domql/utils");
-function text(param, element, node) {
-  let prop = (0, import_utils.exec)(param, element);
+async function text(param, element, node) {
+  let prop = (0, import_utils.exec)(param || element.props.text, element);
   if ((0, import_utils.isString)(prop) && prop.includes("{{")) {
     prop = element.call("replaceLiteralsWithObjectFields", prop);
   }
@@ -33,13 +33,10 @@ function text(param, element, node) {
     node.nodeValue = prop;
   } else if (param !== void 0 || param !== null) {
     if (element.__text) {
-      if (element.__text.text === prop)
-        return;
+      if (element.__text.text === prop) return;
       element.__text.text = prop;
-      if (element.__text.node)
-        element.__text.node.nodeValue = prop;
-    } else
-      (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
+      if (element.__text.node) element.__text.node.nodeValue = prop;
+    } else await (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
   }
 }
 var text_default = text;