@domql/element 2.4.1 → 2.4.3

package/dist/cjs/cache/index.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 cache_exports = {};
+__export(cache_exports, {
+  cache: () => cache
+});
+module.exports = __toCommonJS(cache_exports);
+const cache = {};

package/dist/cjs/cache/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/methods/index.js

@@ -0,0 +1,186 @@
+"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 methods_exports = {};
+__export(methods_exports, {
+  METHODS: () => METHODS,
+  defineSetter: () => defineSetter,
+  get: () => get,
+  isMethod: () => isMethod,
+  keys: () => keys,
+  log: () => log,
+  lookup: () => lookup,
+  nextElement: () => nextElement,
+  parse: () => parse,
+  parseDeep: () => parseDeep,
+  previousElement: () => previousElement,
+  remove: () => remove,
+  setProps: () => setProps,
+  spotByPath: () => spotByPath
+});
+module.exports = __toCommonJS(methods_exports);
+var import_utils = require("@domql/utils");
+var import_tree = require("../tree");
+var import_mixins = require("../mixins");
+const spotByPath = function(path) {
+  const element = this;
+  const arr = [].concat(path);
+  let active = import_tree.TREE[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 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 remove = function(params) {
+  const element = this;
+  if ((0, import_utils.isFunction)(element.node.remove))
+    element.node.remove();
+  else if (!(0, import_utils.isProduction)()) {
+    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 setProps = function(param, options) {
+  const element = this;
+  if (!param || !element.props)
+    return;
+  element.update({ props: param }, options);
+  return element;
+};
+const defineSetter = (element, key, get2, set) => Object.defineProperty(element, key, { get: get2, 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;
+};
+const parse = function(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  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 && 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;
+  });
+  return obj;
+};
+const parseDeep = function(excl = []) {
+  const element = this;
+  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;
+};
+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 nextElement = function() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  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]];
+};
+const METHODS = [
+  "set",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "if",
+  "log",
+  "nextElement",
+  "previousElement"
+];
+const isMethod = function(param) {
+  return METHODS.includes(param);
+};

package/dist/cjs/methods/set.js

@@ -0,0 +1,58 @@
+"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(
+  // 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 set_exports = {};
+__export(set_exports, {
+  addMethods: () => addMethods
+});
+module.exports = __toCommonJS(set_exports);
+var import_utils = require("@domql/utils");
+var import_set = __toESM(require("../set"), 1);
+var import_update = __toESM(require("../update"), 1);
+var import__ = require("./");
+var import_content = require("../mixins/content");
+const addMethods = (element, parent) => {
+  const proto = {
+    set: import_set.default.bind(element),
+    update: import_update.default.bind(element),
+    remove: import__.remove.bind(element),
+    updateContent: import_content.updateContent.bind(element),
+    removeContent: import_content.removeContent.bind(element),
+    setProps: import__.setProps.bind(element),
+    lookup: import__.lookup.bind(element),
+    spotByPath: import__.spotByPath.bind(element),
+    parse: import__.parse.bind(element),
+    parseDeep: import__.parseDeep.bind(element),
+    keys: import__.keys.bind(element),
+    nextElement: import__.nextElement.bind(element),
+    previousElement: import__.previousElement.bind(element)
+  };
+  if ((0, import_utils.isDevelopment)())
+    proto.log = import__.log.bind(element);
+  Object.setPrototypeOf(element, proto);
+};

package/dist/cjs/methods/v2.js

@@ -0,0 +1,109 @@
+"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 v2_exports = {};
+__export(v2_exports, {
+  defineSetter: () => defineSetter,
+  keys: () => keys,
+  log: () => log,
+  nextElement: () => nextElement,
+  parse: () => parse,
+  parseDeep: () => parseDeep,
+  previousElement: () => previousElement
+});
+module.exports = __toCommonJS(v2_exports);
+var import_utils = require("@domql/utils");
+var import_mixins = require("../mixins");
+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;
+};
+const parse = function(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  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 && 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;
+  });
+  return obj;
+};
+const parseDeep = function(excl = []) {
+  const element = this;
+  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;
+};
+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 nextElement = function() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  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/mixins/attr.js

@@ -0,0 +1,42 @@
+"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 attr_exports = {};
+__export(attr_exports, {
+  default: () => attr_default
+});
+module.exports = __toCommonJS(attr_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var attr_default = (params, element, node) => {
+  const { __ref } = element;
+  const { __attr } = __ref;
+  if ((0, import_utils.isNot)("object"))
+    (0, import_report.report)("HTMLInvalidAttr", params);
+  if (params) {
+    for (const attr in params) {
+      const val = (0, import_utils.exec)(params[attr], element);
+      if (val && node.setAttribute)
+        node.setAttribute(attr, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr);
+      __attr[attr] = val;
+    }
+  }
+  console.groupEnd(params, __attr);
+};

package/dist/cjs/mixins/classList.js

@@ -0,0 +1,73 @@
+"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 classList_exports = {};
+__export(classList_exports, {
+  applyClassListOnNode: () => applyClassListOnNode,
+  assignClass: () => assignClass,
+  classList: () => classList,
+  classify: () => classify,
+  default: () => classList_default
+});
+module.exports = __toCommonJS(classList_exports);
+var import_utils = require("@domql/utils");
+const assignClass = (element) => {
+  const { key } = element;
+  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);
+  }
+};
+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}`;
+    else if (typeof param === "function") {
+      className += ` ${(0, import_utils.exec)(param, element)}`;
+    }
+  }
+  return className;
+};
+const classList = (params, element) => {
+  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);
+  const className = params.replace(/\s+/g, " ").trim();
+  if (element.ref)
+    element.ref.class = className;
+  return className;
+};
+const applyClassListOnNode = (params, element, node) => {
+  const className = classList(params, element);
+  node.classList = className;
+  return className;
+};
+var classList_default = (params, element, node) => {
+  applyClassListOnNode(params, element, node);
+};

package/dist/cjs/mixins/content.js

@@ -0,0 +1,75 @@
+"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(
+  // 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 content_exports = {};
+__export(content_exports, {
+  default: () => content_default,
+  removeContent: () => removeContent,
+  setContent: () => setContent,
+  updateContent: () => updateContent
+});
+module.exports = __toCommonJS(content_exports);
+var import_utils = require("@domql/utils");
+var import_set = __toESM(require("../set"), 1);
+const updateContent = function(params, options) {
+  const element = this;
+  if (!element.content)
+    return;
+  if (element.content.update)
+    element.content.update(params, options);
+};
+const removeContent = 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;
+  }
+};
+const setContent = (param, element, node, options) => {
+  if (param && element) {
+    if (element.content.update) {
+      element.content.update({}, options);
+    } else {
+      import_set.default.call(element, param, options);
+    }
+  }
+};
+var content_default = setContent;

package/dist/cjs/mixins/data.js

@@ -0,0 +1,36 @@
+"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 data_exports = {};
+__export(data_exports, {
+  default: () => data_default
+});
+module.exports = __toCommonJS(data_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var data_default = (params, element, node) => {
+  if (params && params.showOnNode) {
+    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

@@ -0,0 +1,35 @@
+"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 html_exports = {};
+__export(html_exports, {
+  default: () => html_default
+});
+module.exports = __toCommonJS(html_exports);
+var import_utils = require("@domql/utils");
+var html_default = (param, element, node) => {
+  const prop = (0, import_utils.exec)(param, element);
+  const { __ref } = element;
+  if (prop !== __ref.__html) {
+    if (node.nodeName === "SVG")
+      node.textContent = prop;
+    else
+      node.innerHTML = prop;
+    __ref.__html = prop;
+  }
+};