@domql/utils 3.1.2 → 3.2.7

package/dist/cjs/props.js

@@ -40,6 +40,9 @@ var import_keys = require("./keys.js");
 var import_events = require("./events.js");
 var import_object = require("./object.js");
 var import_types = require("./types.js");
+var import_string = require("./string.js");
+const RE_UPPER = /^[A-Z]/;
+const RE_DIGITS = /^\d+$/;
 const createProps = (element, parent, key) => {
   const { props, __ref: ref } = element;
   ref.__propsStack = [];
@@ -52,14 +55,20 @@ const createProps = (element, parent, key) => {
   return { ...props };
 };
 function pickupPropsFromElement(obj, opts = {}) {
-  var _a, _b, _c;
   const cachedKeys = opts.cachedKeys || [];
   for (const key in obj) {
     const value = obj[key];
-    const hasDefine = (0, import_types.isObject)((_a = this.define) == null ? void 0 : _a[key]);
-    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = this.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
-    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
-    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    const isEventHandler = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key[2] === key[2].toUpperCase() && (0, import_types.isFunction)(value);
+    if (isEventHandler) {
+      const eventName = (0, import_string.lowercaseFirstLetter)(key.slice(2));
+      if (obj.on) obj.on[eventName] = value;
+      delete obj[key];
+      continue;
+    }
+    const hasDefine = (0, import_types.isObject)(this.define?.[key]);
+    const hasGlobalDefine = (0, import_types.isObject)(this.context?.define?.[key]);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.has(key);
     if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
       obj.props[key] = value;
       delete obj[key];
@@ -69,11 +78,10 @@ function pickupPropsFromElement(obj, opts = {}) {
   return obj;
 }
 function pickupElementFromProps(obj = this, opts) {
-  var _a, _b, _c;
   const cachedKeys = opts.cachedKeys || [];
   for (const key in obj.props) {
     const value = obj.props[key];
-    const isEvent = key.startsWith("on") && key.length > 2;
+    const isEvent = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110;
     const isFn = (0, import_types.isFunction)(value);
     if (isEvent && isFn) {
       (0, import_events.addEventFromProps)(key, obj);
@@ -81,13 +89,15 @@ function pickupElementFromProps(obj = this, opts) {
       continue;
     }
     if (cachedKeys.includes(key)) continue;
-    const hasDefine = (0, import_types.isObject)((_a = this.define) == null ? void 0 : _a[key]);
-    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = this.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
-    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
-    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    const hasDefine = (0, import_types.isObject)(this.define?.[key]);
+    const hasGlobalDefine = (0, import_types.isObject)(this.context?.define?.[key]);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.has(key);
     if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
-      obj[key] = value;
-      if (obj.props) delete obj.props[key];
+      if (obj[key] === void 0 || value === null) {
+        obj[key] = value;
+        if (obj.props) delete obj.props[key];
+      }
     }
   }
   return obj;
@@ -99,8 +109,9 @@ function propertizeElement(element = this) {
   return element;
 }
 function propertizeUpdate(params = {}) {
-  const obj = (0, import_object.deepMerge)({ on: {}, props: {} }, params);
-  return propertizeElement.call(this, obj);
+  if (!params.on) params.on = {};
+  if (!params.props) params.props = {};
+  return propertizeElement.call(this, params);
 }
 const objectizeStringProperty = (propValue) => {
   if ((0, import_types.is)(propValue)("string", "number")) {
@@ -110,21 +121,16 @@ const objectizeStringProperty = (propValue) => {
 };
 const propExists = (prop, stack) => {
   if (!prop || !stack.length) return false;
-  const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
-  return stack.some((existing) => {
-    const existingKey = (0, import_types.isObject)(existing) ? JSON.stringify(existing) : existing;
-    return existingKey === key;
-  });
+  return stack.includes(prop);
 };
 const inheritParentProps = (element, parent) => {
-  var _a;
   const { __ref: ref } = element;
   const propsStack = ref.__propsStack || [];
   const parentProps = parent.props;
   if (!parentProps) return propsStack;
   const matchParentKeyProps = parentProps[element.key];
   const matchParentChildProps = parentProps.childProps;
-  const ignoreChildProps = (_a = element.props) == null ? void 0 : _a.ignoreChildProps;
+  const ignoreChildProps = element.props?.ignoreChildProps;
   if (matchParentChildProps && !ignoreChildProps) {
     const childProps = objectizeStringProperty(matchParentChildProps);
     propsStack.unshift(childProps);
@@ -135,9 +141,9 @@ const inheritParentProps = (element, parent) => {
   }
   return propsStack;
 };
-async function update(props, options) {
+function update(props, options) {
   const element = this.__element;
-  await element.update({ props }, options);
+  element.update({ props }, options);
 }
 function setPropsPrototype(element) {
   const methods = { update: update.bind(element.props), __element: element };
@@ -146,16 +152,15 @@ function setPropsPrototype(element) {
 const removeDuplicateProps = (propsStack) => {
   const seen = /* @__PURE__ */ new Set();
   return propsStack.filter((prop) => {
-    if (!prop || import_keys.PROPS_METHODS.includes(prop)) return false;
-    const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    if (!prop || import_keys.PROPS_METHODS.has(prop)) return false;
+    if (seen.has(prop)) return false;
+    seen.add(prop);
     return true;
   });
 };
 const syncProps = (propsStack, element, opts) => {
   element.props = propsStack.reduce((mergedProps, v) => {
-    if (import_keys.PROPS_METHODS.includes(v)) return mergedProps;
+    if (import_keys.PROPS_METHODS.has(v)) return mergedProps;
     while ((0, import_types.isFunction)(v)) v = (0, import_object.exec)(v, element);
     return (0, import_object.deepMerge)(mergedProps, (0, import_object.deepClone)(v, { exclude: import_keys.PROPS_METHODS }));
   }, {});
@@ -165,19 +170,20 @@ const syncProps = (propsStack, element, opts) => {
 const createPropsStack = (element, parent) => {
   const { props, __ref: ref } = element;
   let propsStack = ref.__propsStack || [];
-  if (parent && parent.props) {
+  if (parent?.props) {
     const parentStack = inheritParentProps(element, parent);
     propsStack = [...parentStack];
   }
   if ((0, import_types.isObject)(props)) propsStack.push(props);
-  else if (props === "inherit" && (parent == null ? void 0 : parent.props)) propsStack.push(parent.props);
+  else if (props === "inherit" && parent?.props) propsStack.push(parent.props);
   else if (props) propsStack.push(props);
   if ((0, import_types.isArray)(ref.__extendsStack)) {
-    ref.__extendsStack.forEach((_extends) => {
+    for (let i = 0; i < ref.__extendsStack.length; i++) {
+      const _extends = ref.__extendsStack[i];
       if (_extends.props && _extends.props !== props) {
         propsStack.push(_extends.props);
       }
-    });
+    }
   }
   ref.__propsStack = removeDuplicateProps(propsStack);
   return ref.__propsStack;
@@ -198,7 +204,10 @@ const initProps = function(element, parent, options) {
   else {
     try {
       applyProps(element, parent);
-    } catch {
+    } catch (e) {
+      if (element.context?.designSystem?.verbose) {
+        console.warn("initProps error at", ref.path?.join("."), e);
+      }
       element.props = {};
       ref.__propsStack = [];
     }

package/dist/cjs/scope.js

@@ -22,7 +22,6 @@ __export(scope_exports, {
 });
 module.exports = __toCommonJS(scope_exports);
 const createScope = (element, parent) => {
-  var _a;
   const { __ref: ref } = element;
-  if (!element.scope) element.scope = parent.scope || ((_a = ref.root) == null ? void 0 : _a.scope) || {};
+  if (!element.scope) element.scope = parent.scope || ref.root?.scope || {};
 };

package/dist/cjs/state.js

@@ -35,12 +35,12 @@ var import_array = require("./array.js");
 var import_keys = require("./keys.js");
 var import_object = require("./object.js");
 var import_types = require("./types.js");
-const checkForStateTypes = async (element) => {
+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 await (0, import_object.execPromise)(state, element);
+    return (0, import_object.exec)(state, element);
   } else if ((0, import_types.is)(state)("string", "number")) {
     ref.__state = state;
     return { value: state };
@@ -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 = async (element, state) => {
+const applyDependentState = (element, state) => {
   const { __element } = state;
-  const origState = await (0, import_object.execPromise)(__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,23 +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: [
+  root: ["body", "html"],
+  head: ["title", "base", "meta", "style", "noscript", "script"],
+  body: /* @__PURE__ */ new Set([
     "string",
     "style",
     "fragment",
@@ -159,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,