@domql/event 2.5.200 → 3.0.1

package/animationFrame.js

@@ -1,7 +1,20 @@
 'use strict'
 
-export const registerFrameListener = (el) => {
+export const registerFrameListener = el => {
+  if (!el || !el.__ref) {
+    throw new Error('Element reference is invalid')
+  }
+
   const { __ref: ref } = el
+
+  if (!ref.root) {
+    throw new Error('Root reference is invalid')
+  }
+
+  if (!ref.root.data) {
+    throw new Error('Data are undefined')
+  }
+
   const { frameListeners } = ref.root.data
 
   // Check if frameListeners exists and the element is not already in the Set
@@ -10,15 +23,19 @@ export const registerFrameListener = (el) => {
   }
 }
 
-export const applyAnimationFrame = (element, options) => {
+export const applyAnimationFrame = element => {
+  if (!element) {
+    throw new Error('Element is invalid')
+  }
   const { props, on, __ref: ref } = element
+  if (!ref.root || !ref.root.data) return
   const { frameListeners } = ref.root.data
   if (frameListeners && (on?.frame || props?.onFrame)) {
     registerFrameListener(element)
   }
 }
 
-export const initAnimationFrame = (ctx) => {
+export const initAnimationFrame = () => {
   const frameListeners = new Set()
 
   function requestFrame () {
@@ -28,7 +45,11 @@ export const initAnimationFrame = (ctx) => {
         frameListeners.delete(element) // Remove if node has no parent
       } else {
         try {
-          (element.on.frame || element.props.onFrame)(element, element.state, element.context)
+          ;(element.on?.frame || element.props.onFrame)(
+            element,
+            element.state,
+            element.context
+          )
         } catch (e) {
           console.warn(e)
         }

package/dist/cjs/animationFrame.js

@@ -24,28 +24,47 @@ __export(animationFrame_exports, {
 });
 module.exports = __toCommonJS(animationFrame_exports);
 const registerFrameListener = (el) => {
+  if (!el || !el.__ref) {
+    throw new Error("Element reference is invalid");
+  }
   const { __ref: ref } = el;
+  if (!ref.root) {
+    throw new Error("Root reference is invalid");
+  }
+  if (!ref.root.data) {
+    throw new Error("Data are undefined");
+  }
   const { frameListeners } = ref.root.data;
   if (frameListeners && !frameListeners.has(el)) {
     frameListeners.add(el);
   }
 };
-const applyAnimationFrame = (element, options) => {
+const applyAnimationFrame = (element) => {
+  if (!element) {
+    throw new Error("Element is invalid");
+  }
   const { props, on, __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))) {
     registerFrameListener(element);
   }
 };
-const initAnimationFrame = (ctx) => {
+const initAnimationFrame = () => {
   const frameListeners = /* @__PURE__ */ new Set();
   function requestFrame() {
+    var _a;
     for (const element of frameListeners) {
       if (!element.parent.node.contains(element.node)) {
         frameListeners.delete(element);
       } else {
         try {
-          (element.on.frame || element.props.onFrame)(element, element.state, element.context);
+          ;
+          (((_a = element.on) == null ? void 0 : _a.frame) || element.props.onFrame)(
+            element,
+            element.state,
+            element.context
+          );
         } catch (e) {
           console.warn(e);
         }

package/dist/cjs/on.js

@@ -32,35 +32,67 @@ const getOnOrPropsEvent = (param, element) => {
   const onPropEvent = (_b = element.props) == null ? void 0 : _b["on" + param.slice(0, 1).toUpperCase() + param.slice(1)];
   return onEvent || onPropEvent;
 };
-const applyEvent = (param, element, state, context, options) => {
-  return param.call(element, element, state || element.state, context || element.context, options);
+const applyEvent = async (param, element, state, context, options) => {
+  if (!(0, import_utils.isFunction)(param)) return;
+  return await param.call(
+    element,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
 };
 const triggerEventOn = async (param, element, options) => {
+  if (!element) {
+    throw new Error("Element is required");
+  }
   const appliedFunction = getOnOrPropsEvent(param, element);
   if (appliedFunction) {
     const { state, context } = element;
     return await applyEvent(appliedFunction, element, state, context, options);
   }
 };
-const applyEventUpdate = (param, updatedObj, element, state, context, options) => {
-  return param.call(element, updatedObj, element, state || element.state, context || element.context, options);
+const applyEventUpdate = async (param, updatedObj, element, state, context, options) => {
+  if (!(0, import_utils.isFunction)(param)) return;
+  return await param.call(
+    element,
+    updatedObj,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
 };
 const triggerEventOnUpdate = async (param, updatedObj, element, options) => {
   const appliedFunction = getOnOrPropsEvent(param, element);
   if (appliedFunction) {
     const { state, context } = element;
-    return await applyEventUpdate(appliedFunction, updatedObj, element, state, context, options);
+    return await applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    );
   }
 };
 const applyEventsOnNode = (element, options) => {
   const { node, on } = element;
   for (const param in on) {
-    if (param === "init" || param === "beforeClassAssign" || param === "render" || param === "renderRouter" || param === "attachNode" || param === "stateInit" || param === "stateCreated" || param === "beforeStateUpdate" || param === "stateUpdate" || param === "beforeUpdate" || param === "done" || param === "create" || param === "complete" || param === "frame" || param === "update") continue;
+    if (import_utils.DOMQL_EVENTS.includes(param)) continue;
     const appliedFunction = getOnOrPropsEvent(param, element);
     if ((0, import_utils.isFunction)(appliedFunction)) {
       node.addEventListener(param, async (event) => {
         const { state, context } = element;
-        await appliedFunction.call(element, event, element, state, context, options);
+        await appliedFunction.call(
+          element,
+          event,
+          element,
+          state,
+          context,
+          options
+        );
       });
     }
   }

package/dist/esm/animationFrame.js

@@ -1,26 +1,45 @@
 const registerFrameListener = (el) => {
+  if (!el || !el.__ref) {
+    throw new Error("Element reference is invalid");
+  }
   const { __ref: ref } = el;
+  if (!ref.root) {
+    throw new Error("Root reference is invalid");
+  }
+  if (!ref.root.data) {
+    throw new Error("Data are undefined");
+  }
   const { frameListeners } = ref.root.data;
   if (frameListeners && !frameListeners.has(el)) {
     frameListeners.add(el);
   }
 };
-const applyAnimationFrame = (element, options) => {
+const applyAnimationFrame = (element) => {
+  if (!element) {
+    throw new Error("Element is invalid");
+  }
   const { props, on, __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))) {
     registerFrameListener(element);
   }
 };
-const initAnimationFrame = (ctx) => {
+const initAnimationFrame = () => {
   const frameListeners = /* @__PURE__ */ new Set();
   function requestFrame() {
+    var _a;
     for (const element of frameListeners) {
       if (!element.parent.node.contains(element.node)) {
         frameListeners.delete(element);
       } else {
         try {
-          (element.on.frame || element.props.onFrame)(element, element.state, element.context);
+          ;
+          (((_a = element.on) == null ? void 0 : _a.frame) || element.props.onFrame)(
+            element,
+            element.state,
+            element.context
+          );
         } catch (e) {
           console.warn(e);
         }

package/dist/esm/on.js

@@ -1,39 +1,71 @@
-import { isFunction } from "@domql/utils";
+import { DOMQL_EVENTS, isFunction } from "@domql/utils";
 const getOnOrPropsEvent = (param, element) => {
   var _a, _b;
   const onEvent = (_a = element.on) == null ? void 0 : _a[param];
   const onPropEvent = (_b = element.props) == null ? void 0 : _b["on" + param.slice(0, 1).toUpperCase() + param.slice(1)];
   return onEvent || onPropEvent;
 };
-const applyEvent = (param, element, state, context, options) => {
-  return param.call(element, element, state || element.state, context || element.context, options);
+const applyEvent = async (param, element, state, context, options) => {
+  if (!isFunction(param)) return;
+  return await param.call(
+    element,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
 };
 const triggerEventOn = async (param, element, options) => {
+  if (!element) {
+    throw new Error("Element is required");
+  }
   const appliedFunction = getOnOrPropsEvent(param, element);
   if (appliedFunction) {
     const { state, context } = element;
     return await applyEvent(appliedFunction, element, state, context, options);
   }
 };
-const applyEventUpdate = (param, updatedObj, element, state, context, options) => {
-  return param.call(element, updatedObj, element, state || element.state, context || element.context, options);
+const applyEventUpdate = async (param, updatedObj, element, state, context, options) => {
+  if (!isFunction(param)) return;
+  return await param.call(
+    element,
+    updatedObj,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  );
 };
 const triggerEventOnUpdate = async (param, updatedObj, element, options) => {
   const appliedFunction = getOnOrPropsEvent(param, element);
   if (appliedFunction) {
     const { state, context } = element;
-    return await applyEventUpdate(appliedFunction, updatedObj, element, state, context, options);
+    return await applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    );
   }
 };
 const applyEventsOnNode = (element, options) => {
   const { node, on } = element;
   for (const param in on) {
-    if (param === "init" || param === "beforeClassAssign" || param === "render" || param === "renderRouter" || param === "attachNode" || param === "stateInit" || param === "stateCreated" || param === "beforeStateUpdate" || param === "stateUpdate" || param === "beforeUpdate" || param === "done" || param === "create" || param === "complete" || param === "frame" || param === "update") continue;
+    if (DOMQL_EVENTS.includes(param)) continue;
     const appliedFunction = getOnOrPropsEvent(param, element);
     if (isFunction(appliedFunction)) {
       node.addEventListener(param, async (event) => {
         const { state, context } = element;
-        await appliedFunction.call(element, event, element, state, context, options);
+        await appliedFunction.call(
+          element,
+          event,
+          element,
+          state,
+          context,
+          options
+        );
       });
     }
   }

package/on.js

@@ -1,18 +1,29 @@
 'use strict'
 
-import { isFunction } from '@domql/utils'
+import { DOMQL_EVENTS, isFunction } from '@domql/utils'
 
 const getOnOrPropsEvent = (param, element) => {
   const onEvent = element.on?.[param]
-  const onPropEvent = element.props?.['on' + param.slice(0, 1).toUpperCase() + param.slice(1)]
+  const onPropEvent =
+    element.props?.['on' + param.slice(0, 1).toUpperCase() + param.slice(1)]
   return onEvent || onPropEvent
 }
 
-export const applyEvent = (param, element, state, context, options) => {
-  return param.call(element, element, state || element.state, context || element.context, options)
+export const applyEvent = async (param, element, state, context, options) => {
+  if (!isFunction(param)) return
+  return await param.call(
+    element,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  )
 }
 
 export const triggerEventOn = async (param, element, options) => {
+  if (!element) {
+    throw new Error('Element is required')
+  }
   const appliedFunction = getOnOrPropsEvent(param, element)
   if (appliedFunction) {
     const { state, context } = element
@@ -20,44 +31,62 @@ export const triggerEventOn = async (param, element, options) => {
   }
 }
 
-export const applyEventUpdate = (param, updatedObj, element, state, context, options) => {
-  return param.call(element, updatedObj, element, state || element.state, context || element.context, options)
+export const applyEventUpdate = async (
+  param,
+  updatedObj,
+  element,
+  state,
+  context,
+  options
+) => {
+  if (!isFunction(param)) return
+  return await param.call(
+    element,
+    updatedObj,
+    element,
+    state || element.state,
+    context || element.context,
+    options
+  )
 }
 
-export const triggerEventOnUpdate = async (param, updatedObj, element, options) => {
+export const triggerEventOnUpdate = async (
+  param,
+  updatedObj,
+  element,
+  options
+) => {
   const appliedFunction = getOnOrPropsEvent(param, element)
   if (appliedFunction) {
     const { state, context } = element
-    return await applyEventUpdate(appliedFunction, updatedObj, element, state, context, options)
+    return await applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    )
   }
 }
 
 export const applyEventsOnNode = (element, options) => {
   const { node, on } = element
   for (const param in on) {
-    if (
-      param === 'init' ||
-      param === 'beforeClassAssign' ||
-      param === 'render' ||
-      param === 'renderRouter' ||
-      param === 'attachNode' ||
-      param === 'stateInit' ||
-      param === 'stateCreated' ||
-      param === 'beforeStateUpdate' ||
-      param === 'stateUpdate' ||
-      param === 'beforeUpdate' ||
-      param === 'done' ||
-      param === 'create' ||
-      param === 'complete' ||
-      param === 'frame' ||
-      param === 'update'
-    ) continue
+    if (DOMQL_EVENTS.includes(param)) continue
 
     const appliedFunction = getOnOrPropsEvent(param, element)
     if (isFunction(appliedFunction)) {
       node.addEventListener(param, async event => {
         const { state, context } = element
-        await appliedFunction.call(element, event, element, state, context, options)
+        await appliedFunction.call(
+          element,
+          event,
+          element,
+          state,
+          context,
+          options
+        )
       })
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/event",
-  "version": "2.5.200",
+  "version": "3.0.1",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -28,8 +28,8 @@
     "prepublish": "npm run build; npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/report": "^2.5.186",
-    "@domql/utils": "^2.5.200"
+    "@domql/report": "^3.0.0",
+    "@domql/utils": "^3.0.1"
   },
-  "gitHead": "0afb63ec375f0526f47ff300885de393138b01e8"
+  "gitHead": "bdadc70a00c5ddde21ca889746bf28db0c3d7c2f"
 }

package/dist/cjs/legacy.js

@@ -1,65 +0,0 @@
-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 legacy_exports = {};
-__export(legacy_exports, {
-  createState: () => createState,
-  init: () => init,
-  propsUpdated: () => propsUpdated,
-  render: () => render,
-  update: () => update,
-  updateState: () => updateState,
-  updateStateInit: () => updateStateInit
-});
-module.exports = __toCommonJS(legacy_exports);
-var import_utils = require("@domql/utils");
-const init = (param, element, state) => {
-  param(element, state);
-};
-const render = (param, element, state) => {
-  param(element, state);
-};
-const createState = (state, element) => {
-  const { on, ...el } = element;
-  if (on && (0, import_utils.isFunction)(on.createState)) {
-    on.createState(state, el);
-  }
-};
-const updateStateInit = (changes, element) => {
-  const { state, on, ...el } = element;
-  if (on && (0, import_utils.isFunction)(on.updateStateInit)) {
-    on.updateStateInit(changes, state, el);
-  }
-};
-const updateState = (changes, element) => {
-  const { state, on } = element;
-  if (on && (0, import_utils.isFunction)(on.updateState)) {
-    on.updateState(changes, state, element);
-  }
-};
-const propsUpdated = (element) => {
-  const { props, state, on } = element;
-  if (on && (0, import_utils.isFunction)(on.propsUpdated)) {
-    on.propsUpdated(props, state, element);
-  }
-};
-const update = (params, element, state) => {
-  if (element.on && (0, import_utils.isFunction)(element.on.update)) {
-    element.on.update(element, state);
-  }
-  return params;
-};

package/dist/esm/legacy.js

@@ -1,61 +0,0 @@
-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 { isFunction } from "@domql/utils";
-const init = (param, element, state) => {
-  param(element, state);
-};
-const render = (param, element, state) => {
-  param(element, state);
-};
-const createState = (state, element) => {
-  const _a = element, { on } = _a, el = __objRest(_a, ["on"]);
-  if (on && isFunction(on.createState)) {
-    on.createState(state, el);
-  }
-};
-const updateStateInit = (changes, element) => {
-  const _a = element, { state, on } = _a, el = __objRest(_a, ["state", "on"]);
-  if (on && isFunction(on.updateStateInit)) {
-    on.updateStateInit(changes, state, el);
-  }
-};
-const updateState = (changes, element) => {
-  const { state, on } = element;
-  if (on && isFunction(on.updateState)) {
-    on.updateState(changes, state, element);
-  }
-};
-const propsUpdated = (element) => {
-  const { props, state, on } = element;
-  if (on && isFunction(on.propsUpdated)) {
-    on.propsUpdated(props, state, element);
-  }
-};
-const update = (params, element, state) => {
-  if (element.on && isFunction(element.on.update)) {
-    element.on.update(element, state);
-  }
-  return params;
-};
-export {
-  createState,
-  init,
-  propsUpdated,
-  render,
-  update,
-  updateState,
-  updateStateInit
-};

package/legacy.js

@@ -1,49 +0,0 @@
-import { isFunction } from '@domql/utils'
-
-// LEGACY
-export const init = (param, element, state) => {
-  param(element, state)
-}
-
-export const render = (param, element, state) => {
-  param(element, state)
-}
-
-// export const attachNode = (param, element, state) => {
-//   param(element, state)
-// }
-
-export const createState = (state, element) => {
-  const { on, ...el } = element
-  if (on && isFunction(on.createState)) {
-    on.createState(state, el)
-  }
-}
-
-export const updateStateInit = (changes, element) => {
-  const { state, on, ...el } = element
-  if (on && isFunction(on.updateStateInit)) {
-    on.updateStateInit(changes, state, el)
-  }
-}
-
-export const updateState = (changes, element) => {
-  const { state, on } = element
-  if (on && isFunction(on.updateState)) {
-    on.updateState(changes, state, element)
-  }
-}
-
-export const propsUpdated = (element) => {
-  const { props, state, on } = element
-  if (on && isFunction(on.propsUpdated)) {
-    on.propsUpdated(props, state, element)
-  }
-}
-
-export const update = (params, element, state) => {
-  if (element.on && isFunction(element.on.update)) {
-    element.on.update(element, state)
-  }
-  return params
-}