@domql/utils 2.5.187 → 3.0.0

package/dist/cjs/methods.js

@@ -0,0 +1,305 @@
+"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, {
+  call: () => call,
+  defineSetter: () => defineSetter,
+  error: () => error,
+  get: () => get,
+  getPath: () => getPath,
+  getRef: () => getRef,
+  isMethod: () => isMethod,
+  keys: () => keys,
+  log: () => log,
+  lookdown: () => lookdown,
+  lookdownAll: () => lookdownAll,
+  lookup: () => lookup,
+  nextElement: () => nextElement,
+  parse: () => parse,
+  parseDeep: () => parseDeep,
+  previousElement: () => previousElement,
+  remove: () => remove,
+  setNodeStyles: () => setNodeStyles,
+  setProps: () => setProps,
+  spotByPath: () => spotByPath,
+  variables: () => variables,
+  verbose: () => verbose,
+  warn: () => warn
+});
+module.exports = __toCommonJS(methods_exports);
+var import_event = require("@domql/event");
+var import_keys = require("./keys.js");
+var import_types = require("./types.js");
+var import_object = require("./object.js");
+var import_env = require("./env.js");
+var import_array = require("./array.js");
+const ENV = "development";
+function spotByPath(path) {
+  const element = this;
+  const { __ref: ref } = element;
+  const arr = [].concat(path);
+  let foundelement = ref.root[arr[0]];
+  if (!arr || !arr.length) {
+    return console.log(arr, "on", element.key, "is undefined");
+  }
+  while (foundelement.key === arr[0]) {
+    arr.shift();
+    if (!arr.length) break;
+    foundelement = foundelement[arr[0]];
+    if (!foundelement) return;
+  }
+  return foundelement;
+}
+function lookup(param) {
+  const el = this;
+  let { parent } = el;
+  if ((0, import_types.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 ((0, import_types.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 ((0, import_types.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 ((0, import_types.isObject)(value) && childElem) setNodeStyles.call(childElem, value);
+    else el.node.style[param] = value;
+  }
+  return el;
+}
+function remove(opts) {
+  const element = this;
+  const beforeRemoveReturns = (0, import_event.triggerEventOn)("beforeRemove", element, opts);
+  if (beforeRemoveReturns === false) return element;
+  if ((0, import_types.isFunction)(element.node.remove)) element.node.remove();
+  else if (!(0, import_env.isProduction)()) {
+    console.warn("This item cant be removed");
+    element.log();
+  }
+  delete element.parent[element.key];
+  if (element.parent.__ref) {
+    element.parent.__ref.__children = (0, import_array.removeValueFromArray)(
+      element.parent.__ref.__children,
+      element.key
+    );
+  }
+  (0, import_event.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] && !DOMQ_PROPERTIES.includes(param)) ||
+      !Object.hasOwnProperty.call(element, param) || import_keys.DOMQ_PROPERTIES.includes(param) && !import_keys.PARSED_DOMQ_PROPERTIES.includes(param)
+    ) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+}
+function parse(excl = []) {
+  const element = this;
+  const { __ref: ref } = element;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => {
+    if (excl.includes(v)) return;
+    const val = element[v];
+    if (v === "state") {
+      if (!(ref == null ? void 0 : ref.__hasRootState)) return;
+      const parsedVal = (0, import_types.isFunction)(val && val.parse) ? val.parse() : val;
+      obj[v] = (0, import_types.isFunction)(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
+    } else if (v === "scope") {
+      if (!(ref == null ? void 0 : ref.__hasRootScope)) return;
+      obj[v] = JSON.parse(JSON.stringify(val || {}));
+    } else if ((0, import_types.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 ((0, import_types.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, (0, import_object.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, _b, _c, _d, _e;
+  const context = this.context;
+  return (_e = ((_a = context.utils) == null ? void 0 : _a[fnKey]) || ((_b = context.functions) == null ? void 0 : _b[fnKey]) || ((_c = context.methods) == null ? void 0 : _c[fnKey]) || ((_d = context.snippets) == null ? void 0 : _d[fnKey])) == null ? void 0 : _e.call(this, ...args);
+}
+function isMethod(param, element) {
+  var _a, _b;
+  return Boolean(import_keys.METHODS.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]));
+}