@domql/event 3.0.6 → 3.1.1

package/animationFrame.js

@@ -27,10 +27,12 @@ export const applyAnimationFrame = element => {
   if (!element) {
     throw new Error('Element is invalid')
   }
-  const { props, on, __ref: ref } = element
+  const { on, props, __ref: ref } = element
   if (!ref.root || !ref.root.data) return
   const { frameListeners } = ref.root.data
-  if (frameListeners && (on?.frame || props?.onFrame)) {
+
+  // Register if any of the frame handlers exists
+  if (frameListeners && (on?.frame || element.onFrame || props?.onFrame)) {
     registerFrameListener(element)
   }
 }
@@ -45,11 +47,18 @@ export const initAnimationFrame = () => {
         frameListeners.delete(element) // Remove if node has no parent
       } else {
         try {
-          ;(element.on?.frame || element.props.onFrame)(
-            element,
-            element.state,
-            element.context
-          )
+          // First try to use on.frame if available
+          if (element.on?.frame) {
+            element.on.frame(element, element.state, element.context)
+          }
+          // Then try element.onFrame (direct property)
+          else if (element.onFrame) {
+            element.onFrame(element, element.state, element.context)
+          }
+          // Lastly check props.onFrame
+          else if (element.props?.onFrame) {
+            element.props.onFrame(element, element.state, element.context)
+          }
         } catch (e) {
           console.warn(e)
         }

package/dist/cjs/animationFrame.js

@@ -43,28 +43,29 @@ const applyAnimationFrame = (element) => {
   if (!element) {
     throw new Error("Element is invalid");
   }
-  const { props, on, __ref: ref } = element;
+  const { on, props, __ref: ref } = element;
   if (!ref.root || !ref.root.data) return;
   const { frameListeners } = ref.root.data;
-  if (frameListeners && ((on == null ? void 0 : on.frame) || (props == null ? void 0 : props.onFrame))) {
+  if (frameListeners && ((on == null ? void 0 : on.frame) || element.onFrame || (props == null ? void 0 : props.onFrame))) {
     registerFrameListener(element);
   }
 };
 const initAnimationFrame = () => {
   const frameListeners = /* @__PURE__ */ new Set();
   function requestFrame() {
-    var _a;
+    var _a, _b;
     for (const element of frameListeners) {
       if (!element.parent.node.contains(element.node)) {
         frameListeners.delete(element);
       } else {
         try {
-          ;
-          (((_a = element.on) == null ? void 0 : _a.frame) || element.props.onFrame)(
-            element,
-            element.state,
-            element.context
-          );
+          if ((_a = element.on) == null ? void 0 : _a.frame) {
+            element.on.frame(element, element.state, element.context);
+          } else if (element.onFrame) {
+            element.onFrame(element, element.state, element.context);
+          } else if ((_b = element.props) == null ? void 0 : _b.onFrame) {
+            element.props.onFrame(element, element.state, element.context);
+          }
         } catch (e) {
           console.warn(e);
         }

package/dist/cjs/globals.js

@@ -0,0 +1,30 @@
+"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 globals_exports = {};
+__export(globals_exports, {
+  document: () => document,
+  global: () => global,
+  self: () => self,
+  window: () => window
+});
+module.exports = __toCommonJS(globals_exports);
+const global = globalThis;
+const self = globalThis;
+const window = globalThis;
+const document = window.document;

package/dist/cjs/keys.js

@@ -0,0 +1,178 @@
+"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 keys_exports = {};
+__export(keys_exports, {
+  DOMQL_EVENTS: () => DOMQL_EVENTS,
+  DOMQ_PROPERTIES: () => DOMQ_PROPERTIES,
+  METHODS: () => METHODS,
+  METHODS_EXL: () => METHODS_EXL,
+  PARSED_DOMQ_PROPERTIES: () => PARSED_DOMQ_PROPERTIES,
+  PROPS_METHODS: () => PROPS_METHODS,
+  STATE_METHODS: () => STATE_METHODS,
+  STATE_PROPERTIES: () => STATE_PROPERTIES
+});
+module.exports = __toCommonJS(keys_exports);
+const DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "classlist",
+  "state",
+  "scope",
+  "deps",
+  "extends",
+  "$router",
+  "routes",
+  "children",
+  "childExtends",
+  "childExtendsRecursive",
+  "props",
+  "if",
+  "define",
+  "__name",
+  "__ref",
+  "__hash",
+  "__text",
+  "key",
+  "tag",
+  "query",
+  "parent",
+  "node",
+  "variables",
+  "on",
+  "component",
+  "context"
+];
+const PARSED_DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "class",
+  "state",
+  "scope",
+  "children",
+  "props",
+  "if",
+  "key",
+  "tag",
+  "query",
+  "on",
+  "context"
+];
+const STATE_PROPERTIES = [
+  "ref",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root"
+];
+const STATE_METHODS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+const PROPS_METHODS = ["update", "__element"];
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "previousElement"
+];
+const METHODS_EXL = [
+  ...["node", "context", "extends", "__element", "__ref"],
+  ...METHODS,
+  ...STATE_METHODS,
+  ...PROPS_METHODS
+];
+const DOMQL_EVENTS = [
+  "init",
+  "beforeClassAssign",
+  "render",
+  "renderRouter",
+  "attachNode",
+  "stateInit",
+  "stateCreated",
+  "beforeStateUpdate",
+  "stateUpdate",
+  "beforeUpdate",
+  "done",
+  "create",
+  "complete",
+  "frame",
+  "update"
+];

package/dist/cjs/node.js

@@ -0,0 +1,35 @@
+"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 node_exports = {};
+__export(node_exports, {
+  isDOMNode: () => isDOMNode,
+  isHtmlElement: () => isHtmlElement,
+  isNode: () => isNode
+});
+module.exports = __toCommonJS(node_exports);
+var import_globals = require("./globals.js");
+const isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof import_globals.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+const isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof import_globals.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+const isDOMNode = (obj) => {
+  return typeof import_globals.window !== "undefined" && (obj instanceof import_globals.window.Node || obj instanceof import_globals.window.Window || obj === import_globals.window || obj === document);
+};

package/dist/cjs/on.js

@@ -25,7 +25,8 @@ __export(on_exports, {
   triggerEventOnUpdate: () => triggerEventOnUpdate
 });
 module.exports = __toCommonJS(on_exports);
-var import_utils = require("@domql/utils");
+var import_keys = require("./keys.js");
+var import_types = require("./types.js");
 const getOnOrPropsEvent = (param, element) => {
   var _a, _b;
   const onEvent = (_a = element.on) == null ? void 0 : _a[param];
@@ -33,7 +34,7 @@ const getOnOrPropsEvent = (param, element) => {
   return onEvent || onPropEvent;
 };
 const applyEvent = async (param, element, state, context, options) => {
-  if (!(0, import_utils.isFunction)(param)) return;
+  if (!(0, import_types.isFunction)(param)) return;
   return await param.call(
     element,
     element,
@@ -53,7 +54,7 @@ const triggerEventOn = async (param, element, options) => {
   }
 };
 const applyEventUpdate = async (param, updatedObj, element, state, context, options) => {
-  if (!(0, import_utils.isFunction)(param)) return;
+  if (!(0, import_types.isFunction)(param)) return;
   return await param.call(
     element,
     updatedObj,
@@ -80,9 +81,9 @@ const triggerEventOnUpdate = async (param, updatedObj, element, options) => {
 const applyEventsOnNode = (element, options) => {
   const { node, on } = element;
   for (const param in on) {
-    if (import_utils.DOMQL_EVENTS.includes(param)) continue;
+    if (import_keys.DOMQL_EVENTS.includes(param)) continue;
     const appliedFunction = getOnOrPropsEvent(param, element);
-    if ((0, import_utils.isFunction)(appliedFunction)) {
+    if ((0, import_types.isFunction)(appliedFunction)) {
       node.addEventListener(param, async (event) => {
         const { state, context } = element;
         await appliedFunction.call(

package/dist/cjs/types.js

@@ -0,0 +1,82 @@
+"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 types_exports = {};
+__export(types_exports, {
+  TYPES: () => TYPES,
+  is: () => is,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isDefined: () => isDefined,
+  isFunction: () => isFunction,
+  isNot: () => isNot,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isString: () => isString,
+  isUndefined: () => isUndefined
+});
+module.exports = __toCommonJS(types_exports);
+var import_node = require("./node.js");
+const isObject = (arg) => {
+  if (arg === null) return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isString = (arg) => typeof arg === "string";
+const isNumber = (arg) => typeof arg === "number";
+const isFunction = (arg) => typeof arg === "function";
+const isBoolean = (arg) => arg === true || arg === false;
+const isNull = (arg) => arg === null;
+const isArray = (arg) => Array.isArray(arg);
+const isDate = (d) => d instanceof Date;
+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 TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  date: isDate,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: import_node.isNode,
+  htmlElement: import_node.isHtmlElement,
+  defined: isDefined
+};
+const is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+const isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};

package/dist/esm/animationFrame.js

@@ -18,28 +18,29 @@ const applyAnimationFrame = (element) => {
   if (!element) {
     throw new Error("Element is invalid");
   }
-  const { props, on, __ref: ref } = element;
+  const { on, props, __ref: ref } = element;
   if (!ref.root || !ref.root.data) return;
   const { frameListeners } = ref.root.data;
-  if (frameListeners && ((on == null ? void 0 : on.frame) || (props == null ? void 0 : props.onFrame))) {
+  if (frameListeners && ((on == null ? void 0 : on.frame) || element.onFrame || (props == null ? void 0 : props.onFrame))) {
     registerFrameListener(element);
   }
 };
 const initAnimationFrame = () => {
   const frameListeners = /* @__PURE__ */ new Set();
   function requestFrame() {
-    var _a;
+    var _a, _b;
     for (const element of frameListeners) {
       if (!element.parent.node.contains(element.node)) {
         frameListeners.delete(element);
       } else {
         try {
-          ;
-          (((_a = element.on) == null ? void 0 : _a.frame) || element.props.onFrame)(
-            element,
-            element.state,
-            element.context
-          );
+          if ((_a = element.on) == null ? void 0 : _a.frame) {
+            element.on.frame(element, element.state, element.context);
+          } else if (element.onFrame) {
+            element.onFrame(element, element.state, element.context);
+          } else if ((_b = element.props) == null ? void 0 : _b.onFrame) {
+            element.props.onFrame(element, element.state, element.context);
+          }
         } catch (e) {
           console.warn(e);
         }

package/dist/esm/globals.js

@@ -0,0 +1,10 @@
+const global = globalThis;
+const self = globalThis;
+const window = globalThis;
+const document = window.document;
+export {
+  document,
+  global,
+  self,
+  window
+};

package/dist/esm/keys.js

@@ -0,0 +1,158 @@
+const DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "classlist",
+  "state",
+  "scope",
+  "deps",
+  "extends",
+  "$router",
+  "routes",
+  "children",
+  "childExtends",
+  "childExtendsRecursive",
+  "props",
+  "if",
+  "define",
+  "__name",
+  "__ref",
+  "__hash",
+  "__text",
+  "key",
+  "tag",
+  "query",
+  "parent",
+  "node",
+  "variables",
+  "on",
+  "component",
+  "context"
+];
+const PARSED_DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "class",
+  "state",
+  "scope",
+  "children",
+  "props",
+  "if",
+  "key",
+  "tag",
+  "query",
+  "on",
+  "context"
+];
+const STATE_PROPERTIES = [
+  "ref",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root"
+];
+const STATE_METHODS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+const PROPS_METHODS = ["update", "__element"];
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "previousElement"
+];
+const METHODS_EXL = [
+  ...["node", "context", "extends", "__element", "__ref"],
+  ...METHODS,
+  ...STATE_METHODS,
+  ...PROPS_METHODS
+];
+const DOMQL_EVENTS = [
+  "init",
+  "beforeClassAssign",
+  "render",
+  "renderRouter",
+  "attachNode",
+  "stateInit",
+  "stateCreated",
+  "beforeStateUpdate",
+  "stateUpdate",
+  "beforeUpdate",
+  "done",
+  "create",
+  "complete",
+  "frame",
+  "update"
+];
+export {
+  DOMQL_EVENTS,
+  DOMQ_PROPERTIES,
+  METHODS,
+  METHODS_EXL,
+  PARSED_DOMQ_PROPERTIES,
+  PROPS_METHODS,
+  STATE_METHODS,
+  STATE_PROPERTIES
+};

package/dist/esm/node.js

@@ -0,0 +1,15 @@
+import { window } from "./globals.js";
+const isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+const isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+const isDOMNode = (obj) => {
+  return typeof window !== "undefined" && (obj instanceof window.Node || obj instanceof window.Window || obj === window || obj === document);
+};
+export {
+  isDOMNode,
+  isHtmlElement,
+  isNode
+};

package/dist/esm/on.js

@@ -1,4 +1,5 @@
-import { DOMQL_EVENTS, isFunction } from "@domql/utils";
+import { DOMQL_EVENTS } from "./keys.js";
+import { isFunction } from "./types.js";
 const getOnOrPropsEvent = (param, element) => {
   var _a, _b;
   const onEvent = (_a = element.on) == null ? void 0 : _a[param];

package/dist/esm/types.js

@@ -0,0 +1,62 @@
+import { isHtmlElement, isNode } from "./node.js";
+const isObject = (arg) => {
+  if (arg === null) return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isString = (arg) => typeof arg === "string";
+const isNumber = (arg) => typeof arg === "number";
+const isFunction = (arg) => typeof arg === "function";
+const isBoolean = (arg) => arg === true || arg === false;
+const isNull = (arg) => arg === null;
+const isArray = (arg) => Array.isArray(arg);
+const isDate = (d) => d instanceof Date;
+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 TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  date: isDate,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+};
+const is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+const isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};
+export {
+  TYPES,
+  is,
+  isArray,
+  isBoolean,
+  isDate,
+  isDefined,
+  isFunction,
+  isNot,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined
+};

package/globals.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const global = globalThis
+const self = globalThis
+const window = globalThis
+const document = (this || window).document // eslint-disable-line
+
+export { global, self, window, document }

package/keys.js

@@ -0,0 +1,157 @@
+'use strict'
+
+export const DOMQ_PROPERTIES = [
+  'attr',
+  'style',
+  'text',
+  'html',
+  'content',
+  'data',
+  'classlist',
+  'state',
+  'scope',
+  'deps',
+  'extends',
+  '$router',
+  'routes',
+  'children',
+  'childExtends',
+  'childExtendsRecursive',
+  'props',
+  'if',
+  'define',
+  '__name',
+  '__ref',
+  '__hash',
+  '__text',
+  'key',
+  'tag',
+  'query',
+  'parent',
+  'node',
+  'variables',
+  'on',
+  'component',
+  'context'
+]
+
+export const PARSED_DOMQ_PROPERTIES = [
+  'attr',
+  'style',
+  'text',
+  'html',
+  'content',
+  'data',
+  'class',
+  'state',
+  'scope',
+  'children',
+  'props',
+  'if',
+  'key',
+  'tag',
+  'query',
+  'on',
+  'context'
+]
+
+export const STATE_PROPERTIES = [
+  'ref',
+  'parent',
+  '__element',
+  '__depends',
+  '__ref',
+  '__children',
+  'root'
+]
+
+export const STATE_METHODS = [
+  'update',
+  'parse',
+  'clean',
+  'create',
+  'destroy',
+  'add',
+  'toggle',
+  'remove',
+  'apply',
+  'set',
+  'reset',
+  'replace',
+  'quietReplace',
+  'quietUpdate',
+  'applyReplace',
+  'applyFunction',
+  'keys',
+  'values',
+  'ref',
+  'rootUpdate',
+  'parentUpdate',
+  'parent',
+  '__element',
+  '__depends',
+  '__ref',
+  '__children',
+  'root',
+  'setByPath',
+  'setPathCollection',
+  'removeByPath',
+  'removePathCollection',
+  'getByPath'
+]
+
+export const PROPS_METHODS = ['update', '__element']
+
+export const METHODS = [
+  'set',
+  'reset',
+  'update',
+  'remove',
+  'updateContent',
+  'removeContent',
+  'lookup',
+  'lookdown',
+  'lookdownAll',
+  'getRef',
+  'getPath',
+  'setNodeStyles',
+  'spotByPath',
+  'keys',
+  'parse',
+  'setProps',
+  'parseDeep',
+  'variables',
+  'if',
+  'log',
+  'verbose',
+  'warn',
+  'error',
+  'call',
+  'nextElement',
+  'previousElement'
+]
+
+export const METHODS_EXL = [
+  ...['node', 'context', 'extends', '__element', '__ref'],
+  ...METHODS,
+  ...STATE_METHODS,
+  ...PROPS_METHODS
+]
+
+export const DOMQL_EVENTS = [
+  'init',
+  'beforeClassAssign',
+  'render',
+  'renderRouter',
+  'attachNode',
+  'stateInit',
+  'stateCreated',
+  'beforeStateUpdate',
+  'stateUpdate',
+  'beforeUpdate',
+  'done',
+  'create',
+  'complete',
+  'frame',
+  'update'
+]

package/node.js

@@ -0,0 +1,37 @@
+'use strict'
+
+import { window } from './globals.js'
+
+export const isNode = obj => {
+  return (
+    (typeof Node === 'object'
+      ? obj instanceof window.Node
+      : obj &&
+        typeof obj === 'object' &&
+        typeof obj.nodeType === 'number' &&
+        typeof obj.nodeName === 'string') || false
+  )
+}
+
+// Returns true if it is a DOM element
+export const isHtmlElement = obj => {
+  return (
+    (typeof HTMLElement === 'object'
+      ? obj instanceof window.HTMLElement // DOM2
+      : obj &&
+        typeof obj === 'object' &&
+        obj !== null &&
+        obj.nodeType === 1 &&
+        typeof obj.nodeName === 'string') || false
+  )
+}
+
+export const isDOMNode = obj => {
+  return (
+    typeof window !== 'undefined' &&
+    (obj instanceof window.Node ||
+      obj instanceof window.Window ||
+      obj === window ||
+      obj === document)
+  )
+}

package/on.js

@@ -1,6 +1,7 @@
 'use strict'
 
-import { DOMQL_EVENTS, isFunction } from '@domql/utils'
+import { DOMQL_EVENTS } from './keys.js'
+import { isFunction } from './types.js'
 
 const getOnOrPropsEvent = (param, element) => {
   const onEvent = element.on?.[param]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/event",
-  "version": "3.0.6",
+  "version": "3.1.1",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -24,12 +24,12 @@
     "build:esm": "npx esbuild *.js --target=es2017 --format=esm --outdir=dist/esm",
     "build:cjs": "npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs",
     "build:iife": "npx esbuild *.js --target=node16 --format=iife --outdir=dist/iife",
-    "build": "rimraf -I dist; npm run build:cjs; npm run build:esm",
+    "build": "npx rimraf -I dist; npm run build:cjs; npm run build:esm",
     "prepublish": "npm run build; npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/report": "^3.0.0",
-    "@domql/utils": "^3.0.6"
+    "@domql/report": "^3.1.1",
+    "@domql/utils": "^3.1.1"
   },
-  "gitHead": "ef6f7abdb0a8cdaa28559e377bc10a12e76ef8f0"
+  "gitHead": "39fb7a8c07355468ccce79e2f787ca3fa0715692"
 }

package/types.js

@@ -0,0 +1,72 @@
+'use strict'
+
+import { isHtmlElement, isNode } from './node.js'
+
+export const isObject = arg => {
+  if (arg === null) return false
+  return (typeof arg === 'object') && (arg.constructor === Object)
+}
+
+export const isString = arg => typeof arg === 'string'
+
+export const isNumber = arg => typeof arg === 'number'
+
+export const isFunction = arg => typeof arg === 'function'
+
+export const isBoolean = arg => arg === true || arg === false
+
+export const isNull = arg => arg === null
+
+export const isArray = arg => Array.isArray(arg)
+
+export const isDate = d => d instanceof Date
+
+export const isObjectLike = arg => {
+  if (arg === null) return false
+  // if (isArray(arg)) return false
+  return (typeof arg === 'object')
+}
+
+export const isDefined = arg => {
+  return isObject(arg) ||
+    isObjectLike(arg) ||
+    isString(arg) ||
+    isNumber(arg) ||
+    isFunction(arg) ||
+    isArray(arg) ||
+    isObjectLike(arg) ||
+    isBoolean(arg) ||
+    isDate(arg) ||
+    isNull(arg)
+}
+
+export const isUndefined = arg => {
+  return arg === undefined
+}
+
+export const TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  date: isDate,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+}
+
+export const is = (arg) => {
+  return (...args) => {
+    return args.map(val => TYPES[val](arg)).filter(v => v).length > 0
+  }
+}
+
+export const isNot = (arg) => {
+  return (...args) => {
+    return args.map(val => TYPES[val](arg)).filter(v => v).length === 0
+  }
+}