@domql/element 2.5.200 → 3.0.0

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,20 +27,18 @@ __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;
     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) {
@@ -49,13 +48,17 @@ const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS
     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;
       }
     }
@@ -76,6 +79,8 @@ const throughExecProps = (element) => {
     }
   }
 };
+const isPropertyInDefines = (key, element) => {
+};
 const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
@@ -84,7 +89,7 @@ const throughInitialDefine = (element) => {
   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) {
@@ -92,7 +97,12 @@ const throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state, element.context);
+    const execParam = defineObj[param](
+      elementProp,
+      element,
+      element.state,
+      element.context
+    );
     if (execParam) element[param] = execParam;
   }
   return element;
@@ -105,9 +115,15 @@ 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);
+    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);
+    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,36 +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) (options.strict ? import_utils.merge : import_utils.overwrite)(proto, 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;
@@ -77,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]));

package/dist/cjs/mixins/attr.js

@@ -24,17 +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 (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) node.setAttribute(attr2, val);
-      else if (node.removeAttribute) node.removeAttribute(attr2);
+    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);
       __attr[attr2] = val;
     }
   }

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

package/dist/cjs/mixins/state.js

@@ -22,13 +22,12 @@ __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 (import_utils.STATE_METHODS.includes(param)) continue;
       if (!Object.hasOwnProperty.call(state2, param)) continue;
     }
   }

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);
   }
@@ -36,7 +36,7 @@ function text(param, element, node) {
       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");
+    } else await (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
   }
 }
 var text_default = text;

package/dist/cjs/node.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
@@ -25,59 +35,59 @@ module.exports = __toCommonJS(node_exports);
 var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
 var import_render = require("@domql/render");
-var import_methods = require("./methods/index.js");
 var import_create = require("./create.js");
 var import_iterate = require("./iterate.js");
 var import_mixins = require("./mixins/index.js");
 var import_applyParam = require("./utils/applyParam.js");
-var import_propEvents = require("./utils/propEvents.js");
+var import_children = __toESM(require("./children.js"), 1);
+var import_set = require("./set.js");
 const ENV = "development";
-const createNode = async (element, options) => {
+const createNode = async (element, opts) => {
   let { node, tag, __ref: ref } = element;
+  if (!ref.__if) return element;
   let isNewNode;
   if (!node) {
     isNewNode = true;
-    if (!ref.__if) return element;
     if (tag === "shadow") {
       node = element.node = element.parent.node.attachShadow({ mode: "open" });
     } else node = element.node = (0, import_render.cacheNode)(element);
-    (0, import_event.triggerEventOn)("attachNode", element, options);
+    await (0, import_event.triggerEventOn)("attachNode", element, opts);
   }
-  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+  if (ENV === "test" || ENV === "development" || opts.alowRefReference) {
     node.ref = element;
     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);
-  if (element.tag !== "string" && element.tag !== "fragment") {
-    (0, import_propEvents.propagateEventsFromProps)(element);
-    if (isNewNode && (0, import_utils.isObject)(element.on)) {
-      (0, import_event.applyEventsOnNode)(element, options);
-    }
-  }
+  await (0, import_iterate.throughExecProps)(element);
+  await (0, import_iterate.throughInitialDefine)(element);
+  await (0, import_iterate.throughInitialExec)(element);
+  await (0, import_event.applyEventsOnNode)(element, { isNewNode, ...opts });
   for (const param in element) {
     const value = element[param];
-    if (!Object.hasOwnProperty.call(element, param)) continue;
-    if ((0, import_utils.isUndefined)(value) || (0, import_methods.isMethod)(param, element) || (0, import_utils.isVariant)(param) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) continue;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    if (!Object.hasOwnProperty.call(element, param) || (0, import_utils.isUndefined)(value) || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) {
+      continue;
+    }
+    const isElement = await (0, import_applyParam.applyParam)(param, element, opts);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       if (element[param] && !hasDefine && !hasContextDefine) {
         const createAsync = async () => {
-          await (0, import_create.create)((0, import_utils.exec)(value, element), element, param, options);
+          await (0, import_create.create)(value, element, param, opts);
         };
-        if (element.props && element.props.lazyLoad || options.lazyLoad) {
+        if (element.props && element.props.lazyLoad || opts.lazyLoad) {
           window.requestAnimationFrame(async () => {
             await createAsync();
-            if (!options.preventUpdateListener) {
-              (0, import_event.triggerEventOn)("lazyLoad", element, options);
+            if (!opts.preventUpdateListener) {
+              await (0, import_event.triggerEventOn)("lazyLoad", element, opts);
             }
           });
         } else await createAsync();
       }
     }
   }
+  const content = element.children ? await (0, import_children.default)(element.children, element, opts) : element.content || element.content;
+  if (content) {
+    await (0, import_set.setContent)(content, element, opts);
+  }
   return element;
 };
 var node_default = createNode;