@domql/utils 3.1.2 → 3.2.7

package/dist/esm/props.js

@@ -1,23 +1,10 @@
-var __defProp = Object.defineProperty;
-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;
-};
 import { DOMQ_PROPERTIES, PROPS_METHODS } from "./keys.js";
 import { addEventFromProps } from "./events.js";
 import { deepClone, deepMerge, exec } from "./object.js";
 import { is, isArray, isFunction, isObject, isObjectLike } from "./types.js";
+import { lowercaseFirstLetter } from "./string.js";
+const RE_UPPER = /^[A-Z]/;
+const RE_DIGITS = /^\d+$/;
 const createProps = (element, parent, key) => {
   const { props, __ref: ref } = element;
   ref.__propsStack = [];
@@ -27,17 +14,23 @@ const createProps = (element, parent, key) => {
     ref.__propsStack.push(props);
     return {};
   }
-  return __spreadValues({}, props);
+  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 = isObject((_a = this.define) == null ? void 0 : _a[key]);
-    const hasGlobalDefine = 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 = DOMQ_PROPERTIES.includes(key);
+    const isEventHandler = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key[2] === key[2].toUpperCase() && isFunction(value);
+    if (isEventHandler) {
+      const eventName = lowercaseFirstLetter(key.slice(2));
+      if (obj.on) obj.on[eventName] = value;
+      delete obj[key];
+      continue;
+    }
+    const hasDefine = isObject(this.define?.[key]);
+    const hasGlobalDefine = isObject(this.context?.define?.[key]);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = DOMQ_PROPERTIES.has(key);
     if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
       obj.props[key] = value;
       delete obj[key];
@@ -47,11 +40,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 = isFunction(value);
     if (isEvent && isFn) {
       addEventFromProps(key, obj);
@@ -59,13 +51,15 @@ function pickupElementFromProps(obj = this, opts) {
       continue;
     }
     if (cachedKeys.includes(key)) continue;
-    const hasDefine = isObject((_a = this.define) == null ? void 0 : _a[key]);
-    const hasGlobalDefine = 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 = DOMQ_PROPERTIES.includes(key);
+    const hasDefine = isObject(this.define?.[key]);
+    const hasGlobalDefine = isObject(this.context?.define?.[key]);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = 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;
@@ -77,8 +71,9 @@ function propertizeElement(element = this) {
   return element;
 }
 function propertizeUpdate(params = {}) {
-  const obj = 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 (is(propValue)("string", "number")) {
@@ -88,21 +83,16 @@ const objectizeStringProperty = (propValue) => {
 };
 const propExists = (prop, stack) => {
   if (!prop || !stack.length) return false;
-  const key = isObject(prop) ? JSON.stringify(prop) : prop;
-  return stack.some((existing) => {
-    const existingKey = 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);
@@ -113,9 +103,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 };
@@ -124,16 +114,15 @@ function setPropsPrototype(element) {
 const removeDuplicateProps = (propsStack) => {
   const seen = /* @__PURE__ */ new Set();
   return propsStack.filter((prop) => {
-    if (!prop || PROPS_METHODS.includes(prop)) return false;
-    const key = isObject(prop) ? JSON.stringify(prop) : prop;
-    if (seen.has(key)) return false;
-    seen.add(key);
+    if (!prop || 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 (PROPS_METHODS.includes(v)) return mergedProps;
+    if (PROPS_METHODS.has(v)) return mergedProps;
     while (isFunction(v)) v = exec(v, element);
     return deepMerge(mergedProps, deepClone(v, { exclude: PROPS_METHODS }));
   }, {});
@@ -143,19 +132,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 (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 (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;
@@ -177,6 +167,9 @@ const initProps = function(element, parent, options) {
     try {
       applyProps(element, parent);
     } catch (e) {
+      if (element.context?.designSystem?.verbose) {
+        console.warn("initProps error at", ref.path?.join("."), e);
+      }
       element.props = {};
       ref.__propsStack = [];
     }

package/dist/esm/scope.js

@@ -1,7 +1,6 @@
 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 || {};
 };
 export {
   createScope

package/dist/esm/state.js

@@ -1,28 +1,9 @@
-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 { addProtoToArray } from "./array.js";
 import { STATE_METHODS } from "./keys.js";
 import {
   deepClone,
   deepMerge,
-  execPromise,
+  exec,
   overwriteDeep,
   overwriteShallow
 } from "./object.js";
@@ -31,15 +12,14 @@ import {
   isFunction,
   isObject,
   isObjectLike,
-  isString,
-  isUndefined
+  isString
 } from "./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 (isFunction(state)) {
     ref.__state = state;
-    return await execPromise(state, element);
+    return exec(state, element);
   } else if (is(state)("string", "number")) {
     ref.__state = state;
     return { value: state };
@@ -106,7 +86,7 @@ const findInheritedState = (element, parent, options = {}) => {
 const createInheritedState = (element, parent) => {
   const ref = element.__ref;
   const inheritedState = findInheritedState(element, parent);
-  if (isUndefined(inheritedState)) return element.state;
+  if (inheritedState === void 0) return element.state;
   if (is(inheritedState)("object", "array")) {
     return deepClone(inheritedState);
   } else if (is(inheritedState)("string", "number", "boolean")) {
@@ -117,7 +97,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 && is(stateKey)("number", "string", "boolean")) return true;
   return false;
 };
@@ -134,27 +114,30 @@ 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 execPromise(__element == null ? void 0 : __element.state, element);
+  const origState = exec(__element?.state, element);
   if (!origState) return;
   const dependentState = deepClone(origState, STATE_METHODS);
   const newDepends = { [element.key]: dependentState };
-  const __depends = isObject(origState.__depends) ? __spreadValues(__spreadValues({}, origState.__depends), newDepends) : newDepends;
+  const __depends = isObject(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
   if (Array.isArray(origState)) {
-    addProtoToArray(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+    addProtoToArray(origState, {
+      ...Object.getPrototypeOf(origState),
       __depends
-    }));
+    });
   } else {
-    Object.setPrototypeOf(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+    Object.setPrototypeOf(origState, {
+      ...Object.getPrototypeOf(origState),
       __depends
-    }));
+    });
   }
   return dependentState;
 };

package/dist/esm/string.js

@@ -16,15 +16,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;
@@ -35,13 +35,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 ?? "");
     }
   });
 }
@@ -94,27 +94,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/esm/tags.js

@@ -1,17 +1,7 @@
 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",
@@ -135,11 +125,76 @@ 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);
 export {
   HTML_TAGS,
+  SVG_TAGS,
   isValidHtmlTag
 };

package/dist/esm/triggerEvent.js

@@ -0,0 +1,70 @@
+import { isFunction } from "./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 (!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 (!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
+    );
+  }
+};
+export {
+  applyEvent,
+  applyEventUpdate,
+  triggerEventOn,
+  triggerEventOnUpdate
+};

package/dist/esm/types.js

@@ -14,12 +14,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,
@@ -35,14 +31,10 @@ 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));
 };
 export {
   TYPES,