@domql/element 2.5.185 → 2.5.187

package/dist/esm/methods/index.js

@@ -0,0 +1,333 @@
+import { triggerEventOn } from "@domql/event";
+import { isDefined, isObject, isFunction, isObjectLike, isProduction, removeValueFromArray, deepClone } from "@domql/utils";
+import { TREE } from "../tree.js";
+import { parseFilters, REGISTRY } from "../mixins/index.js";
+const ENV = "development";
+function spotByPath(path) {
+  const element = this;
+  const arr = [].concat(path);
+  let active = 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;
+}
+function lookup(param) {
+  const el = this;
+  let { parent } = el;
+  if (isFunction(param)) {
+    if (parent.state && param(parent, parent.state, parent.context))
+      return parent;
+    else if (parent.parent)
+      return parent.lookup(param);
+    else
+      return;
+  }
+  if (el[param])
+    return el[param];
+  while (parent.param !== param) {
+    if (parent[param])
+      return parent[param];
+    parent = parent.parent;
+    if (!parent)
+      return;
+  }
+  return parent;
+}
+function lookdown(param) {
+  var _a;
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref.__children;
+  for (let i = 0; i < children.length; i++) {
+    const v = children[i];
+    const childElem = el[v];
+    if (v === param)
+      return childElem;
+    else if (isFunction(param)) {
+      const exec = param(childElem, childElem.state, childElem.context);
+      if (childElem.state && exec) {
+        return childElem;
+      }
+    }
+    const lookdown2 = (_a = childElem == null ? void 0 : childElem.lookdown) == null ? void 0 : _a.call(childElem, param);
+    if (lookdown2)
+      return lookdown2;
+  }
+}
+function lookdownAll(param, results = []) {
+  var _a;
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref.__children;
+  for (let i = 0; i < children.length; i++) {
+    const v = children[i];
+    const childElem = el[v];
+    if (v === param)
+      results.push(childElem);
+    else if (isFunction(param)) {
+      const exec = param(childElem, childElem.state, childElem.context);
+      if (childElem.state && exec)
+        results.push(childElem);
+    }
+    (_a = childElem == null ? void 0 : childElem.lookdownAll) == null ? void 0 : _a.call(childElem, param, results);
+  }
+  return results.length ? results : void 0;
+}
+function setNodeStyles(params = {}) {
+  var _a;
+  const el = this;
+  if (!((_a = el.node) == null ? void 0 : _a.style))
+    return;
+  for (const param in params) {
+    const value = params[param];
+    const childElem = el[param];
+    if (isObject(value) && childElem)
+      setNodeStyles.call(childElem, value);
+    else
+      el.node.style[param] = value;
+  }
+  return el;
+}
+function remove(opts) {
+  const element = this;
+  const beforeUpdateReturns = triggerEventOn("beforeRemove", element, opts);
+  if (beforeUpdateReturns === false)
+    return element;
+  if (isFunction(element.node.remove))
+    element.node.remove();
+  else if (!isProduction()) {
+    console.warn("This item cant be removed");
+    element.log();
+  }
+  delete element.parent[element.key];
+  if (element.parent.__ref)
+    element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key);
+  triggerEventOn("remove", element, opts);
+}
+function get(param) {
+  const element = this;
+  return element[param];
+}
+function setProps(param, options) {
+  const element = this;
+  if (!param || !element.props)
+    return;
+  element.update({ props: param }, options);
+  return element;
+}
+function getRef() {
+  return this.__ref;
+}
+function getPath() {
+  return this.getRef().path;
+}
+const defineSetter = (element, key, get2, set) => Object.defineProperty(element, key, { get: get2, set });
+function keys() {
+  const element = this;
+  const keys2 = [];
+  for (const param in element) {
+    if (REGISTRY[param] && !parseFilters.elementKeys.includes(param) || !Object.hasOwnProperty.call(element, param)) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+}
+function parse(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => {
+    if (excl.includes(v))
+      return;
+    const val = element[v];
+    if (v === "state") {
+      if (element.__ref && !element.__ref.__hasRootState)
+        return;
+      const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
+      obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
+    } else if (v === "scope") {
+      if (element.__ref && !element.__ref.__hasRootScope)
+        return;
+      obj[v] = JSON.parse(JSON.stringify(val || {}));
+    } else if (v === "props") {
+      const { __element, update, ...props } = element[v];
+      obj[v] = props;
+    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v))
+      obj[v] = val;
+  });
+  return obj;
+}
+function parseDeep(excl = []) {
+  const element = this;
+  const obj = parse.call(element, excl);
+  for (const v in obj) {
+    if (excl.includes(v))
+      return;
+    if (isObjectLike(obj[v])) {
+      obj[v] = parseDeep.call(obj[v], excl);
+    }
+  }
+  return obj;
+}
+function verbose(...args) {
+  if (ENV !== "test" && ENV !== "development")
+    return;
+  const element = this;
+  const { __ref: ref } = element;
+  console.groupCollapsed(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.log(element);
+  console.groupEnd(element.key);
+  return element;
+}
+function log(...params) {
+  if (ENV === "test" || ENV === "development") {
+    console.log(...params);
+  }
+}
+function warn(...params) {
+  if (ENV === "test" || ENV === "development") {
+    console.warn(...params);
+  }
+}
+function error(...params) {
+  var _a, _b;
+  if (ENV === "test" || ENV === "development") {
+    if ((_a = params[params.length - 1]) == null ? void 0 : _a.debugger)
+      debugger;
+    if ((_b = params[params.length - 1]) == null ? void 0 : _b.verbose)
+      verbose.call(this);
+    throw new Error(...params);
+  }
+}
+function nextElement() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  return parent[nextChild];
+}
+function previousElement(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]];
+}
+function variables(obj = {}) {
+  const element = this;
+  if (!element.data)
+    element.data = {};
+  if (!element.data.varCaches)
+    element.data.varCaches = {};
+  const varCaches = element.data.varCaches;
+  const changes = {};
+  let changed;
+  for (const key in obj) {
+    if (obj[key] !== varCaches[key]) {
+      changed = true;
+      changes[key] = obj[key];
+    }
+  }
+  return {
+    changed: (cb) => {
+      if (!changed)
+        return;
+      const returns = cb(changes, deepClone(varCaches));
+      for (const key in changes) {
+        varCaches[key] = changes[key];
+      }
+      return returns;
+    },
+    timeout: (cb, timeout) => {
+      if (!changed)
+        return;
+      const t = setTimeout(() => {
+        cb(changes);
+        clearTimeout(t);
+      }, timeout);
+    }
+  };
+}
+function call(fnKey, ...args) {
+  var _a;
+  const context = this.context;
+  return (_a = context.utils[fnKey] || context.functions[fnKey] || context.methods[fnKey] || context.snippets[fnKey]) == null ? void 0 : _a.call(this, ...args);
+}
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "previousElement"
+];
+function isMethod(param, element) {
+  var _a, _b;
+  return METHODS.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]);
+}
+export {
+  METHODS,
+  call,
+  defineSetter,
+  error,
+  get,
+  getPath,
+  getRef,
+  isMethod,
+  keys,
+  log,
+  lookdown,
+  lookdownAll,
+  lookup,
+  nextElement,
+  parse,
+  parseDeep,
+  previousElement,
+  remove,
+  setNodeStyles,
+  setProps,
+  spotByPath,
+  variables,
+  verbose,
+  warn
+};

