@domql/utils 3.8.1 → 3.8.6

package/dist/cjs/if.js

@@ -22,9 +22,19 @@ __export(if_exports, {
 });
 module.exports = __toCommonJS(if_exports);
 var import_types = require("./types.js");
+var import_object = require("./object.js");
 const createIfConditionFlag = (element, parent) => {
   const { __ref: ref } = element;
-  if ((0, import_types.isFunction)(element.if) && !element.if(element, element.state, element.context)) {
-    delete ref.__if;
-  } else ref.__if = true;
+  const ifVal = element.if;
+  if ((0, import_types.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 = (0, import_object.exec)(ifVal, element);
+    if (!result) delete ref.__if;
+    else ref.__if = true;
+  } else {
+    ref.__if = true;
+  }
 };

package/dist/cjs/object.js

@@ -76,6 +76,17 @@ const exec = (param, element, state, context) => {
     }
     return result;
   }
+  if (param != null && element?.context?.plugins && ((0, import_types.isArray)(param) || (0, import_types.isObject)(param) && !(0, import_node.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, state, context);
+        }
+      }
+    }
+  }
   return param;
 };
 const map = (obj, extention, element) => {

package/dist/cjs/triggerEvent.js

@@ -48,13 +48,18 @@ const applyEvent = (param, element, state, context, options) => {
     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;
   }
 };

package/dist/esm/if.js

@@ -1,9 +1,19 @@
 import { isFunction } from "./types.js";
+import { exec } from "./object.js";
 const 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;
+  }
 };
 export {
   createIfConditionFlag

package/dist/esm/object.js

@@ -31,6 +31,17 @@ const exec = (param, element, state, context) => {
     }
     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, state, context);
+        }
+      }
+    }
+  }
   return param;
 };
 const map = (obj, extention, element) => {

package/dist/esm/triggerEvent.js

@@ -22,13 +22,18 @@ const applyEvent = (param, element, state, context, options) => {
     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;
   }
 };

package/dist/iife/index.js

@@ -31,8 +31,13 @@ var DomqlUtils = (() => {
   });
 
   // dist/esm/node.js
+  var isDOMNode2;
   var init_node = __esm({
     "dist/esm/node.js"() {
+      init_globals();
+      isDOMNode2 = (obj) => {
+        return typeof window3 !== "undefined" && (window3.Node && obj instanceof window3.Node || window3.Window && obj instanceof window3.Window || obj === window3 || obj === document);
+      };
     }
   });
 
@@ -155,6 +160,7 @@ var DomqlUtils = (() => {
   var init_object = __esm({
     "dist/esm/object.js"() {
       init_types();
+      init_node();
       exec2 = (param, element, state, context) => {
         if (isFunction2(param)) {
           if (!element) return;
@@ -173,6 +179,17 @@ var DomqlUtils = (() => {
           }
           return result;
         }
+        if (param != null && element?.context?.plugins && (isArray2(param) || isObject2(param) && !isDOMNode2(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 exec2(resolved, element, state, context);
+              }
+            }
+          }
+        }
         return param;
       };
     }
@@ -2296,6 +2313,17 @@ var DomqlUtils = (() => {
       }
       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, state, context);
+          }
+        }
+      }
+    }
     return param;
   };
   var map = (obj, extention, element) => {
@@ -2944,9 +2972,18 @@ var DomqlUtils = (() => {
   // if.js
   var 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;
+    }
   };
 
   // log.js
@@ -4152,13 +4189,18 @@ var DomqlUtils = (() => {
       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;
     }
   };

package/if.js

@@ -1,14 +1,22 @@
 'use strict'
 
 import { isFunction } from './types.js'
+import { exec } from './object.js'
 
 export const createIfConditionFlag = (element, parent) => {
   const { __ref: ref } = element
+  const ifVal = element.if
 
-  if (
-    isFunction(element.if) &&
-    !element.if(element, element.state, element.context)
-  ) {
-    delete ref.__if
-  } else ref.__if = true
+  if (isFunction(ifVal)) {
+    if (!ifVal(element, element.state, element.context)) {
+      delete ref.__if
+    } else ref.__if = true
+  } else if (ifVal != null && typeof ifVal === 'object') {
+    // funcql schema — evaluate via exec() which delegates to plugins
+    const result = exec(ifVal, element)
+    if (!result) delete ref.__if
+    else ref.__if = true
+  } else {
+    ref.__if = true
+  }
 }

package/object.js

@@ -36,6 +36,22 @@ export const exec = (param, element, state, context) => {
     }
     return result
   }
+  // If param is a non-function value and the context has handler-resolving
+  // plugins (e.g. funcql), try to resolve it into a callable function.
+  // This enables funcql schemas as property values (text, if, style, etc.).
+  // Only attempt for array/object params that could be schemas — skip
+  // primitives and DOM nodes to avoid overhead on normal DOMQL values.
+  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, state, context)
+        }
+      }
+    }
+  }
   return param
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/utils",
-  "version": "3.8.1",
+  "version": "3.8.6",
   "license": "CC-BY-NC-4.0",
   "type": "module",
   "module": "./dist/esm/index.js",
@@ -38,7 +38,7 @@
   },
   "gitHead": "9fc1b79b41cdc725ca6b24aec64920a599634681",
   "peerDependencies": {
-    "@symbo.ls/fetch": "^3.8.1"
+    "@symbo.ls/fetch": "^3.8.6"
   },
   "peerDependenciesMeta": {
     "@symbo.ls/fetch": {

package/triggerEvent.js

@@ -26,13 +26,20 @@ export const applyEvent = (param, element, state, context, options) => {
     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)
+    // In SSR/brender mode, ReferenceErrors for missing client-only helpers
+    // are expected (e.g. DOM animation functions). Log concisely.
+    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
   }
 }