@domql/utils 3.2.3 → 3.2.7

package/dist/esm/extends.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 { joinArrays, removeDuplicatesInArray } from "./array.js";
 import { matchesComponentNaming } from "./component.js";
 import { deepClone, exec } from "./object.js";
@@ -47,13 +28,12 @@ const createExtends = (element, parent, key) => {
   return __extends;
 };
 const addExtends = (newExtends, element) => {
-  var _a;
   const { __ref: ref } = element;
   let { __extends } = ref;
   if (!newExtends) return __extends;
-  const variant = (_a = element.props) == null ? void 0 : _a.variant;
+  const variant = element.props?.variant;
   const context = element.context;
-  if (variant && (context == null ? void 0 : context.components) && !Array.isArray(newExtends) && typeof newExtends === "string") {
+  if (variant && context?.components && !Array.isArray(newExtends) && typeof newExtends === "string") {
     const variantKey = `${newExtends}.${variant}`;
     if (context.components[variantKey]) {
       newExtends = variantKey;
@@ -70,9 +50,10 @@ const concatAddExtends = (newExtend, element) => {
   const { extends: elementExtend } = element;
   const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
   const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
-  return __spreadProps(__spreadValues({}, element), {
+  return {
+    ...element,
     extends: joinArrays(receivedArray, originalArray)
-  });
+  };
 };
 const generateHash = () => Math.random().toString(36).substring(2);
 const extendStackRegistry = {};
@@ -85,7 +66,7 @@ const setHashedExtend = (extend, stack) => {
   if (!isString(extend)) {
     extend.__hash = hash;
   }
-  if (!["__proto__", "constructor", "prototype"].includes(hash)) {
+  if (hash !== "__proto__" && hash !== "constructor" && hash !== "prototype") {
     extendStackRegistry[hash] = stack;
   }
   return stack;
@@ -107,10 +88,16 @@ const extractArrayExtend = (extend, stack, context, processed = /* @__PURE__ */
   return stack;
 };
 const deepExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
-  const extendOflattenExtend = extend.extends;
-  const cleanExtend = __spreadValues({}, extend);
+  const extendOflattenExtend = extend.extends || extend.extend;
+  const cleanExtend = { ...extend };
   delete cleanExtend.extends;
-  if (Object.keys(cleanExtend).length > 0) {
+  delete cleanExtend.extend;
+  let hasKeys = false;
+  for (const _k in cleanExtend) {
+    hasKeys = true;
+    break;
+  }
+  if (hasKeys) {
     stack.push(cleanExtend);
   }
   if (extendOflattenExtend) {
@@ -128,21 +115,30 @@ const flattenExtend = (extend, stack, context, processed = /* @__PURE__ */ new S
     extend = mapStringsWithContextComponents(extend, context);
   }
   processed.add(extend);
-  if (extend == null ? void 0 : extend.extends) {
+  if (extend?.extends || extend?.extend) {
     deepExtend(extend, stack, context, processed);
   } else if (extend) {
     stack.push(extend);
   }
   return stack;
 };
+const MERGE_EXTENDS_SKIP = /* @__PURE__ */ new Set([
+  "parent",
+  "node",
+  "__ref",
+  "__proto__",
+  "extend",
+  "childExtend",
+  "childExtendRecursive"
+]);
 const deepMergeExtends = (element, extend) => {
   extend = deepClone(extend);
   for (const e in extend) {
-    if (["parent", "node", "__ref", "__proto__"].indexOf(e) > -1) continue;
+    if (MERGE_EXTENDS_SKIP.has(e)) continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if (extendProp === void 0) continue;
-    if (Object.prototype.hasOwnProperty.call(extend, e) && !["__proto__", "constructor", "prototype"].includes(e)) {
+    if (Object.prototype.hasOwnProperty.call(extend, e) && e !== "__proto__" && e !== "constructor" && e !== "prototype") {
       if (elementProp === void 0) {
         element[e] = extendProp;
       } else if (isObject(elementProp) && isObject(extendProp)) {
@@ -171,11 +167,11 @@ const cloneAndMergeArrayExtend = (stack) => {
   }, {});
 };
 const mapStringsWithContextComponents = (extend, context, options = {}, variant) => {
-  const COMPONENTS = context && context.components || options.components;
-  const PAGES = context && context.pages || options.pages;
+  const COMPONENTS = context?.components || options.components;
+  const PAGES = context?.pages || options.pages;
   if (isString(extend)) {
     const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
-    const pageExists = PAGES && extend.startsWith("/") && PAGES[extend];
+    const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend];
     if (componentExists) return componentExists;
     else if (pageExists) return pageExists;
     else {
@@ -206,7 +202,7 @@ const getExtendsInElement = (obj) => {
   let result = [];
   function traverse(o) {
     for (const key in o) {
-      if (Object.hasOwnProperty.call(o, key)) {
+      if (Object.prototype.hasOwnProperty.call(o, key)) {
         if (matchesComponentNaming(key)) {
           result.push(key);
         }
@@ -227,14 +223,16 @@ const getExtendsInElement = (obj) => {
   return result;
 };
 const createElementExtends = (element, parent, options = {}) => {
-  var _a;
   const { __ref: ref } = element;
   const context = element.context || parent.context;
-  const variant = (_a = element.props) == null ? void 0 : _a.variant;
+  const variant = element.props?.variant;
+  if (element.extend && !element.extends) element.extends = element.extend;
+  delete element.extend;
+  if (!element.extends && element.props?.extends) element.extends = element.props.extends;
   if (element.extends) {
     if (Array.isArray(element.extends) && element.extends.length > 0) {
       const [firstExtend, ...restExtends] = element.extends;
-      if (typeof firstExtend === "string" && variant && (context == null ? void 0 : context.components)) {
+      if (typeof firstExtend === "string" && variant && context?.components) {
         const variantKey = `${firstExtend}.${variant}`;
         if (context.components[variantKey]) {
           addExtends([variantKey, ...restExtends], element);
@@ -244,7 +242,7 @@ const createElementExtends = (element, parent, options = {}) => {
       } else {
         addExtends(element.extends, element);
       }
-    } else if (typeof element.extends === "string" && variant && (context == null ? void 0 : context.components)) {
+    } else if (typeof element.extends === "string" && variant && context?.components) {
       const variantKey = `${element.extends}.${variant}`;
       if (context.components[variantKey]) {
         addExtends(variantKey, element);
@@ -267,28 +265,28 @@ const createElementExtends = (element, parent, options = {}) => {
   return removeDuplicatesInArray(ref.__extends);
 };
 const inheritChildPropsExtends = (element, parent, options = {}) => {
-  var _a, _b, _c;
   const { props, __ref: ref } = element;
-  const ignoreChildExtends = options.ignoreChildExtends || (props == null ? void 0 : props.ignoreChildExtends);
+  const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
   if (!ignoreChildExtends) {
-    if ((_b = (_a = parent.props) == null ? void 0 : _a.childProps) == null ? void 0 : _b.extends) {
-      addExtends((_c = parent.props) == null ? void 0 : _c.childProps.extends, element);
+    if (parent.props?.childProps?.extends) {
+      addExtends(parent.props?.childProps.extends, element);
     }
   }
   return ref.__extends;
 };
 const inheritChildExtends = (element, parent, options = {}) => {
   const { props, __ref: ref } = element;
-  const ignoreChildExtends = options.ignoreChildExtends || (props == null ? void 0 : props.ignoreChildExtends);
-  if (!ignoreChildExtends && parent.childExtends) {
-    addExtends(parent.childExtends, element);
+  const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
+  const childExtends = parent.childExtends || parent.childExtend;
+  if (!ignoreChildExtends && childExtends) {
+    addExtends(childExtends, element);
   }
   return ref.__extends;
 };
 const inheritRecursiveChildExtends = (element, parent, options = {}) => {
   const { props, __ref: ref } = element;
-  const childExtendsRecursive = parent.childExtendsRecursive;
-  const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || (props == null ? void 0 : props.ignoreChildExtendsRecursive);
+  const childExtendsRecursive = parent.childExtendsRecursive || parent.childExtendRecursive;
+  const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || props?.ignoreChildExtendsRecursive;
   const isText = element.key === "__text";
   if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
     addExtends(childExtendsRecursive, element);
@@ -298,7 +296,7 @@ const inheritRecursiveChildExtends = (element, parent, options = {}) => {
 const createExtendsStack = (element, parent, options = {}) => {
   const { props, __ref: ref } = element;
   const context = element.context || parent.context;
-  const variant = element.variant || (props == null ? void 0 : props.variant);
+  const variant = element.variant || props?.variant;
   const __extends = removeDuplicatesInArray(
     ref.__extends.map((val, i) => {
       return mapStringsWithContextComponents(

package/dist/esm/function.js

@@ -35,16 +35,16 @@ const memoize = (fn) => {
     }
   };
 };
+const RE_STRING_FUNCTION = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
 const isStringFunction = (inputString) => {
-  const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
-  return functionRegex.test(inputString);
+  return RE_STRING_FUNCTION.test(inputString);
 };
 function cloneFunction(fn, win = window) {
   const temp = function() {
     return fn.apply(win, arguments);
   };
   for (const key in fn) {
-    if (Object.hasOwnProperty.call(fn, key)) {
+    if (Object.prototype.hasOwnProperty.call(fn, key)) {
       temp[key] = fn[key];
     }
   }

package/dist/esm/index.js

@@ -21,3 +21,4 @@ export * from "./scope.js";
 export * from "./methods.js";
 export * from "./cache.js";
 export * from "./update.js";
+export * from "./triggerEvent.js";

package/dist/esm/key.js

@@ -1,12 +1,12 @@
 import { exec } from "./object.js";
-const generateKey = /* @__PURE__ */ function() {
+const generateKey = /* @__PURE__ */ (function() {
   let index = 0;
   function newId() {
     index++;
     return index;
   }
   return newId;
-}();
+})();
 const createSnapshotId = generateKey;
 const createKey = (element, parent, key) => {
   return (exec(key, element) || key || element.key || generateKey()).toString();

package/dist/esm/keys.js

@@ -1,4 +1,4 @@
-const DOMQ_PROPERTIES = [
+const DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
   "attr",
   "style",
   "text",
@@ -10,11 +10,14 @@ const DOMQ_PROPERTIES = [
   "scope",
   "root",
   "deps",
+  "extend",
   "extends",
   "$router",
   "routes",
   "children",
+  "childExtend",
   "childExtends",
+  "childExtendRecursive",
   "childExtendsRecursive",
   "props",
   "if",
@@ -32,8 +35,8 @@ const DOMQ_PROPERTIES = [
   "on",
   "component",
   "context"
-];
-const PARSED_DOMQ_PROPERTIES = [
+]);
+const PARSED_DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
   "attr",
   "style",
   "text",
@@ -49,8 +52,9 @@ const PARSED_DOMQ_PROPERTIES = [
   "key",
   "tag",
   "query",
-  "on"
-];
+  "on",
+  "context"
+]);
 const STATE_PROPERTIES = [
   "ref",
   "parent",
@@ -60,7 +64,7 @@ const STATE_PROPERTIES = [
   "__children",
   "root"
 ];
-const STATE_METHODS = [
+const STATE_METHODS = /* @__PURE__ */ new Set([
   "update",
   "parse",
   "clean",
@@ -93,9 +97,9 @@ const STATE_METHODS = [
   "removeByPath",
   "removePathCollection",
   "getByPath"
-];
-const PROPS_METHODS = ["update", "__element"];
-const METHODS = [
+]);
+const PROPS_METHODS = /* @__PURE__ */ new Set(["update", "__element"]);
+const METHODS = /* @__PURE__ */ new Set([
   "set",
   "reset",
   "update",
@@ -121,15 +125,25 @@ const METHODS = [
   "error",
   "call",
   "nextElement",
-  "previousElement"
-];
-const METHODS_EXL = [
-  ...["node", "context", "extends", "__element", "__ref"],
+  "previousElement",
+  "getRootState",
+  "getRoot",
+  "getRootData",
+  "getRootContext",
+  "getContext",
+  "getChildren"
+]);
+const METHODS_EXL = /* @__PURE__ */ new Set([
+  "node",
+  "context",
+  "extends",
+  "__element",
+  "__ref",
   ...METHODS,
   ...STATE_METHODS,
   ...PROPS_METHODS
-];
-const DOMQL_EVENTS = [
+]);
+const DOMQL_EVENTS = /* @__PURE__ */ new Set([
   "init",
   "beforeClassAssign",
   "render",
@@ -145,7 +159,7 @@ const DOMQL_EVENTS = [
   "complete",
   "frame",
   "update"
-];
+]);
 export {
   DOMQL_EVENTS,
   DOMQ_PROPERTIES,

package/dist/esm/methods.js

@@ -1,19 +1,4 @@
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-import { triggerEventOn } from "@domql/event";
+import { triggerEventOn } from "./triggerEvent.js";
 import { DOMQ_PROPERTIES, METHODS, PARSED_DOMQ_PROPERTIES } from "./keys.js";
 import { isDefined, isFunction, isObject, isObjectLike } from "./types.js";
 import { deepClone } from "./object.js";
@@ -54,10 +39,9 @@ function lookup(param) {
   return parent;
 }
 function lookdown(param) {
-  var _a;
   const el = this;
   const { __ref: ref } = el;
-  const children = ref == null ? void 0 : ref.__children;
+  const children = ref?.__children;
   if (!children) return;
   for (let i = 0; i < children.length; i++) {
     const v = children[i];
@@ -69,15 +53,14 @@ function lookdown(param) {
         return childElem;
       }
     }
-    const lookdown2 = (_a = childElem == null ? void 0 : childElem.lookdown) == null ? void 0 : _a.call(childElem, param);
+    const lookdown2 = childElem?.lookdown?.(param);
     if (lookdown2) return lookdown2;
   }
 }
 function lookdownAll(param, results = []) {
-  var _a;
   const el = this;
   const { __ref: ref } = el;
-  const children = ref == null ? void 0 : ref.__children;
+  const children = ref?.__children;
   if (!children) return;
   for (let i = 0; i < children.length; i++) {
     const v = children[i];
@@ -87,14 +70,13 @@ function lookdownAll(param, results = []) {
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) results.push(childElem);
     }
-    (_a = childElem == null ? void 0 : childElem.lookdownAll) == null ? void 0 : _a.call(childElem, param, results);
+    childElem?.lookdownAll?.(param, results);
   }
   return results.length ? results : void 0;
 }
 function setNodeStyles(params = {}) {
-  var _a;
   const el = this;
-  if (!((_a = el.node) == null ? void 0 : _a.style)) return;
+  if (!el.node?.style) return;
   for (const param in params) {
     const value = params[param];
     const childElem = el[param];
@@ -142,14 +124,48 @@ function getChildren() {
 function getPath() {
   return this.getRef().path;
 }
+function getRootState(param) {
+  let state = null;
+  const hasRootState = (obj) => obj.__element && obj.root?.isRootState;
+  if (!this) {
+    state = window.platformState || window.smblsApp?.state;
+  } else if (hasRootState(this)) {
+    state = this.root;
+  } else if (this.__ref && this.__ref.path) {
+    const hasPlatformState = this.state && hasRootState(this.state);
+    const hasPlatformStateOnParent = isFunction(this.state) && this.parent.state && hasRootState(this.parent.state);
+    if (hasPlatformState || hasPlatformStateOnParent) {
+      state = this.state.root || this.parent.state.root;
+    }
+  }
+  if (!state) {
+    state = window.platformState || window.smblsApp?.state;
+  }
+  return param ? state?.[param] : state;
+}
+function getRoot(key) {
+  const rootElem = this.getRootState()?.__element;
+  return rootElem && Object.keys(rootElem).length > 0 && key ? rootElem[key] : rootElem;
+}
+function getRootData(key) {
+  return this.getRoot("data") && Object.keys(this.getRoot("data")).length > 0 && key ? this.getRoot("data")[key] : this.getRoot("data");
+}
+function getRootContext(key) {
+  const ctx = this.getRoot()?.context;
+  return key ? ctx[key] : ctx;
+}
+function getContext(key) {
+  const ctx = this.context;
+  return key ? ctx[key] : ctx;
+}
 const defineSetter = (element, key, get2, set) => Object.defineProperty(element, key, { get: get2, set });
 function keys() {
   const element = this;
   const keys2 = [];
   for (const param in element) {
     if (
-      // (REGISTRY[param] && !DOMQ_PROPERTIES.includes(param)) ||
-      !Object.hasOwnProperty.call(element, param) || DOMQ_PROPERTIES.includes(param) && !PARSED_DOMQ_PROPERTIES.includes(param)
+      // (REGISTRY[param] && !DOMQ_PROPERTIES.has(param)) ||
+      !Object.prototype.hasOwnProperty.call(element, param) || DOMQ_PROPERTIES.has(param) && !PARSED_DOMQ_PROPERTIES.has(param)
     ) {
       continue;
     }
@@ -162,24 +178,26 @@ function parse(excl = []) {
   const obj = {};
   const keyList = keys.call(element);
   const hasChildren = keyList.includes("children");
-  keyList.forEach((v) => {
-    if (excl.includes(v) || !Object.hasOwnProperty.call(element, v)) return;
-    if (hasChildren && v === "content") return;
+  const exclSet = excl.length ? new Set(excl) : null;
+  for (let i = 0; i < keyList.length; i++) {
+    const v = keyList[i];
+    if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+    if (hasChildren && v === "content") continue;
     const val = element[v];
     if (v === "state") {
-      if (element.__ref && !element.__ref.__hasRootState) return;
+      if (element.__ref && !element.__ref.__hasRootState) continue;
       const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
       obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
     } else if (v === "scope") {
-      if (element.__ref && !element.__ref.__hasRootScope) return;
+      if (element.__ref && !element.__ref.__hasRootScope) continue;
       obj[v] = JSON.parse(JSON.stringify(val || {}));
     } else if (v === "props") {
-      const _a = element[v], { __element, update } = _a, props = __objRest(_a, ["__element", "update"]);
+      const { __element, update, ...props } = element[v];
       obj[v] = props;
-    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v)) {
+    } else if (isDefined(val) && Object.prototype.hasOwnProperty.call(element, v)) {
       obj[v] = val;
     }
-  });
+  }
   return obj;
 }
 function parseDeep(excl = [], visited = /* @__PURE__ */ new WeakSet()) {
@@ -187,8 +205,9 @@ function parseDeep(excl = [], visited = /* @__PURE__ */ new WeakSet()) {
   if (visited.has(element)) return void 0;
   visited.add(element);
   const obj = parse.call(element, excl);
+  const exclSet = excl.length ? new Set(excl) : null;
   for (const v in obj) {
-    if (excl.includes(v) || !Object.hasOwnProperty.call(element, v)) continue;
+    if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
     const val = obj[v];
     if (Array.isArray(val)) {
       obj[v] = val.map(
@@ -228,10 +247,9 @@ function warn(...params) {
   }
 }
 function error(...params) {
-  var _a, _b;
   if (ENV === "test" || ENV === "development") {
-    if ((_a = params[params.length - 1]) == null ? void 0 : _a.debugger) debugger;
-    if ((_b = params[params.length - 1]) == null ? void 0 : _b.verbose) verbose.call(this);
+    if (params[params.length - 1]?.debugger) debugger;
+    if (params[params.length - 1]?.verbose) verbose.call(this);
     throw new Error(...params);
   }
 }
@@ -283,13 +301,11 @@ function variables(obj = {}) {
   };
 }
 function call(fnKey, ...args) {
-  var _a, _b, _c, _d, _e;
   const context = this.context;
-  return (_e = ((_a = context.utils) == null ? void 0 : _a[fnKey]) || ((_b = context.functions) == null ? void 0 : _b[fnKey]) || ((_c = context.methods) == null ? void 0 : _c[fnKey]) || ((_d = context.snippets) == null ? void 0 : _d[fnKey])) == null ? void 0 : _e.call(this, ...args);
+  return (context.utils?.[fnKey] || context.functions?.[fnKey] || context.methods?.[fnKey] || context.snippets?.[fnKey])?.call(this, ...args);
 }
 function isMethod(param, element) {
-  var _a, _b;
-  return Boolean(METHODS.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]));
+  return Boolean(METHODS.has(param) || element?.context?.methods?.[param]);
 }
 export {
   call,
@@ -297,8 +313,13 @@ export {
   error,
   get,
   getChildren,
+  getContext,
   getPath,
   getRef,
+  getRoot,
+  getRootContext,
+  getRootData,
+  getRootState,
   isMethod,
   keys,
   log,