package/dist/esm/methods/set.js

@@ -0,0 +1,61 @@
+import { merge, overwrite } from "@domql/utils";
+import { set, reset } from "../set.js";
+import { update } from "../update.js";
+import { removeContent, updateContent } from "../mixins/content.js";
+import {
+  call,
+  error,
+  getPath,
+  getRef,
+  keys,
+  log,
+  lookdown,
+  lookdownAll,
+  lookup,
+  nextElement,
+  parse,
+  parseDeep,
+  previousElement,
+  remove,
+  setNodeStyles,
+  setProps,
+  spotByPath,
+  variables,
+  verbose,
+  warn
+} from "./index.js";
+const addMethods = (element, parent, options = {}) => {
+  const proto = {
+    set,
+    reset,
+    update,
+    variables,
+    remove,
+    updateContent,
+    removeContent,
+    setProps,
+    lookup,
+    lookdown,
+    lookdownAll,
+    getRef,
+    getPath,
+    setNodeStyles,
+    spotByPath,
+    parse,
+    parseDeep,
+    keys,
+    nextElement,
+    previousElement,
+    log,
+    verbose,
+    warn,
+    error,
+    call
+  };
+  if (element.context.methods)
+    (options.strict ? merge : overwrite)(proto, element.context.methods);
+  Object.setPrototypeOf(element, proto);
+};
+export {
+  addMethods
+};

package/dist/esm/methods/v2.js

@@ -0,0 +1,89 @@
+import { isDefined, isFunction, isObjectLike } from "@domql/utils";
+import { parseFilters, REGISTRY } from "../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 (REGISTRY[param] && !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 (isFunction(val && val.parse))
+        val = val.parse();
+    } else if (v === "props") {
+      const { __element, update, ...props } = element[v];
+      obj[v] = props;
+    } else if (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 (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]];
+};
+export {
+  defineSetter,
+  keys,
+  log,
+  nextElement,
+  parse,
+  parseDeep,
+  previousElement
+};

package/dist/esm/mixins/attr.js

