@domql/utils 2.5.200 → 3.0.1

package/dist/cjs/component.js

@@ -18,221 +18,30 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var component_exports = {};
 __export(component_exports, {
-  addAdditionalExtend: () => addAdditionalExtend,
-  addChildrenIfNotInOriginal: () => addChildrenIfNotInOriginal,
-  applyComponentFromContext: () => applyComponentFromContext,
-  applyKeyComponentAsExtend: () => applyKeyComponentAsExtend,
-  checkIfKeyIsComponent: () => checkIfKeyIsComponent,
-  checkIfKeyIsProperty: () => checkIfKeyIsProperty,
-  checkIfSugar: () => checkIfSugar,
-  extendizeByKey: () => extendizeByKey,
-  extractComponentKeyFromKey: () => extractComponentKeyFromKey,
   getCapitalCaseKeys: () => getCapitalCaseKeys,
-  getChildrenComponentsByKey: () => getChildrenComponentsByKey,
-  getExtendsInElement: () => getExtendsInElement,
-  hasVariantProp: () => hasVariantProp,
-  isVariant: () => isVariant,
-  setContentKey: () => setContentKey
+  getSpreadChildren: () => getSpreadChildren,
+  isContextComponent: () => isContextComponent,
+  matchesComponentNaming: () => matchesComponentNaming
 });
 module.exports = __toCommonJS(component_exports);
-var import_array = require("./array.js");
-var import_object = require("./object.js");
+var import_extends = require("./extends.js");
 var import_types = require("./types.js");
-const ENV = "development";
-const checkIfKeyIsComponent = (key) => {
+const matchesComponentNaming = (key) => {
   const isFirstKeyString = (0, import_types.isString)(key);
   if (!isFirstKeyString) return;
   const firstCharKey = key.slice(0, 1);
   return /^[A-Z]*$/.test(firstCharKey);
 };
-const checkIfKeyIsProperty = (key) => {
-  const isFirstKeyString = (0, import_types.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 = (0, import_types.isArray)(elementExtend) ? elementExtend : [elementExtend];
-  const receivedArray = (0, import_types.isArray)(newExtend) ? newExtend : [newExtend];
-  const extend = (0, import_array.joinArrays)(receivedArray, originalArray);
-  return { ...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: { ...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 {
-      ...element,
-      tag,
-      extend: extendFromKey
-    };
-  } else if (extend) {
-    return addAdditionalExtend(extendFromKey, element);
-  } else if ((0, import_types.isFunction)(element)) {
-    return {
-      extend: extendFromKey,
-      tag,
-      props: { ...(0, import_object.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((0, import_object.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 = (0, import_object.exec)(extend, element);
-  if ((0, import_types.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 (!(0, import_types.isString)(param)) return;
-  const firstCharKey = param.slice(0, 1);
-  return firstCharKey === ".";
-};
-const hasVariantProp = (element) => {
-  const { props } = element;
-  if ((0, import_types.isObject)(props) && (0, import_types.isString)(props.variant)) return true;
-};
-const getChildrenComponentsByKey = (key, el) => {
-  if (key === el.key || el.__ref.__componentKey === key) {
-    return el;
-  }
-  if (el.extend) {
-    const foundString = (0, import_types.isString)(el.extend) && el.extend === key;
-    const foundInArray = (0, import_types.isArray)(el.extend) && el.extend.filter((v) => v === key).length;
-    if (foundString || foundInArray) return el;
-  }
-  if (el.parent && el.parent.childExtend) {
-    const foundString = (0, import_types.isString)(el.parent.childExtend) && el.parent.childExtend === key;
-    const foundInArray = (0, import_types.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] = (0, import_extends.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]);
+}

package/dist/cjs/cookie.js

@@ -53,23 +53,23 @@ const removeCookie = (cname) => {
   import_globals.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);
 }

package/dist/cjs/element.js

@@ -0,0 +1,136 @@
+"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 element_exports = {};
+__export(element_exports, {
+  addCaching: () => addCaching,
+  addContext: () => addContext,
+  addRef: () => addRef,
+  createBasedOnType: () => createBasedOnType,
+  createElement: () => createElement,
+  createParent: () => createParent,
+  createPath: () => createPath,
+  createRoot: () => createRoot,
+  returnValueAsText: () => returnValueAsText
+});
+module.exports = __toCommonJS(element_exports);
+var import_extends = require("./extends.js");
+var import_key = require("./key.js");
+var import_node = require("./node.js");
+var import_props = require("./props.js");
+var import_tags = require("./tags.js");
+var import_types = require("./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 = import_tags.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 ((0, import_types.is)(element)("string", "number")) {
+    return returnValueAsText(element, parent, key);
+  }
+  if ((0, import_types.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 ((0, import_node.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)) {
+    ref.root = 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 = (0, import_extends.createExtends)(element, parent, key);
+  ref.path = createPath(element, parent, key);
+  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 = (0, import_key.createKey)(element, parent, passedKey);
+  addCaching(element, parent, key);
+  const props = (0, import_props.createProps)(element, parent, key);
+  const context = addContext(element, parent, key, opts, root);
+  const on = element.on || {};
+  return {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  };
+};

package/dist/cjs/events.js

@@ -0,0 +1,37 @@
+"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 events_exports = {};
+__export(events_exports, {
+  addEventFromProps: () => addEventFromProps
+});
+module.exports = __toCommonJS(events_exports);
+var import_string = require("./string.js");
+var import_types = require("./types.js");
+const addEventFromProps = (key, element) => {
+  const { props, on } = element;
+  const eventName = (0, import_string.lowercaseFirstLetter)(key.split("on")[1]);
+  const origEvent = on[eventName];
+  const funcFromProps = props[key];
+  if ((0, import_types.isFunction)(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args);
+      if (originalEventRetunrs !== false) funcFromProps(...args);
+    };
+  } else on[eventName] = funcFromProps;
+};