domql 1.6.3 → 1.6.5

package/dist/cjs/element/create.js

@@ -28,19 +28,21 @@ __export(create_exports, {
 });
 module.exports = __toCommonJS(create_exports);
 var import_utils = require("@domql/utils");
+var import_tree = require("@domql/tree");
+var import_key = require("@domql/key");
 var import_registry = require("@domql/registry");
 var import_event = require("@domql/event");
-var import_root = __toESM(require("./root"));
-var import_node = __toESM(require("./node"));
-var import_assign = require("./assign");
+var import_render = require("@domql/render");
+var import_methods = require("@domql/methods");
+var import_classlist = require("@domql/classlist");
+var import_node = require("@domql/node");
+var import_node2 = __toESM(require("./node"));
 var import_extend = require("./extend");
 var import_set = __toESM(require("./set"));
 var import_state = __toESM(require("./state"));
 var import_props = __toESM(require("./props"));
 var import_update = __toESM(require("./update"));
-var import_classList = require("./mixins/classList");
-var import_methods = require("./methods");
-var import_cache = __toESM(require("./cache"));
+var import_methods2 = require("./methods");
 var import_mixins = require("./mixins");
 var import_iterate = require("./iterate");
 var import_options = __toESM(require("./options"));
@@ -69,13 +71,14 @@ const create = (element, parent, key, options = import_options.default.create ||
     element = { extend: element };
   }
   if (!parent)
-    parent = import_root.default;
-  if ((0, import_utils.isNode)(parent))
-    parent = import_root.default[`${key}_parent`] = { key: ":root", node: parent };
+    parent = import_tree.ROOT;
+  if ((0, import_utils.isNode)(parent)) {
+    parent = import_tree.ROOT[`${key}_parent`] = { key: ":root", node: parent };
+  }
   if (checkIfPrimitive(element)) {
     element = applyValueAsText(element, parent, key);
   }
-  const assignedKey = (element.key || key || (0, import_utils.createID)()).toString();
+  const assignedKey = (element.key || key || (0, import_key.createKey)()).toString();
   if ((0, import_component.checkIfKeyIsComponent)(assignedKey)) {
     element = (0, import_component.applyKeyComponentAsExtend)(element, parent, assignedKey);
   }
