@domql/utils 3.2.3 → 3.2.10

package/dist/cjs/state.js

@@ -37,7 +37,7 @@ var import_object = require("./object.js");
 var import_types = require("./types.js");
 const checkForStateTypes = (element) => {
   const { state: orig, props, __ref: ref } = element;
-  const state = (props == null ? void 0 : props.state) || orig;
+  const state = props?.state || orig;
   if ((0, import_types.isFunction)(state)) {
     ref.__state = state;
     return (0, import_object.exec)(state, element);
@@ -107,7 +107,7 @@ const findInheritedState = (element, parent, options = {}) => {
 const createInheritedState = (element, parent) => {
   const ref = element.__ref;
   const inheritedState = findInheritedState(element, parent);
-  if ((0, import_types.isUndefined)(inheritedState)) return element.state;
+  if (inheritedState === void 0) return element.state;
   if ((0, import_types.is)(inheritedState)("object", "array")) {
     return (0, import_object.deepClone)(inheritedState);
   } else if ((0, import_types.is)(inheritedState)("string", "number", "boolean")) {
@@ -118,7 +118,7 @@ const createInheritedState = (element, parent) => {
 };
 const checkIfInherits = (element) => {
   const { __ref: ref } = element;
-  const stateKey = ref == null ? void 0 : ref.__state;
+  const stateKey = ref?.__state;
   if (stateKey && (0, import_types.is)(stateKey)("number", "string", "boolean")) return true;
   return false;
 };
@@ -135,15 +135,16 @@ const createNestedObjectByKeyPath = (path, value) => {
   const keys = path.split("/");
   const obj = {};
   let ref = obj;
-  keys.forEach((key, index) => {
-    ref[key] = index === keys.length - 1 ? value || {} : {};
-    ref = ref[key];
-  });
+  const lastIdx = keys.length - 1;
+  for (let i = 0; i <= lastIdx; i++) {
+    ref[keys[i]] = i === lastIdx ? value || {} : {};
+    ref = ref[keys[i]];
+  }
   return obj;
 };
 const applyDependentState = (element, state) => {
   const { __element } = state;
-  const origState = (0, import_object.exec)(__element == null ? void 0 : __element.state, element);
+  const origState = (0, import_object.exec)(__element?.state, element);
   if (!origState) return;
   const dependentState = (0, import_object.deepClone)(origState, import_keys.STATE_METHODS);
   const newDepends = { [element.key]: dependentState };

package/dist/cjs/string.js

@@ -48,15 +48,15 @@ const brackRegex = {
 };
 const getNestedValue = (obj, path) => {
   return path.split(".").reduce((acc, part) => {
-    return acc && acc[part] !== void 0 ? acc[part] : void 0;
+    return acc?.[part];
   }, obj);
 };
-function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
+function replaceLiteralsWithObjectFields(str, state, options = {}) {
   const { bracketsLength = 2 } = options;
   const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
   if (!str.includes(bracketPattern)) return str;
   const reg = brackRegex[bracketsLength];
-  const obj = state || {};
+  const obj = state || this.state || {};
   return str.replace(reg, (_, parentPath, variable) => {
     if (parentPath) {
       const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
@@ -67,13 +67,13 @@ function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
       }
       const key = variable.trim();
       if (key === "parent") {
-        return parentState.value !== void 0 ? String(parentState.value) : "";
+        return String(parentState.value ?? "");
       }
       const value = getNestedValue(parentState, key);
-      return value !== void 0 ? String(value) : "";
+      return String(value ?? "");
     } else {
       const value = getNestedValue(obj, variable.trim());
-      return value !== void 0 ? String(value) : "";
+      return String(value ?? "");
     }
   });
 }
@@ -126,27 +126,22 @@ const findKeyPosition = (str, key) => {
     endLineNumber
   };
 };
+const RE_OCTAL = /\\([0-7]{1,3})/g;
 const replaceOctalEscapeSequences = (str) => {
-  const octalRegex = /\\([0-7]{1,3})/g;
-  return str.replace(octalRegex, (match, p1) => {
-    const octalValue = parseInt(p1, 8);
-    const char = String.fromCharCode(octalValue);
-    return char;
-  });
+  return str.replace(RE_OCTAL, (_, p1) => String.fromCharCode(parseInt(p1, 8)));
 };
 const encodeNewlines = (str) => {
-  return str.split("\n").join("/////n").split("`").join("/////tilde").split("$").join("/////dlrsgn");
+  return str.replace(/\n/g, "/////n").replace(/`/g, "/////tilde").replace(/\$/g, "/////dlrsgn");
 };
 const decodeNewlines = (encodedStr) => {
-  return encodedStr.split("/////n").join("\n").split("/////tilde").join("`").split("/////dlrsgn").join("$");
+  return encodedStr.replace(/\/\/\/\/\/n/g, "\n").replace(/\/\/\/\/\/tilde/g, "`").replace(/\/\/\/\/\/dlrsgn/g, "$");
 };
+const RE_NON_ALNUM = /[^a-zA-Z0-9\s]/g;
 const customEncodeURIComponent = (str) => {
-  return str.split("").map((char) => {
-    if (/[^a-zA-Z0-9\s]/.test(char)) {
-      return "%" + char.charCodeAt(0).toString(16).toUpperCase();
-    }
-    return char;
-  }).join("");
+  return str.replace(
+    RE_NON_ALNUM,
+    (char) => "%" + char.charCodeAt(0).toString(16).toUpperCase()
+  );
 };
 const customDecodeURIComponent = (encodedStr) => {
   return encodedStr.replace(

package/dist/cjs/tags.js

@@ -19,13 +19,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var tags_exports = {};
 __export(tags_exports, {
   HTML_TAGS: () => HTML_TAGS,
+  SVG_TAGS: () => SVG_TAGS,
   isValidHtmlTag: () => isValidHtmlTag
 });
 module.exports = __toCommonJS(tags_exports);
 const HTML_TAGS = {
   root: ["body", "html"],
   head: ["title", "base", "meta", "style", "noscript", "script"],
-  body: [
+  body: /* @__PURE__ */ new Set([
     "string",
     "style",
     "fragment",
@@ -149,7 +150,71 @@ const HTML_TAGS = {
     "wbr",
     // SVG
     "svg",
-    "path"
-  ]
+    "path",
+    "circle",
+    "ellipse",
+    "line",
+    "polygon",
+    "polyline",
+    "rect",
+    "g",
+    "defs",
+    "symbol",
+    "use",
+    "text",
+    "tspan",
+    "image",
+    "clipPath",
+    "mask",
+    "pattern",
+    "marker",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "filter",
+    "feGaussianBlur",
+    "feOffset",
+    "feMerge",
+    "feMergeNode",
+    "feBlend",
+    "feColorMatrix",
+    "feFlood",
+    "feComposite",
+    "foreignObject"
+  ])
 };
-const isValidHtmlTag = (arg) => HTML_TAGS.body.includes(arg);
+const SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "ellipse",
+  "line",
+  "polygon",
+  "polyline",
+  "rect",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "text",
+  "tspan",
+  "image",
+  "clipPath",
+  "mask",
+  "pattern",
+  "marker",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "filter",
+  "feGaussianBlur",
+  "feOffset",
+  "feMerge",
+  "feMergeNode",
+  "feBlend",
+  "feColorMatrix",
+  "feFlood",
+  "feComposite",
+  "foreignObject"
+]);
+const isValidHtmlTag = (arg) => HTML_TAGS.body.has(arg);

package/dist/cjs/triggerEvent.js

@@ -0,0 +1,90 @@
+"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 triggerEvent_exports = {};
+__export(triggerEvent_exports, {
+  applyEvent: () => applyEvent,
+  applyEventUpdate: () => applyEventUpdate,
+  triggerEventOn: () => triggerEventOn,
+  triggerEventOnUpdate: () => triggerEventOnUpdate
+});
+module.exports = __toCommonJS(triggerEvent_exports);
+var import_types = require("./types.js");
+const getOnOrPropsEvent = (param, element) => {
+  const onEvent = element.on?.[param];
+  if (onEvent) return onEvent;
+  const props = element.props;
+  if (!props) return;
+  const propKey = "on" + param.charAt(0).toUpperCase() + param.slice(1);
+  return props[propKey];
+};
+const applyEvent = (param, element, state, context, options) => {
+  if (!(0, import_types.isFunction)(param)) return;
+  const result = param.call(
+    element,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
+  if (result && typeof result.then === "function") {
+    result.catch(() => {
+    });
+  }
+  return result;
+};
+const triggerEventOn = (param, element, options) => {
+  if (!element) {
+    throw new Error("Element is required");
+  }
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state, context } = element;
+    return applyEvent(appliedFunction, element, state, context, options);
+  }
+};
+const applyEventUpdate = (param, updatedObj, element, state, context, options) => {
+  if (!(0, import_types.isFunction)(param)) return;
+  const result = param.call(
+    element,
+    updatedObj,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
+  if (result && typeof result.then === "function") {
+    result.catch(() => {
+    });
+  }
+  return result;
+};
+const triggerEventOnUpdate = (param, updatedObj, element, options) => {
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state, context } = element;
+    return applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    );
+  }
+};

package/dist/cjs/types.js

@@ -50,12 +50,8 @@ const isObjectLike = (arg) => {
   if (arg === null) return false;
   return typeof arg === "object";
 };
-const isDefined = (arg) => {
-  return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isDate(arg) || isNull(arg);
-};
-const isUndefined = (arg) => {
-  return arg === void 0;
-};
+const isDefined = (arg) => arg !== void 0;
+const isUndefined = (arg) => arg === void 0;
 const TYPES = {
   boolean: isBoolean,
   array: isArray,
@@ -71,12 +67,8 @@ const TYPES = {
   defined: isDefined
 };
 const is = (arg) => {
-  return (...args) => {
-    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
-  };
+  return (...args) => args.some((val) => TYPES[val](arg));
 };
 const isNot = (arg) => {
-  return (...args) => {
-    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
-  };
+  return (...args) => !args.some((val) => TYPES[val](arg));
 };

package/dist/esm/array.js

@@ -4,9 +4,11 @@ const arrayContainsOtherArray = (arr1, arr2) => {
   return arr2.every((val) => arr1.includes(val));
 };
 const getFrequencyInArray = (arr, value) => {
-  return arr.reduce((count, currentValue) => {
-    return currentValue === value ? count + 1 : count;
-  }, 0);
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === value) count++;
+  }
+  return count;
 };
 const removeFromArray = (arr, index) => {
   if (isString(index)) index = parseInt(index);
@@ -100,8 +102,12 @@ const filterArraysFast = (sourceArr, excludeArr) => {
   return sourceArr.filter((item) => !excludeSet.has(item));
 };
 const checkIfStringIsInArray = (string, arr) => {
-  if (!string) return;
-  return arr.filter((v) => string.includes(v)).length;
+  if (!string) return 0;
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (string.includes(arr[i])) count++;
+  }
+  return count;
 };
 const removeDuplicatesInArray = (arr) => {
   if (!isArray(arr)) return arr;

package/dist/esm/component.js

@@ -1,10 +1,9 @@
 import { createExtendsFromKeys } from "./extends.js";
 import { isString } from "./types.js";
 const matchesComponentNaming = (key) => {
-  const isFirstKeyString = isString(key);
-  if (!isFirstKeyString) return;
-  const firstCharKey = key.slice(0, 1);
-  return /^[A-Z]*$/.test(firstCharKey);
+  if (!isString(key) || !key.length) return false;
+  const code = key.charCodeAt(0);
+  return code >= 65 && code <= 90;
 };
 function getCapitalCaseKeys(obj) {
   return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
@@ -13,11 +12,10 @@ 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]);
+  return context?.components?.[key] || context?.pages?.[key];
 }
 export {
   getCapitalCaseKeys,

package/dist/esm/element.js

@@ -1,22 +1,3 @@
-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";
@@ -27,7 +8,7 @@ const ENV = process.env.NODE_ENV;
 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;
+  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key;
   return {
     text: element,
     tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
@@ -39,7 +20,7 @@ const createBasedOnType = (element, parent, key) => {
       console.warn(
         key,
         "element is undefined in",
-        parent && parent.__ref && parent.__ref.path
+        parent?.__ref?.path
       );
     }
     return {};
@@ -73,8 +54,8 @@ 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;
+  if (!ref?.root) {
+    ref.root = hasRoot ? element : parentRef?.root;
   }
 };
 const createPath = (element, parent, key) => {
@@ -104,7 +85,7 @@ const addCaching = (element, parent, key) => {
   return ref;
 };
 const createElement = (passedProps, parentEl, passedKey, opts, root) => {
-  const hashed = passedProps == null ? void 0 : passedProps.__hash;
+  const hashed = passedProps?.__hash;
   const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
   if (!element) return;
   const parent = createParent(element, parentEl, passedKey, opts, root);
@@ -113,13 +94,14 @@ const createElement = (passedProps, parentEl, passedKey, opts, root) => {
   const props = createProps(element, parent, key);
   const context = addContext(element, parent, key, opts, root);
   const on = element.on || {};
-  return __spreadProps(__spreadValues({}, element), {
+  return {
+    ...element,
     key,
     props,
     parent,
     context,
     on
-  });
+  };
 };
 export {
   addCaching,