@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/esm/methods.js

@@ -0,0 +1,569 @@
+import { triggerEventOn } from "./triggerEvent.js";
+import { DOMQ_PROPERTIES, METHODS, PARSED_DOMQ_PROPERTIES } from "./keys.js";
+import { isDefined, isFunction, isObject, isObjectLike } from "./types.js";
+import { deepClone } from "./object.js";
+import { isProduction } from "./env.js";
+import { removeValueFromArray } from "./array.js";
+import { OPTIONS } from "./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 (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 (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 (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 (isObject(value) && childElem) setNodeStyles.call(childElem, value);
+    else el.node.style[param] = value;
+  }
+  return el;
+}
+function remove(opts) {
+  const element = this;
+  const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
+  if (beforeRemoveReturns === 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) 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 = 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) || DOMQ_PROPERTIES.has(param) && !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 = 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) continue;
+      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.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) => isObjectLike(item) ? parseDeep.call(item, excl, visited) : item
+      );
+    } else if (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, 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 || 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(METHODS.has(param) || element?.context?.methods?.[param]);
+}
+export {
+  call,
+  defineSetter,
+  error,
+  get,
+  getChildren,
+  getContext,
+  getDB,
+  getPath,
+  getQuery,
+  getRef,
+  getRoot,
+  getRootContext,
+  getRootData,
+  getRootState,
+  isMethod,
+  keys,
+  log,
+  lookdown,
+  lookdownAll,
+  lookup,
+  nextElement,
+  parse,
+  parseDeep,
+  previousElement,
+  remove,
+  setNodeStyles,
+  setProps,
+  spotByPath,
+  variables,
+  verbose,
+  warn
+};

package/dist/esm/node.js

@@ -0,0 +1,15 @@
+import { window } from "./globals.js";
+const isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+const isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+const isDOMNode = (obj) => {
+  return typeof window !== "undefined" && (window.Node && obj instanceof window.Node || window.Window && obj instanceof window.Window || obj === window || obj === document);
+};
+export {
+  isDOMNode,
+  isHtmlElement,
+  isNode
+};