@domql/utils 2.5.187 → 3.0.0

package/dist/esm/component.js

@@ -1,255 +1,27 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { joinArrays } from "./array.js";
-import { deepClone, exec } from "./object.js";
-import { isArray, isFunction, isObject, isString } from "./types.js";
-const ENV = "development";
-const checkIfKeyIsComponent = (key) => {
+import { createExtendsFromKeys } from "./extends.js";
+import { isString } from "./types.js";
+const matchesComponentNaming = (key) => {
   const isFirstKeyString = isString(key);
-  if (!isFirstKeyString)
-    return;
+  if (!isFirstKeyString) return;
   const firstCharKey = key.slice(0, 1);
   return /^[A-Z]*$/.test(firstCharKey);
 };
-const checkIfKeyIsProperty = (key) => {
-  const isFirstKeyString = isString(key);
-  if (!isFirstKeyString)
-    return;
-  const firstCharKey = key.slice(0, 1);
-  return /^[a-z]*$/.test(firstCharKey);
-};
-const addAdditionalExtend = (newExtend, element) => {
-  if (!newExtend)
-    return element;
-  const { extend: elementExtend } = element;
-  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
-  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
-  const extend = joinArrays(receivedArray, originalArray);
-  return __spreadProps(__spreadValues({}, element), { extend });
-};
-const checkIfSugar = (element, parent, key) => {
-  var _a;
-  const {
-    extend,
-    props,
-    childExtend,
-    extends: extendProps,
-    childExtends,
-    childProps,
-    children,
-    on,
-    $collection,
-    $stateCollection,
-    $propsCollection
-  } = element;
-  const hasComponentAttrs = extend || childExtend || props || on || $collection || $stateCollection || $propsCollection;
-  if (hasComponentAttrs && (childProps || extendProps || children || childExtends)) {
-    const logErr = (_a = parent || element) == null ? void 0 : _a.error;
-    if (logErr)
-      logErr.call(element, "Sugar component includes params for builtin components", { verbose: true });
-  }
-  return !hasComponentAttrs || childProps || extendProps || children || childExtends;
-};
-const extractComponentKeyFromKey = (key) => {
-  return key.includes("+") ? key.split("+") : key.includes("_") ? [key.split("_")[0]] : key.includes(".") && !checkIfKeyIsComponent(key.split(".")[1]) ? [key.split(".")[0]] : [key];
-};
-const extendizeByKey = (element, parent, key) => {
-  const { context } = parent;
-  const { tag, extend, childExtends } = element;
-  const isSugar = checkIfSugar(element, parent, key);
-  const extendFromKey = extractComponentKeyFromKey(key);
-  const isExtendKeyComponent = context && context.components[extendFromKey];
-  if (element === isExtendKeyComponent)
-    return element;
-  else if (isSugar) {
-    const newElem = addAdditionalExtend(element.extends, {
-      extend: extendFromKey,
-      tag,
-      props: __spreadValues({}, element)
-    });
-    if (newElem.props.data) {
-      newElem.data = newElem.props.data;
-      delete newElem.props.data;
-    }
-    if (newElem.props.state) {
-      newElem.state = newElem.props.state;
-      delete newElem.props.state;
-    }
-    if (newElem.props.attr) {
-      newElem.attr = newElem.props.attr;
-      delete newElem.props.attr;
-    }
-    if (newElem.props.if) {
-      newElem.if = newElem.props.if;
-      delete newElem.props.if;
-    }
-    if (childExtends)
-      newElem.childExtend = childExtends;
-    return newElem;
-  } else if (!extend || extend === true) {
-    return __spreadProps(__spreadValues({}, element), {
-      tag,
-      extend: extendFromKey
-    });
-  } else if (extend) {
-    return addAdditionalExtend(extendFromKey, element);
-  } else if (isFunction(element)) {
-    return {
-      extend: extendFromKey,
-      tag,
-      props: __spreadValues({}, exec(element, parent))
-    };
-  }
-};
 function getCapitalCaseKeys(obj) {
   return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
 }
-const addChildrenIfNotInOriginal = (element, parent, key) => {
-  const childElems = getCapitalCaseKeys(element.props);
-  if (!childElems.length)
-    return element;
-  for (const i in childElems) {
-    const childKey = childElems[i];
-    const childElem = element[childKey];
-    const newChild = element.props[childKey];
-    const assignChild = (val) => {
-      element[childKey] = val;
-      delete element.props[childKey];
-    };
-    if (newChild == null ? void 0 : newChild.ignoreExtend)
-      continue;
-    if (newChild === null)
-      assignChild(null);
-    else if (!childElem)
-      assignChild(deepClone(newChild));
-    else {
-      const isSugarChildElem = checkIfSugar(childElem, parent, key);
-      if (isSugarChildElem)
-        continue;
-      assignChild({
-        extend: element[childKey],
-        props: newChild
-      });
-    }
-  }
-};
-const applyKeyComponentAsExtend = (element, parent, key) => {
-  return extendizeByKey(element, parent, key) || element;
-};
-const applyComponentFromContext = (element, parent, options) => {
-  const { context } = element;
-  if (!context || !context.components)
-    return;
-  const { components } = context;
-  const { extend } = element;
-  const execExtend = exec(extend, element);
-  if (isString(execExtend)) {
-    const componentExists = components[execExtend] || components["smbls." + execExtend];
-    if (componentExists)
-      element.extend = componentExists;
-    else {
-      if ((ENV === "test" || ENV === "development") && options.verbose) {
-        console.warn(execExtend, "is not in library", components, element);
-        console.warn("replacing with ", {});
-      }
-      element.extend = {};
-    }
-  }
-};
-const isVariant = (param) => {
-  if (!isString(param))
-    return;
-  const firstCharKey = param.slice(0, 1);
-  return firstCharKey === ".";
-};
-const hasVariantProp = (element) => {
-  const { props } = element;
-  if (isObject(props) && isString(props.variant))
-    return true;
-};
-const getChildrenComponentsByKey = (key, el) => {
-  if (key === el.key || el.__ref.__componentKey === key) {
-    return el;
-  }
-  if (el.extend) {
-    const foundString = isString(el.extend) && el.extend === key;
-    const foundInArray = isArray(el.extend) && el.extend.filter((v) => v === key).length;
-    if (foundString || foundInArray)
-      return el;
-  }
-  if (el.parent && el.parent.childExtend) {
-    const foundString = isString(el.parent.childExtend) && el.parent.childExtend === key;
-    const foundInArray = isArray(el.parent.childExtend) && el.parent.childExtend.filter((v) => v === key).length;
-    if (foundString || foundInArray)
-      return el;
-  }
-};
-const getExtendsInElement = (obj) => {
-  let result = [];
-  function traverse(o) {
-    for (const key in o) {
-      if (Object.hasOwnProperty.call(o, key)) {
-        if (checkIfKeyIsComponent(key)) {
-          result.push(key);
-        }
-        if (key === "extend" || key === "extends") {
-          if (typeof o[key] === "string") {
-            result.push(o[key]);
-          } else if (Array.isArray(o[key])) {
-            result = result.concat(o[key]);
-          }
-        }
-        if (typeof o[key] === "object" && o[key] !== null) {
-          traverse(o[key]);
-        }
-      }
-    }
-  }
-  traverse(obj);
-  return result;
-};
-const setContentKey = (el, opts = {}) => {
-  const { __ref: ref } = el;
-  const contentElementKey = opts.contentElementKey;
-  if (contentElementKey !== "content" && contentElementKey !== ref.contentElementKey || !ref.contentElementKey) {
-    ref.contentElementKey = contentElementKey || "content";
-  } else
-    ref.contentElementKey = "content";
-  if (contentElementKey !== "content")
-    opts.contentElementKey = "content";
-  return ref.contentElementKey;
-};
+function getSpreadChildren(obj) {
+  return Object.keys(obj).filter((key) => /^\d+$/.test(key));
+}
+function isContextComponent(element, parent, passedKey) {
+  var _a, _b;
+  const { context } = parent || {};
+  const [extendsKey] = createExtendsFromKeys(passedKey);
+  const key = passedKey || extendsKey;
+  return ((_a = context == null ? void 0 : context.components) == null ? void 0 : _a[key]) || ((_b = context == null ? void 0 : context.pages) == null ? void 0 : _b[key]);
+}
 export {
-  addAdditionalExtend,
-  addChildrenIfNotInOriginal,
-  applyComponentFromContext,
-  applyKeyComponentAsExtend,
-  checkIfKeyIsComponent,
-  checkIfKeyIsProperty,
-  checkIfSugar,
-  extendizeByKey,
-  extractComponentKeyFromKey,
   getCapitalCaseKeys,
-  getChildrenComponentsByKey,
-  getExtendsInElement,
-  hasVariantProp,
-  isVariant,
-  setContentKey
+  getSpreadChildren,
+  isContextComponent,
+  matchesComponentNaming
 };

package/dist/esm/cookie.js

@@ -2,53 +2,48 @@ import { isUndefined } from "./types.js";
 import { document } from "./globals.js";
 const isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
 const setCookie = (cname, cvalue, exdays = 365) => {
-  if (isUndefined(document) || isUndefined(document.cookie))
-    return;
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
   const d = /* @__PURE__ */ new Date();
   d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
   const expires = `expires=${d.toUTCString()}`;
   document.cookie = `${cname}=${cvalue};${expires};path=/`;
 };
 const getCookie = (cname) => {
-  if (isUndefined(document) || isUndefined(document.cookie))
-    return;
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
   const name = `${cname}=`;
   const decodedCookie = decodeURIComponent(document.cookie);
   const ca = decodedCookie.split(";");
   for (let i = 0; i < ca.length; i++) {
     let c = ca[i];
-    while (c.charAt(0) === " ")
-      c = c.substring(1);
-    if (c.indexOf(name) === 0)
-      return c.substring(name.length, c.length);
+    while (c.charAt(0) === " ") c = c.substring(1);
+    if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
   }
   return "";
 };
 const removeCookie = (cname) => {
-  if (isUndefined(document) || isUndefined(document.cookie))
-    return;
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
   document.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
 };
 function getLocalStorage(key) {
-  let savedJSON;
-  if (window.localStorage) {
-    try {
-      savedJSON = JSON.parse(window.localStorage.getItem(key));
-    } catch (e) {
-    }
+  if (!window.localStorage) {
+    return void 0;
   }
-  if (typeof savedJSON !== "undefined") {
-    return savedJSON;
+  const item = window.localStorage.getItem(key);
+  if (item === null) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(item);
+  } catch (e) {
+    return void 0;
   }
 }
 function setLocalStorage(key, data) {
-  if (data && window.localStorage) {
-    if (typeof data === "object") {
-      window.localStorage.setItem(key, JSON.stringify(data));
-    } else {
-      window.localStorage.setItem(key, data);
-    }
+  if (!window.localStorage || data === void 0 || data === null) {
+    return;
   }
+  const value = typeof data === "object" ? JSON.stringify(data) : data;
+  window.localStorage.setItem(key, value);
 }
 export {
   getCookie,

package/dist/esm/element.js

@@ -0,0 +1,135 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { createExtends } from "./extends.js";
+import { createKey } from "./key.js";
+import { isNode } from "./node.js";
+import { createProps } from "./props.js";
+import { HTML_TAGS } from "./tags.js";
+import { is, isFunction } from "./types.js";
+const ENV = "development";
+const returnValueAsText = (element, parent, key) => {
+  const childExtendsTag = parent.childExtends && parent.childExtends.tag;
+  const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
+  };
+};
+const createBasedOnType = (element, parent, key) => {
+  if (element === void 0) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(
+        key,
+        "element is undefined in",
+        parent && parent.__ref && parent.__ref.path
+      );
+    }
+    return {};
+  }
+  if (element === null) return;
+  if (element === true) return {};
+  if (is(element)("string", "number")) {
+    return returnValueAsText(element, parent, key);
+  }
+  if (isFunction(element)) {
+    return { props: element };
+  }
+  return element;
+};
+const addRef = (element, parent) => {
+  const ref = {};
+  ref.origin = element;
+  ref.parent = parent;
+  return ref;
+};
+const createParent = (element, parent, key, options, root) => {
+  if (!parent) return root;
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ":root", node: parent };
+    root[`${key}_parent`] = parentNodeWrapper;
+    return parentNodeWrapper;
+  }
+  return parent;
+};
+const createRoot = (element, parent) => {
+  const { __ref: ref } = element;
+  const { __ref: parentRef } = parent;
+  const hasRoot = parent && parent.key === ":root";
+  if (!(ref == null ? void 0 : ref.root)) {
+    return hasRoot ? element : parentRef == null ? void 0 : parentRef.root;
+  }
+};
+const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent;
+  if (!parentRef) parentRef = parent.ref = {};
+  if (!parentRef.path) parentRef.path = [];
+  return parentRef.path.concat(key);
+};
+const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext = options.context && !root.context && !element.context;
+  if (forcedOptionsContext) root.context = options.context;
+  return options.context || parent.context || root.context || element.context;
+};
+const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent);
+  element.__ref = ref;
+  if (!ref.__defineCache) ref.__defineCache = {};
+  if (!ref.__exec) ref.__exec = {};
+  if (!ref.__execProps) ref.__execProps = {};
+  if (!ref.__class) ref.__class = {};
+  if (!ref.__classNames) ref.__classNames = {};
+  if (!ref.__attr) ref.__attr = {};
+  if (!ref.__changes) ref.__changes = [];
+  if (!ref.__children) ref.__children = [];
+  ref.__extends = createExtends(element, parent, key);
+  ref.path = createPath(element, parent, key);
+  ref.root = createRoot(element, parent);
+  return ref;
+};
+const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = passedProps == null ? void 0 : passedProps.__hash;
+  const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
+  if (!element) return;
+  const parent = createParent(element, parentEl, passedKey, opts, root);
+  const key = createKey(element, parent, passedKey);
+  addCaching(element, parent, key);
+  const props = createProps(element, parent, key);
+  const context = addContext(element, parent, key, opts, root);
+  const on = element.on || {};
+  return __spreadProps(__spreadValues({}, element), {
+    key,
+    props,
+    parent,
+    context,
+    on
+  });
+};
+export {
+  addCaching,
+  addContext,
+  addRef,
+  createBasedOnType,
+  createElement,
+  createParent,
+  createPath,
+  createRoot,
+  returnValueAsText
+};

package/dist/esm/events.js

@@ -0,0 +1,17 @@
+import { lowercaseFirstLetter } from "./string.js";
+import { isFunction } from "./types.js";
+const addEventFromProps = (key, element) => {
+  const { props, on } = element;
+  const eventName = lowercaseFirstLetter(key.split("on")[1]);
+  const origEvent = on[eventName];
+  const funcFromProps = props[key];
+  if (isFunction(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args);
+      if (originalEventRetunrs !== false) funcFromProps(...args);
+    };
+  } else on[eventName] = funcFromProps;
+};
+export {
+  addEventFromProps
+};