domql 3.8.0 → 3.8.6

package/dist/iife/index.js

@@ -352,6 +352,17 @@ var Domql = (() => {
           }
           return result;
         }
+        if (param != null && element?.context?.plugins && (isArray(param) || isObject(param) && !isDOMNode(param))) {
+          const plugins = element.context.plugins;
+          for (const plugin of plugins) {
+            if (plugin.resolveHandler) {
+              const resolved = plugin.resolveHandler(param, element);
+              if (typeof resolved === "function") {
+                return exec(resolved, element, state2, context);
+              }
+            }
+          }
+        }
         return param;
       };
       merge = (element, obj, excludeFrom = []) => {
@@ -671,11 +682,21 @@ var Domql = (() => {
   var init_if = __esm({
     "../utils/dist/esm/if.js"() {
       init_types();
+      init_object();
       createIfConditionFlag = (element, parent) => {
         const { __ref: ref } = element;
-        if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
-          delete ref.__if;
-        } else ref.__if = true;
+        const ifVal = element.if;
+        if (isFunction(ifVal)) {
+          if (!ifVal(element, element.state, element.context)) {
+            delete ref.__if;
+          } else ref.__if = true;
+        } else if (ifVal != null && typeof ifVal === "object") {
+          const result = exec(ifVal, element);
+          if (!result) delete ref.__if;
+          else ref.__if = true;
+        } else {
+          ref.__if = true;
+        }
       };
     }
   });
@@ -1335,7 +1356,7 @@ var Domql = (() => {
       const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key) || looksLikeElement(value);
       const isBuiltin = DOMQ_PROPERTIES.has(key);
       if (!isElement && !isBuiltin) {
-        obj.props[key] = value;
+        if (!(key in obj.props)) obj.props[key] = value;
         delete obj[key];
         cachedKeys.push(key);
       }
@@ -1863,13 +1884,18 @@ var Domql = (() => {
           if (result && typeof result.then === "function") {
             result.catch((err) => {
               element.error = err;
-              console.error("[DOMQL] Async event error:", err);
+              if (err instanceof ReferenceError) console.warn("[DOMQL] Async event warning:", err.message);
+              else console.error("[DOMQL] Async event error:", err);
             });
           }
           return result;
         } catch (err) {
           element.error = err;
-          console.error("[DOMQL] Event handler error:", err);
+          if (err instanceof ReferenceError) {
+            console.warn("[DOMQL] Event handler warning:", err.message);
+          } else {
+            console.error("[DOMQL] Event handler error:", err);
+          }
           if (element.context?.strictMode) throw err;
         }
       };
@@ -2605,6 +2631,7 @@ var Domql = (() => {
           const session = await adapter.getSession();
           updateAuth(session?.user || null, session);
         } catch (e) {
+          console.warn("[fetch] Failed to restore auth session:", e.message);
         }
         if (adapter.onAuthStateChange) {
           adapter.onAuthStateChange((event, session) => {
@@ -6435,7 +6462,18 @@ ${element}` : "";
     "onfullscreenchange",
     "onfullscreenerror"
   ];
+  var camelToAttr = (key) => {
+    if (key.startsWith("aria") && key.length > 4 && key.charCodeAt(4) >= 65 && key.charCodeAt(4) <= 90) {
+      return "aria-" + key.charAt(4).toLowerCase() + key.slice(5).replace(/([A-Z])/g, (m) => "-" + m.toLowerCase());
+    }
+    if (key.startsWith("data") && key.length > 4 && key.charCodeAt(4) >= 65 && key.charCodeAt(4) <= 90) {
+      return "data-" + key.charAt(4).toLowerCase() + key.slice(5).replace(/([A-Z])/g, (m) => "-" + m.toLowerCase());
+    }
+    return null;
+  };
   var checkAttributeByTagName = (tag, attribute) => {
+    if (attribute.startsWith("aria-") || attribute.startsWith("data-")) return true;
+    if (camelToAttr(attribute)) return true;
     if (Object.prototype.hasOwnProperty.call(HTML_ATTRIBUTES, tag)) {
       const attributes = HTML_ATTRIBUTES[tag];
       return attributes.includes(attribute) || attributes.includes("default");
@@ -6454,25 +6492,139 @@ ${element}` : "";
     for (const key in props) {
       if (Object.prototype.hasOwnProperty.call(props, key)) {
         if (cssProps && key in cssProps) continue;
+        if (key === "aria" && props[key] && typeof props[key] === "object") {
+          for (const ariaKey in props[key]) {
+            if (isDefined(props[key][ariaKey])) {
+              filteredObject["aria-" + ariaKey] = props[key][ariaKey];
+            }
+          }
+          continue;
+        }
+        if (key === "data" && props[key] && typeof props[key] === "object") {
+          for (const dataKey in props[key]) {
+            if (isDefined(props[key][dataKey])) {
+              const kebab = dataKey.replace(/([A-Z])/g, (m) => "-" + m.toLowerCase());
+              filteredObject["data-" + kebab] = props[key][dataKey];
+            }
+          }
+          continue;
+        }
         const isAttribute = checkAttributeByTagName(tag, key);
         const isEvent = checkEventFunctions(key);
         if (isDefined(props[key]) && (isAttribute || isEvent)) {
-          filteredObject[key] = props[key];
+          const attrName = camelToAttr(key) || key;
+          filteredObject[attrName] = props[key];
         }
       }
     }
     return filteredObject;
   };
+  var resolvePropValue = (el, value) => {
+    let resolved = el.call("exec", value, el);
+    if (!resolved) return;
+    if (isString(resolved) && resolved.includes("{{")) {
+      resolved = el.call("replaceLiteralsWithObjectFields", resolved);
+    }
+    return resolved;
+  };
+  var resolveFileSource = (el, value) => {
+    let src = (el.props.preSrc || "") + (resolvePropValue(el, value) || "");
+    if (!src) return;
+    try {
+      new URL(src);
+      return src;
+    } catch (e) {
+    }
+    const { context } = el;
+    if (!context.files) return src;
+    const fileSrc = src.startsWith("/files/") ? src.slice(7) : src;
+    const file = context.files[src] || context.files[fileSrc];
+    if (file && file.content) return file.content.src;
+    return src;
+  };
+  var ATTR_TRANSFORMS = {
+    src: (el) => resolveFileSource(el, el.props.src),
+    href: (el) => resolvePropValue(el, el.props.href),
+    action: (el) => resolvePropValue(el, el.props.action),
+    poster: (el) => resolveFileSource(el, el.props.poster),
+    data: (el) => resolvePropValue(el, el.props.data)
+  };
+  var resolveCase = (caseKey, element) => {
+    const caseFn = element.context?.cases?.[caseKey];
+    if (caseFn === void 0) return void 0;
+    if (isFunction(caseFn)) return caseFn.call(element, element);
+    return !!caseFn;
+  };
+  var evaluateCondition = (prefix, caseKey, element) => {
+    if (prefix === "$") {
+      let result = resolveCase(caseKey, element);
+      if (result === void 0) result = !!element.props?.[caseKey];
+      return result;
+    }
+    let isTruthy = element.props[caseKey] === true || element.state[caseKey] || element[caseKey];
+    if (!isTruthy) {
+      const caseResult = resolveCase(caseKey, element);
+      if (caseResult !== void 0) isTruthy = caseResult;
+    }
+    return prefix === "." ? !!isTruthy : !isTruthy;
+  };
+  var CONDITIONAL_PREFIXES = /* @__PURE__ */ new Set(["$", ".", "!"]);
+  var extractConditionalAttrs = (props, tag, cssProps) => {
+    const result = {};
+    const addConditionalAttr = (attrName, attrVal, prefix, caseKey) => {
+      const capturedVal = attrVal;
+      result[attrName] = (el) => {
+        if (!evaluateCondition(prefix, caseKey, el)) return void 0;
+        return isFunction(capturedVal) ? capturedVal(el) : capturedVal;
+      };
+    };
+    for (const key in props) {
+      const prefix = key.charAt(0);
+      if (!CONDITIONAL_PREFIXES.has(prefix)) continue;
+      const block = props[key];
+      if (!block || typeof block !== "object") continue;
+      const caseKey = key.slice(1);
+      for (const attrKey in block) {
+        if (cssProps && attrKey in cssProps) continue;
+        if (attrKey === "aria" && block[attrKey] && typeof block[attrKey] === "object") {
+          for (const ariaKey in block[attrKey]) {
+            addConditionalAttr("aria-" + ariaKey, block[attrKey][ariaKey], prefix, caseKey);
+          }
+          continue;
+        }
+        if (attrKey === "data" && block[attrKey] && typeof block[attrKey] === "object") {
+          for (const dataKey in block[attrKey]) {
+            const kebab = dataKey.replace(/([A-Z])/g, (m) => "-" + m.toLowerCase());
+            addConditionalAttr("data-" + kebab, block[attrKey][dataKey], prefix, caseKey);
+          }
+          continue;
+        }
+        const isAttribute = checkAttributeByTagName(tag, attrKey);
+        const isEvent = checkEventFunctions(attrKey);
+        if (!isAttribute && !isEvent) continue;
+        const attrName = camelToAttr(attrKey) || attrKey;
+        addConditionalAttr(attrName, block[attrKey], prefix, caseKey);
+      }
+    }
+    return result;
+  };
 
   // ../element/dist/esm/create.js
   var EXCLUDED_ATTRS = /* @__PURE__ */ new Set(["class", "style"]);
   var applyPropsAsAttrs = (element) => {
     const { tag, props, context } = element;
     if (!tag || !props) return;
-    const autoAttrs = filterAttributesByTagName(tag, props, context?.cssPropsRegistry);
+    const cssProps = context?.cssPropsRegistry;
+    const autoAttrs = filterAttributesByTagName(tag, props, cssProps);
+    const conditionalAttrs = extractConditionalAttrs(props, tag, cssProps);
     const filtered = {};
     for (const key in autoAttrs) {
-      if (!EXCLUDED_ATTRS.has(key)) filtered[key] = autoAttrs[key];
+      if (!EXCLUDED_ATTRS.has(key)) {
+        filtered[key] = ATTR_TRANSFORMS[key] ? ATTR_TRANSFORMS[key] : autoAttrs[key];
+      }
+    }
+    for (const key in conditionalAttrs) {
+      if (!EXCLUDED_ATTRS.has(key)) filtered[key] = conditionalAttrs[key];
     }
     let hasFiltered = false;
     for (const _k in filtered) {
@@ -6581,7 +6733,8 @@ ${element}` : "";
           isDemoComponent ? isDemoComponent + " " : "" + path.join(".")
         );
         element.verbose();
-        console.error("[DOMQL] Render error:", e);
+        if (e instanceof ReferenceError) console.warn("[DOMQL] Render warning:", e.message);
+        else console.error("[DOMQL] Render error:", e);
         if (element.on?.error) {
           element.on.error(e, element, element.state, element.context, options);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domql",
-  "version": "3.8.0",
+  "version": "3.8.6",
   "license": "CC-BY-NC-4.0",
   "type": "module",
   "module": "./dist/esm/index.js",
@@ -25,9 +25,9 @@
     "build:iife": "cross-env NODE_ENV=$NODE_ENV esbuild index.js --bundle --target=es2020 --format=iife --global-name=Domql --outfile=dist/iife/index.js --define:process.env.NODE_ENV=process.env.NODE_ENV"
   },
   "dependencies": {
-    "@domql/element": "^3.8.0",
-    "@domql/state": "^3.8.0",
-    "@domql/utils": "^3.8.0"
+    "@domql/element": "^3.8.6",
+    "@domql/state": "^3.8.6",
+    "@domql/utils": "^3.8.6"
   },
   "gitHead": "9fc1b79b41cdc725ca6b24aec64920a599634681",
   "browser": "./dist/esm/index.js",