domql 1.5.136 → 1.6.0

package/dist/cjs/element/methods.js

@@ -0,0 +1,166 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 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;
+};
+const parse = function() {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => obj[v] = element[v]);
+  return obj;
+};
+const parseDeep = function() {
+  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]);
+    }
+  }
+  return obj;
+};
+const log = function(...args) {
+  const element = this;
+  const { __ref } = element;
+  console.group(element.key);
+  if (args.length) {
+    args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  } else {
+    console.log(__ref.path);
+    const keys2 = element.keys();
+    keys2.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  }
+  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;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  console.log(nextChild);
+  return parent[nextChild];
+};
+const previousElement = function(el) {
+  const element = el || this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  if (!__children)
+    return;
+  const currentIndex = __children.indexOf(key);
+  return parent[__children[currentIndex - 1]];
+};

package/dist/cjs/element/node.js

@@ -0,0 +1,80 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 node_exports = {};
+__export(node_exports, {
+  createNode: () => createNode,
+  default: () => node_default
+});
+module.exports = __toCommonJS(node_exports);
+var import_utils = require("@domql/utils");
+var import_event = require("@domql/event");
+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) => {
+  let { node, tag, __ref } = 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_cache.default)(element);
+    (0, import_event.triggerEventOn)("attachNode", element);
+  }
+  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+    node.ref = element;
+    if ((0, import_utils.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!__ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    (0, import_iterate.throughInitialDefine)(element);
+    (0, import_iterate.throughInitialExec)(element);
+    if (isNewNode && (0, import_utils.isObject)(element.on))
+      (0, import_iterate.applyEvents)(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)
+        continue;
+      const isElement = (0, import_applyParam.applyParam)(param, element, options);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        if (element[param] && !hasDefine && !hasContextDefine) {
+          (0, import_create.default)((0, import_utils.exec)(prop, element), element, param, options);
+        }
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode;

package/dist/cjs/element/nodes.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nodes_exports = {};
+__export(nodes_exports, {
+  default: () => nodes_default
+});
+module.exports = __toCommonJS(nodes_exports);
+var nodes_default = {
+  root: [
+    "body",
+    "html"
+  ],
+  head: [
+    "title",
+    "base",
+    "meta",
+    "style"
+  ],
+  body: [
+    "html",
+    "body",
+    "string",
+    "fragment",
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "basefont",
+    "bdi",
+    "bdo",
+    "big",
+    "blockquote",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "meter",
+    "nav",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "pre",
+    "progress",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "small",
+    "source",
+    "span",
+    "strike",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "tr",
+    "track",
+    "tt",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
+    "svg",
+    "path"
+  ]
+};

package/dist/cjs/element/options.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var options_exports = {};
+__export(options_exports, {
+  default: () => options_default
+});
+module.exports = __toCommonJS(options_exports);
+var options_default = {};

package/dist/cjs/element/parse.js

@@ -0,0 +1,42 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 parse_exports = {};
+__export(parse_exports, {
+  default: () => parse_default
+});
+module.exports = __toCommonJS(parse_exports);
+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);
+  else
+    (0, import_create.default)(element, virtualTree);
+  return virtualTree.node.innerHTML;
+};
+var parse_default = parse;

package/dist/cjs/element/props.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var props_exports = {};
+__export(props_exports, {
+  default: () => props_default,
+  syncProps: () => syncProps,
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const objectizeStringProperty = (propValue) => {
+  if ((0, import_utils.is)(propValue)("string", "number"))
+    return { inheritedString: propValue };
+  return propValue;
+};
+const inheritParentProps = (element, parent) => {
+  let propsStack = [];
+  const parentProps = (0, import_utils.exec)(parent, parent.state).props;
+  const matchParent = parent.props && parentProps[element.key];
+  const matchParentIsString = (0, import_utils.isString)(matchParent);
+  const matchParentChildProps = parentProps && parentProps.childProps;
+  if (matchParent) {
+    if (matchParentIsString) {
+      const inheritedStringExists = propsStack.filter((v) => v.inheritedString)[0];
+      if (inheritedStringExists)
+        inheritedStringExists.inheritedString = matchParent;
+      else {
+        propsStack = [].concat(objectizeStringProperty(matchParent), propsStack);
+      }
+    } else {
+      propsStack.push(objectizeStringProperty(matchParent));
+    }
+  }
+  if (matchParentChildProps)
+    propsStack.push(matchParentChildProps);
+  return propsStack;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.__props = inheritParentProps(element, parent);
+  if ((0, import_utils.isObject)(props))
+    propsStack.push(props);
+  else if (props === "inherit" && parent.props)
+    propsStack.push(parent.props);
+  else if (props)
+    propsStack.push(props);
+  if ((0, import_utils.isArray)(__ref.__extend)) {
+    __ref.__extend.map((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+      return extend.props;
+    });
+  }
+  __ref.__props = propsStack;
+  return propsStack;
+};
+const syncProps = (props, element) => {
+  element.props = {};
+  const mergedProps = { update, __element: element };
+  props.forEach((v) => {
+    if (v === "update" || v === "__element")
+      return;
+    const execProps = (0, import_utils.exec)(v, element);
+    if ((0, import_utils.isObject)(execProps) && execProps.__element)
+      return;
+    element.props = (0, import_utils2.deepMerge)(mergedProps, (0, import_utils2.deepClone)(execProps));
+  });
+  element.props = mergedProps;
+  return element.props;
+};
+const createProps = function(element, parent, cached) {
+  const propsStack = cached || createPropsStack(element, parent);
+  const { __ref } = element;
+  if (propsStack.length) {
+    __ref.__props = propsStack;
+    syncProps(propsStack, element);
+    element.props.update = update;
+  }
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    syncProps(propsStack, element);
+  return element;
+};
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var props_default = createProps;

package/dist/cjs/element/remove.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remove_exports = {};
+__export(remove_exports, {
+  removeContentElement: () => removeContentElement
+});
+module.exports = __toCommonJS(remove_exports);
+var import_utils = require("@domql/utils");
+const removeContentElement = function(el) {
+  const element = el || this;
+  const { __ref } = element;
+  if (element.content) {
+    if (element.content.node) {
+      if (element.content.tag === "fragment")
+        element.node.innerHTML = "";
+      else
+        element.node.removeChild(element.content.node);
+    }
+    const { __cached } = __ref;
+    if (__cached && __cached.content) {
+      if (__cached.content.tag === "fragment")
+        __cached.content.parent.node.innerHTML = "";
+      else if (__cached.content && (0, import_utils.isFunction)(__cached.content.remove))
+        __cached.content.remove();
+    }
+    delete element.content;
+  }
+};

package/dist/cjs/element/root.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var root_exports = {};
+__export(root_exports, {
+  default: () => root_default
+});
+module.exports = __toCommonJS(root_exports);
+var import_globals = require("@domql/globals");
+var import_report = require("@domql/report");
+const root = {
+  key: ":root",
+  node: import_globals.document ? import_globals.document.body : (0, import_report.report)("DocumentNotDefined", import_globals.document)
+};
+var root_default = root;