@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/methods.js

@@ -0,0 +1,599 @@
+"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 methods_exports = {};
+__export(methods_exports, {
+  call: () => call,
+  defineSetter: () => defineSetter,
+  error: () => error,
+  get: () => get,
+  getChildren: () => getChildren,
+  getContext: () => getContext,
+  getDB: () => getDB,
+  getPath: () => getPath,
+  getQuery: () => getQuery,
+  getRef: () => getRef,
+  getRoot: () => getRoot,
+  getRootContext: () => getRootContext,
+  getRootData: () => getRootData,
+  getRootState: () => getRootState,
+  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_triggerEvent = require("./triggerEvent.js");
+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");
+var import_cache = require("./cache.js");
+const ENV = process.env.NODE_ENV;
+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) {
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref?.__children;
+  if (!children) return;
+  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 = childElem?.lookdown?.(param);
+    if (lookdown2) return lookdown2;
+  }
+}
+function lookdownAll(param, results = []) {
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref?.__children;
+  if (!children) return;
+  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);
+    }
+    childElem?.lookdownAll?.(param, results);
+  }
+  return results.length ? results : void 0;
+}
+function setNodeStyles(params = {}) {
+  const el = this;
+  if (!el.node?.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_triggerEvent.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_triggerEvent.triggerEventOn)("remove", element, opts);
+}
+function get(param) {
+  const element = this;
+  return element[param];
+}
+function setProps(param, options) {
+  const element = this;
+  if (!param) return;
+  element.update(param, options);
+  return element;
+}
+function getRef(key) {
+  if (key) return this.__ref && this.__ref[key];
+  return this.__ref;
+}
+function getChildren() {
+  const __children = this.getRef("__children");
+  return __children.map((k) => this[k]);
+}
+function getPath() {
+  return this.getRef().path;
+}
+function getRootState(param) {
+  let state = null;
+  const hasRootState = (obj) => obj.__element && obj.root?.isRootState;
+  if (!this) {
+    state = window.platformState || window.smblsApp?.state;
+  } else if (hasRootState(this)) {
+    state = this.root;
+  } else if (this.__ref && this.__ref.path) {
+    const hasPlatformState = this.state && hasRootState(this.state);
+    const hasPlatformStateOnParent = (0, import_types.isFunction)(this.state) && this.parent.state && hasRootState(this.parent.state);
+    if (hasPlatformState || hasPlatformStateOnParent) {
+      state = this.state.root || this.parent.state.root;
+    }
+  }
+  if (!state) {
+    state = window.platformState || window.smblsApp?.state;
+  }
+  return param ? state?.[param] : state;
+}
+function getRoot(key) {
+  const rootElem = this.getRootState()?.__element;
+  return rootElem && Object.keys(rootElem).length > 0 && key ? rootElem[key] : rootElem;
+}
+function getRootData(key) {
+  return this.getRoot("data") && Object.keys(this.getRoot("data")).length > 0 && key ? this.getRoot("data")[key] : this.getRoot("data");
+}
+function getRootContext(key) {
+  const ctx = this.getRoot()?.context;
+  return key ? ctx[key] : ctx;
+}
+function getContext(key) {
+  const ctx = this.context;
+  return key ? ctx[key] : ctx;
+}
+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.has(param)) ||
+      !Object.prototype.hasOwnProperty.call(element, param) || import_keys.DOMQ_PROPERTIES.has(param) && !import_keys.PARSED_DOMQ_PROPERTIES.has(param)
+    ) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+}
+function parse(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  const hasChildren = keyList.includes("children");
+  const exclSet = excl.length ? new Set(excl) : null;
+  for (let i = 0; i < keyList.length; i++) {
+    const v = keyList[i];
+    if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+    if (hasChildren && v === "content") continue;
+    const val = element[v];
+    if (v === "state") {
+      if (element.__ref && !element.__ref.__hasRootState) continue;
+      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 (element.__ref && !element.__ref.__hasRootScope) continue;
+      obj[v] = JSON.parse(JSON.stringify(val || {}));
+    } else if (v === "props") {
+      const { __element, update, ...props } = element[v];
+      obj[v] = props;
+    } else if ((0, import_types.isDefined)(val) && Object.prototype.hasOwnProperty.call(element, v)) {
+      obj[v] = val;
+    }
+  }
+  return obj;
+}
+function parseDeep(excl = [], visited = /* @__PURE__ */ new WeakSet()) {
+  const element = this;
+  if (visited.has(element)) return void 0;
+  visited.add(element);
+  const obj = parse.call(element, excl);
+  const exclSet = excl.length ? new Set(excl) : null;
+  for (const v in obj) {
+    if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+    const val = obj[v];
+    if (Array.isArray(val)) {
+      obj[v] = val.map(
+        (item) => (0, import_types.isObjectLike)(item) ? parseDeep.call(item, excl, visited) : item
+      );
+    } else if ((0, import_types.isObjectLike)(val)) {
+      obj[v] = parseDeep.call(val, excl, visited);
+    }
+  }
+  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) {
+  if (ENV === "test" || ENV === "development") {
+    if (params[params.length - 1]?.debugger) debugger;
+    if (params[params.length - 1]?.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) {
+  const context = this.context;
+  const fn = context.utils?.[fnKey] || context.functions?.[fnKey] || context.methods?.[fnKey] || context.snippets?.[fnKey];
+  if (!fn) return;
+  try {
+    const result = fn.call(this, ...args);
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        error.call(this, err);
+      });
+    }
+    return result;
+  } catch (err) {
+    error.call(this, err);
+    if (context?.strictMode) throw err;
+  }
+}
+async function getDB() {
+  const element = this;
+  const db = element.context?.fetch;
+  if (!db) return null;
+  if (typeof db.select === "function") {
+    if (!db.__authInitialized && db.getSession) {
+      const { initAdapterAuth } = await import("@symbo.ls/fetch");
+      await initAdapterAuth(db, element.context);
+    }
+    return db;
+  }
+  if (db.__resolved) {
+    if (!db.__resolved.__authInitialized && db.__resolved.getSession) {
+      const { initAdapterAuth } = await import("@symbo.ls/fetch");
+      await initAdapterAuth(db.__resolved, element.context);
+    }
+    return db.__resolved;
+  }
+  if (db.__resolving) return db.__resolving;
+  const resolvePromise = import("@symbo.ls/fetch").then(({ resolveDb }) => resolveDb(db));
+  db.__resolving = resolvePromise;
+  const resolved = await resolvePromise;
+  db.__resolved = resolved;
+  element.context.fetch = resolved;
+  delete db.__resolving;
+  if (resolved.getSession) {
+    const { initAdapterAuth } = await import("@symbo.ls/fetch");
+    await initAdapterAuth(resolved, element.context);
+  }
+  return resolved;
+}
+function getQuery(format) {
+  const element = this;
+  const useStateQuery = format || import_cache.OPTIONS.useStateQuery || element.context?.useStateQuery;
+  if (!useStateQuery) return null;
+  const query = {};
+  buildQueryFromElement(element, query);
+  if (useStateQuery === true) return query;
+  const formatter = QUERY_FORMATTERS[useStateQuery];
+  return formatter ? formatter(query) : query;
+}
+const buildQueryFromElement = (element, query) => {
+  const ref = element.__ref;
+  if (!ref) return;
+  const stateKey = ref.__state;
+  if (stateKey && typeof stateKey === "string") {
+    setQueryPath(query, stateKey);
+  }
+  const children = ref.__children;
+  if (children) {
+    for (let i = 0; i < children.length; i++) {
+      const child = element[children[i]];
+      if (child && child.__ref) {
+        buildQueryFromElement(child, query);
+      }
+    }
+  }
+  const contentKey = ref.contentElementKey || "content";
+  const content = element[contentKey];
+  if (content && content.__ref) {
+    buildQueryFromElement(content, query);
+  }
+};
+const setQueryPath = (query, path) => {
+  const clean = path.replaceAll("../", "").replaceAll("~/", "");
+  const parts = clean.split("/");
+  let current = query;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i === parts.length - 1) {
+      if (!current[part]) current[part] = true;
+    } else {
+      if (current[part] === true) current[part] = {};
+      if (!current[part]) current[part] = {};
+      current = current[part];
+    }
+  }
+};
+const queryToGraphQL = (query, indent = 0) => {
+  const pad = "  ".repeat(indent);
+  const entries = Object.entries(query);
+  if (!entries.length) return "";
+  const fields = entries.map(([key, value]) => {
+    if (value === true) return `${pad}${key}`;
+    return `${pad}${key} {
+${queryToGraphQL(value, indent + 1)}
+${pad}}`;
+  });
+  return fields.join("\n");
+};
+const formatGraphQL = (query) => {
+  return `{
+${queryToGraphQL(query, 1)}
+}`;
+};
+const formatJsonApi = (query) => {
+  const result = { fields: {}, include: [] };
+  const walk = (obj, prefix) => {
+    const fields = [];
+    for (const key in obj) {
+      if (obj[key] === true) {
+        fields.push(key);
+      } else {
+        const nested = prefix ? `${prefix}.${key}` : key;
+        result.include.push(nested);
+        walk(obj[key], nested);
+      }
+    }
+    if (fields.length) {
+      result.fields[prefix || "_root"] = fields;
+    }
+  };
+  walk(query, "");
+  return result;
+};
+const formatOData = (query) => {
+  const build = (obj) => {
+    const select2 = [];
+    const expand2 = [];
+    for (const key in obj) {
+      if (obj[key] === true) {
+        select2.push(key);
+      } else {
+        const nested = build(obj[key]);
+        const parts2 = [];
+        if (nested.select) parts2.push(`$select=${nested.select}`);
+        if (nested.expand) parts2.push(`$expand=${nested.expand}`);
+        expand2.push(parts2.length ? `${key}(${parts2.join(";")})` : key);
+      }
+    }
+    return {
+      select: select2.length ? select2.join(",") : "",
+      expand: expand2.length ? expand2.join(",") : ""
+    };
+  };
+  const { select, expand } = build(query);
+  const parts = [];
+  if (select) parts.push(`$select=${select}`);
+  if (expand) parts.push(`$expand=${expand}`);
+  return parts.join("&");
+};
+const formatSQL = (query, options) => {
+  const columns = [];
+  const joins = [];
+  const tables = /* @__PURE__ */ new Set();
+  const walk = (obj, table, parentTable) => {
+    tables.add(table);
+    if (parentTable) {
+      joins.push(
+        `LEFT JOIN ${table} ON ${table}.${parentTable}_id = ${parentTable}.id`
+      );
+    }
+    for (const key in obj) {
+      if (obj[key] === true) {
+        columns.push(`${table}.${key}`);
+      } else {
+        walk(obj[key], key, table);
+      }
+    }
+  };
+  const roots = Object.keys(query);
+  if (roots.length === 1 && query[roots[0]] !== true) {
+    walk(query[roots[0]], roots[0], null);
+  } else {
+    walk(query, "_root", null);
+  }
+  const from = [...tables][0] || "_root";
+  const select = columns.length ? columns.join(", ") : "*";
+  const joinStr = joins.length ? "\n" + joins.join("\n") : "";
+  return `SELECT ${select}
+FROM ${from}${joinStr}`;
+};
+const formatPaths = (query) => {
+  const paths = [];
+  const walk = (obj, prefix) => {
+    for (const key in obj) {
+      const path = prefix ? `${prefix}/${key}` : key;
+      if (obj[key] === true) {
+        paths.push(path);
+      } else {
+        walk(obj[key], path);
+      }
+    }
+  };
+  walk(query, "");
+  return paths;
+};
+const formatSupabase = (query) => {
+  const build = (obj) => {
+    const parts = [];
+    for (const key in obj) {
+      if (obj[key] === true) {
+        parts.push(key);
+      } else {
+        parts.push(`${key}(${build(obj[key])})`);
+      }
+    }
+    return parts.join(", ");
+  };
+  const roots = Object.keys(query);
+  if (roots.length === 1 && query[roots[0]] !== true) {
+    return { from: roots[0], select: build(query[roots[0]]) };
+  }
+  return { from: null, select: build(query) };
+};
+const QUERY_FORMATTERS = {
+  graphql: formatGraphQL,
+  "json-api": formatJsonApi,
+  odata: formatOData,
+  sql: formatSQL,
+  supabase: formatSupabase,
+  paths: formatPaths
+};
+function isMethod(param, element) {
+  return Boolean(import_keys.METHODS.has(param) || element?.context?.methods?.[param]);
+}

package/dist/cjs/node.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 node_exports = {};
+__export(node_exports, {
+  isDOMNode: () => isDOMNode,
+  isHtmlElement: () => isHtmlElement,
+  isNode: () => isNode
+});
+module.exports = __toCommonJS(node_exports);
+var import_globals = require("./globals.js");
+const isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof import_globals.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+const isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof import_globals.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+const isDOMNode = (obj) => {
+  return typeof import_globals.window !== "undefined" && (import_globals.window.Node && obj instanceof import_globals.window.Node || import_globals.window.Window && obj instanceof import_globals.window.Window || obj === import_globals.window || obj === document);
+};