@@ -105,7 +108,7 @@ const create = (element, parent, key, options = import_options.default.create ||
   element.state = (0, import_state.default)(element, parent);
   checkIf(element, parent);
   if (element.node && __ref.__if) {
-    return (0, import_assign.assignNode)(element, parent, assignedKey);
+    return (0, import_render.assignNode)(element, parent, assignedKey);
   }
   if (__ref.__if)
     (0, import_props.default)(element, parent);
@@ -113,12 +116,11 @@ const create = (element, parent, key, options = import_options.default.create ||
   if (initReturns === false)
     return element;
   (0, import_event.triggerEventOn)("beforeClassAssign", element);
-  (0, import_classList.assignClass)(element);
-  console.log(element);
-  (0, import_node.default)(element, options);
+  (0, import_classlist.assignClass)(element);
+  (0, import_node2.default)(element, options);
   if (!__ref.__if)
     return element;
-  (0, import_assign.assignNode)(element, parent, key);
+  (0, import_render.assignNode)(element, parent, key);
   (0, import_event.triggerEventOn)("renderRouter", element);
   (0, import_event.triggerEventOn)("render", element);
   if (parent.__ref && parent.__ref.__children)
@@ -145,28 +147,28 @@ const addMethods = (element, parent) => {
   element.setProps = import_methods.setProps;
   element.lookup = import_methods.lookup;
   element.spotByPath = import_methods.spotByPath;
-  element.parse = import_methods.parse;
-  element.parseDeep = import_methods.parseDeep;
-  element.keys = import_methods.keys;
-  element.nextElement = import_methods.nextElement;
-  element.previousElement = import_methods.previousElement;
+  element.parse = import_methods2.parse;
+  element.parseDeep = import_methods2.parseDeep;
+  element.keys = import_methods2.keys;
+  element.nextElement = import_methods2.nextElement;
+  element.previousElement = import_methods2.previousElement;
   if (ENV === "test" || ENV === "development") {
-    element.log = import_methods.log;
+    element.log = import_methods2.log;
   }
 };
 const applyContext = (element, parent, options) => {
-  if (options.context && !import_root.default.context && !element.context)
-    import_root.default.context = options.context;
+  if (options.context && !import_tree.ROOT.context && !element.context)
+    import_tree.ROOT.context = options.context;
   if (!element.context)
-    element.context = parent.context || options.context || import_root.default.context;
+    element.context = parent.context || options.context || import_tree.ROOT.context;
 };
 const checkIf = (element, parent) => {
   const { __ref } = element;
   if ((0, import_utils.isFunction)(element.if)) {
     const ifPassed = element.if(element, element.state);
     if (!ifPassed) {
-      const ifFragment = (0, import_cache.default)({ tag: "fragment" });
-      __ref.__ifFragment = (0, import_assign.appendNode)(ifFragment, parent.node);
+      const ifFragment = (0, import_node.cacheNode)({ tag: "fragment" });
+      __ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
       delete __ref.__if;
     } else
       __ref.__if = true;
@@ -194,7 +196,7 @@ const addCaching = (element, parent) => {
     __ref.__children = [];
   const hasRoot = parent && parent.key === ":root";
   if (!__ref.__root)
-    __ref.__root = hasRoot ? element : parent.__ref.__root;
+    __ref.__root = hasRoot ? element : __parentRef.__root;
   if (ENV === "test" || ENV === "development") {
     if (!__parentRef)
       __parentRef = parent.__ref = {};
@@ -205,7 +207,7 @@ const addCaching = (element, parent) => {
 };
 const resolveExtends = (element, parent, options) => {
   const { __ref } = element;
-  element.tag = (0, import_cache.detectTag)(element);
+  element.tag = (0, import_node.detectTag)(element);
   if (!__ref.__exec)
     __ref.__exec = {};
   if (!__ref.__attr)

package/dist/cjs/element/index.js

@@ -24,32 +24,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var element_exports = {};
 __export(element_exports, {
-  assign: () => assign,
-  cache: () => import_cache.default,
+  TREE: () => import_tree.TREE,
   create: () => import_create.default,
   createNode: () => import_node.default,
   define: () => import_define.default,
-  get: () => import_methods.get,
+  get: () => import_methods2.get,
   keys: () => import_methods.keys,
   log: () => import_methods.log,
-  lookup: () => import_methods.lookup,
+  lookup: () => import_methods2.lookup,
   parse: () => import_parse.default,
-  remove: () => import_methods.remove,
-  root: () => import_root.default,
+  remove: () => import_methods2.remove,
   set: () => import_set.default,
-  setProps: () => import_methods.setProps,
-  tree: () => import_tree.default,
   update: () => import_update.default
 });
 module.exports = __toCommonJS(element_exports);
-var import_root = __toESM(require("./root"));
-var import_tree = __toESM(require("./tree"));
-var import_cache = __toESM(require("./cache"));
+var import_tree = require("@domql/tree");
 var import_create = __toESM(require("./create"));
 var import_node = __toESM(require("./node"));
-var assign = __toESM(require("./assign"));
 var import_define = __toESM(require("./define"));
 var import_update = __toESM(require("./update"));
 var import_parse = __toESM(require("./parse"));
 var import_set = __toESM(require("./set"));
 var import_methods = require("./methods");
+var import_methods2 = require("@domql/methods");

package/dist/cjs/element/iterate.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var iterate_exports = {};
 __export(iterate_exports, {
-  applyEvents: () => applyEvents,
   throughInitialDefine: () => throughInitialDefine,
   throughInitialExec: () => throughInitialExec,
   throughUpdatedDefine: () => throughUpdatedDefine,
@@ -27,18 +26,7 @@ __export(iterate_exports, {
 module.exports = __toCommonJS(iterate_exports);
 var import_utils = require("@domql/utils");
 var import_utils2 = require("../utils");
-var import_methods = require("./methods");
-const applyEvents = (element) => {
-  const { node, on } = element;
-  for (const param in on) {
-    if (param === "init" || param === "beforeClassAssign" || param === "render" || param === "renderRouter" || param === "attachNode" || param === "stateInit" || param === "stateCreated" || param === "initStateUpdated" || param === "stateUpdated" || param === "initUpdate" || param === "update")
-      continue;
-    const appliedFunction = element.on[param];
-    if ((0, import_utils.isFunction)(appliedFunction)) {
-      node.addEventListener(param, (event) => appliedFunction(event, element, element.state, element.context));
-    }
-  }
-};
+var import_methods = require("@domql/methods");
 const throughInitialExec = (element) => {
   const { __ref } = element;
   const { __exec } = __ref;
@@ -78,10 +66,14 @@ const throughInitialDefine = (element) => {
     let prop = element[param];
     if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
       __exec[param] = prop;
-      element[param] = prop = (0, import_utils.exec)(prop, element);
+      const execParam2 = prop = (0, import_utils.exec)(prop, element);
+      if (execParam2)
+        element[param] = execParam2;
     }
     __cached[param] = prop;
-    element[param] = obj[param](prop, element, element.state);
+    const execParam = obj[param](prop, element, element.state);
+    if (execParam)
+      element[param] = execParam;
   }
   return element;
 };
@@ -99,7 +91,9 @@ const throughUpdatedDefine = (element) => {
     if (execParam)
       __cached[param] = execParam(element, element.state);
     const cached = (0, import_utils.exec)(__cached[param], element);
-    element[param] = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state);
+    if (newExecParam)
+      element[param] = newExecParam;
   }
   return changes;
 };

package/dist/cjs/element/methods.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,88 +15,27 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var methods_exports = {};
 __export(methods_exports, {
   defineSetter: () => defineSetter,
-  get: () => get,
-  isMethod: () => isMethod,
   keys: () => keys,
   log: () => log,
-  lookup: () => lookup,
   nextElement: () => nextElement,
   parse: () => parse,
   parseDeep: () => parseDeep,
   previousElement: () => previousElement,
-  remove: () => remove,
   set: () => set,
-  setProps: () => setProps,
-  spotByPath: () => spotByPath,
   update: () => update
 });
 module.exports = __toCommonJS(methods_exports);
 var import_utils = require("@domql/utils");
 var import_mixins = require("./mixins");
-var import_root = __toESM(require("./root"));
-const ENV = "development";
-const lookup = function(key) {
-  const element = this;
-  let { parent } = element;
-  while (parent.key !== key) {
-    if (parent[key])
-      return parent[key];
-    parent = parent.parent;
-    if (!parent)
-      return;
-  }
-  return parent;
-};
-const spotByPath = function(path) {
-  const element = this;
-  const arr = [].concat(path);
-  let active = import_root.default[arr[0]];
-  if (!arr || !arr.length)
-    return console.log(arr, "on", element.key, "is undefined");
-  while (active.key === arr[0]) {
-    arr.shift();
-    if (!arr.length)
-      break;
-    active = active[arr[0]];
-    if (!active)
-      return;
-  }
-  return active;
-};
-const remove = function(params) {
-  const element = this;
-  if ((0, import_utils.isFunction)(element.node.remove))
-    element.node.remove();
-  else if (ENV === "test" || ENV === "development") {
-    console.warn("This item cant be removed");
-    element.log();
-  }
-  delete element.parent[element.key];
-};
-const get = function(param) {
-  const element = this;
-  return element[param];
-};
 const set = function() {
 };
 const update = function() {
 };
-const setProps = function(param, options) {
-  const element = this;
-  if (!param || !element.props)
-    return;
-  element.update({ props: param }, options);
-  return element;
-};
-const defineSetter = (element, key, get2, set2) => Object.defineProperty(element, key, { get: get2, set: set2 });
+const defineSetter = (element, key, get, set2) => Object.defineProperty(element, key, { get, set: set2 });
 const keys = function() {
   const element = this;
   const keys2 = [];
@@ -110,19 +47,35 @@ const keys = function() {
   }
   return keys2;
 };
-const parse = function() {
+const parse = function(excl = []) {
   const element = this;
   const obj = {};
   const keyList = keys.call(element);
-  keyList.forEach((v) => obj[v] = element[v]);
+  keyList.forEach((v) => {
+    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 == null ? void 0 : val.parse))
+        val = val.parse();
+    } else if (v === "props") {
+      const { __element, update: update2, ...props } = element[v];
+      obj[v] = props;
+    } else if ((0, import_utils.isDefined)(val))
+      obj[v] = val;
+  });
   return obj;
 };
-const parseDeep = function() {
+const parseDeep = function(excl = []) {
   const element = this;
-  const obj = parse.call(element);
-  for (const k in obj) {
-    if ((0, import_utils.isObjectLike)(obj[k])) {
-      obj[k] = parseDeep.call(obj[k]);
+  const obj = parse.call(element, excl);
+  for (const v in obj) {
+    if (excl.includes(v))
+      return;
+    if ((0, import_utils.isObjectLike)(obj[v])) {
+      obj[v] = parseDeep.call(obj[v], excl);
     }
   }
   return obj;
@@ -143,9 +96,6 @@ const log = function(...args) {
   console.groupEnd(element.key);
   return element;
 };
-const isMethod = function(param) {
-  return param === "set" || param === "update" || param === "remove" || param === "removeContent" || param === "lookup" || param === "spotByPath" || param === "keys" || param === "parse" || param === "setProps" || param === "parseDeep" || param === "if" || param === "log" || param === "nextElement" || param === "previousElement";
-};
 const nextElement = function() {
   const element = this;
   const { key, parent } = element;

package/dist/cjs/element/node.js

@@ -30,11 +30,11 @@ __export(node_exports, {
 module.exports = __toCommonJS(node_exports);
 var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
+var import_methods = require("@domql/methods");
+var import_node = require("@domql/node");
 var import_create = __toESM(require("./create"));
-var import_cache = __toESM(require("./cache"));
 var import_iterate = require("./iterate");
 var import_mixins = require("./mixins");
-var import_methods = require("./methods");
 var import_applyParam = require("./applyParam");
 const ENV = "development";
 const createNode = (element, options) => {
@@ -47,7 +47,7 @@ const createNode = (element, options) => {
     if (tag === "shadow") {
       node = element.node = element.parent.node.attachShadow({ mode: "open" });
     } else
-      node = element.node = (0, import_cache.default)(element);
+      node = element.node = (0, import_node.cacheNode)(element);
     (0, import_event.triggerEventOn)("attachNode", element);
   }
   if (ENV === "test" || ENV === "development" || options.alowRefReference) {
@@ -61,7 +61,7 @@ const createNode = (element, options) => {
     (0, import_iterate.throughInitialDefine)(element);
     (0, import_iterate.throughInitialExec)(element);
     if (isNewNode && (0, import_utils.isObject)(element.on))
-      (0, import_iterate.applyEvents)(element);
+      (0, import_event.applyEventsOnNode)(element);
     for (const param in element) {
       const prop = element[param];
       if ((0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || prop === void 0)

package/dist/cjs/element/parse.js

@@ -27,14 +27,14 @@ __export(parse_exports, {
   default: () => parse_default
 });
 module.exports = __toCommonJS(parse_exports);
+var import_render = require("@domql/render");
 var import_create = __toESM(require("./create"));
-var import_assign = require("./assign");
 const parse = (element) => {
   const virtualTree = {
     node: document.createElement("div")
   };
   if (element && element.node)
-    (0, import_assign.assignNode)(element, virtualTree);
+    (0, import_render.assignNode)(element, virtualTree);
   else
     (0, import_create.default)(element, virtualTree);
   return virtualTree.node.innerHTML;

package/dist/cjs/element/props.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var props_exports = {};
 __export(props_exports, {
+  IGNORE_PROPS_PARAMS: () => IGNORE_PROPS_PARAMS,
   default: () => props_default,
   syncProps: () => syncProps,
   updateProps: () => updateProps
@@ -25,6 +26,7 @@ __export(props_exports, {
 module.exports = __toCommonJS(props_exports);
 var import_utils = require("@domql/utils");
 var import_utils2 = require("../utils");
+const IGNORE_PROPS_PARAMS = ["update", "__element"];
 const objectizeStringProperty = (propValue) => {
   if ((0, import_utils.is)(propValue)("string", "number"))
     return { inheritedString: propValue };
@@ -75,7 +77,7 @@ const syncProps = (props, element) => {
   element.props = {};
   const mergedProps = { update, __element: element };
   props.forEach((v) => {
-    if (v === "update" || v === "__element")
+    if (IGNORE_PROPS_PARAMS.includes(v))
       return;
     const execProps = (0, import_utils.exec)(v, element);
     if ((0, import_utils.isObject)(execProps) && execProps.__element)