@@ -0,0 +1,26 @@
+import { exec, isNot, isNull, isUndefined } from "@domql/utils";
+import { report } from "@domql/report";
+import { deepMerge } from "../utils/index.js";
+function attr(params, element, node) {
+  const { __ref: ref, props } = element;
+  const { __attr } = ref;
+  if (isNot("object"))
+    report("HTMLInvalidAttr", params);
+  if (params) {
+    if (props.attr)
+      deepMerge(params, props.attr);
+    for (const attr2 in params) {
+      const val = exec(params[attr2], element);
+      if (val !== false && !isUndefined(val) && !isNull(val) && node.setAttribute)
+        node.setAttribute(attr2, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr2);
+      __attr[attr2] = val;
+    }
+  }
+}
+var attr_default = attr;
+export {
+  attr,
+  attr_default as default
+};

package/dist/esm/mixins/classList.js

@@ -0,0 +1,55 @@
+import { exec, isObject, isString } from "@domql/utils";
+const assignKeyAsClassname = (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 += ` ${exec(param, element)}`;
+    }
+  }
+  return className;
+};
+const classList = (params, element) => {
+  if (!params)
+    return;
+  const { key } = element;
+  if (params === true)
+    params = element.class = { key };
+  if (isString(params))
+    params = element.class = { default: params };
+  if (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;
+};
+function applyClasslist(params, element, node) {
+  applyClassListOnNode(params, element, node);
+}
+var classList_default = applyClasslist;
+export {
+  applyClassListOnNode,
+  applyClasslist,
+  assignKeyAsClassname,
+  classList,
+  classify,
+  classList_default as default
+};

package/dist/esm/mixins/content.js

@@ -0,0 +1,54 @@
+import { isFunction, setContentKey } from "@domql/utils";
+import { set } from "../set.js";
+const updateContent = function(params, options) {
+  const element = this;
+  const ref = element.__ref;
+  const contentKey = ref.contentElementKey;
+  if (!element[contentKey])
+    return;
+  if (element[contentKey].update)
+    element[contentKey].update(params, options);
+};
+const removeContent = function(el, opts = {}) {
+  const element = el || this;
+  const { __ref: ref } = element;
+  const contentElementKey = setContentKey(element, opts);
+  if (opts.contentElementKey !== "content")
+    opts.contentElementKey = "content";
+  if (element[contentElementKey]) {
+    if (element[contentElementKey].node && element.node) {
+      if (element[contentElementKey].tag === "fragment")
+        element.node.innerHTML = "";
+      else {
+        const contentNode = element[contentElementKey].node;
+        if (contentNode.parentNode === element.node)
+          element.node.removeChild(element[contentElementKey].node);
+      }
+    }
+    const { __cached } = ref;
+    if (__cached && __cached[contentElementKey]) {
+      if (__cached[contentElementKey].tag === "fragment")
+        __cached[contentElementKey].parent.node.innerHTML = "";
+      else if (__cached[contentElementKey] && isFunction(__cached[contentElementKey].remove))
+        __cached[contentElementKey].remove();
+    }
+    delete element[contentElementKey];
+  }
+};
+function setContent(param, element, node, opts) {
+  const contentElementKey = setContentKey(element, opts);
+  if (param && element) {
+    if (element[contentElementKey].update) {
+      element[contentElementKey].update({}, opts);
+    } else {
+      set.call(element, param, opts);
+    }
+  }
+}
+var content_default = setContent;
+export {
+  content_default as default,
+  removeContent,
+  setContent,
+  updateContent
+};

package/dist/esm/mixins/data.js

@@ -0,0 +1,22 @@
+import { exec, isObject, deepMerge } from "@domql/utils";
+import { report } from "@domql/report";
+function data(params, element, node) {
+  if (params) {
+    if (element.props.data)
+      deepMerge(params, element.props.data);
+    if (params.showOnNode) {
+      if (!isObject(params))
+        report("HTMLInvalidData", params);
+      for (const dataset in params) {
+        if (dataset !== "showOnNode") {
+          node.dataset[dataset] = exec(params[dataset], element);
+        }
+      }
+    }
+  }
+}
+var data_default = data;
+export {
+  data,
+  data_default as default
+};

package/dist/esm/mixins/html.js

@@ -0,0 +1,18 @@
+import { exec } from "@domql/utils";
+function html(param, element, node) {
+  var _a;
+  const prop = exec(param, element) || 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;
+    __ref.__html = prop;
+  }
+}
+var html_default = html;
+export {
+  html_default as default,
+  html
+};

package/dist/esm/mixins/index.js

@@ -0,0 +1,23 @@
+import { attr } from "./attr.js";
+import { applyClasslist } from "./classList.js";
+import { setContent } from "./content.js";
+import { data } from "./data.js";
+import { html } from "./html.js";
+import { style } from "./style.js";
+import { text } from "./text.js";
+import { state } from "./state.js";
+import { scope } from "./scope.js";
+import { REGISTRY } from "./registry.js";
+export * from "./registry.js";
+export {
+  attr,
+  applyClasslist as classList,
+  setContent as content,
+  data,
+  html,
+  REGISTRY as registry,
+  scope,
+  state,
+  style,
+  text
+};