@domql/event 2.3.89 → 2.3.100

package/can.js

@@ -1,10 +1,9 @@
 'use strict'
 
-// import { TAGS } from '@domql/registry'
-// import { report } from '@domql/report'
+import { report } from '@domql/report'
+import { isValidHtmlTag } from '@domql/utils'
 
-// export const render = (element) => {
-//   const tag = element.tag || 'div'
-//   const isValid = TAGS.body.indexOf(tag) > -1
-//   return isValid || report('HTMLInvalidTag')
-// }
+export const canRender = (element) => {
+  const tag = element.tag || 'div'
+  return isValidHtmlTag(tag) || report('HTMLInvalidTag')
+}

package/dist/cjs/can.js

@@ -0,0 +1,29 @@
+"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 can_exports = {};
+__export(can_exports, {
+  canRender: () => canRender
+});
+module.exports = __toCommonJS(can_exports);
+var import_report = require("@domql/report");
+var import_utils = require("@domql/utils");
+const canRender = (element) => {
+  const tag = element.tag || "div";
+  return (0, import_utils.isValidHtmlTag)(tag) || (0, import_report.report)("HTMLInvalidTag");
+};

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_exports = {};
+module.exports = __toCommonJS(event_exports);
+__reExport(event_exports, require("./on"), module.exports);
+__reExport(event_exports, require("./can"), module.exports);

package/dist/cjs/legacy.js

@@ -0,0 +1,65 @@
+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/cjs/on.js

@@ -0,0 +1,52 @@
+"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 on_exports = {};
+__export(on_exports, {
+  applyEvent: () => applyEvent,
+  applyEventsOnNode: () => applyEventsOnNode,
+  triggerEventOn: () => triggerEventOn
+});
+module.exports = __toCommonJS(on_exports);
+var import_utils = require("@domql/utils");
+const applyEvent = (param, element, state, context, updatedObj) => {
+  if (updatedObj)
+    return param(updatedObj, element, state || element.state, context || element.context);
+  return param(element, state || element.state, context || element.context);
+};
+const triggerEventOn = (param, element, updatedObj) => {
+  if (element.on && (0, import_utils.isFunction)(element.on[param])) {
+    if (updatedObj) {
+      const { state, context } = element;
+      return applyEvent(element.on[param], element, state, context, updatedObj);
+    }
+    return applyEvent(element.on[param], element);
+  }
+};
+const applyEventsOnNode = (element) => {
+  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 === "initStateUpdated" || param === "stateUpdated" || param === "initUpdate" || param === "update")
+      continue;
+    const appliedFunction = element.on[param];
+    if ((0, import_utils.isFunction)(appliedFunction)) {
+      const { state, context } = element;
+      node.addEventListener(param, (event) => appliedFunction(event, element, state, context));
+    }
+  }
+};

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}

package/dist/cjs/store.js

@@ -0,0 +1,27 @@
+"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 store_exports = {};
+__export(store_exports, {
+  default: () => store_default
+});
+module.exports = __toCommonJS(store_exports);
+var store_default = {
+  click: [],
+  render: []
+};

package/index.js

@@ -1,16 +1,4 @@
 'use strict'
 
-import * as on from './on'
-import * as can from './can'
-import * as is from './is'
-
-const applyEvent = on.applyEvent
-const triggerEventOn = on.triggerEventOn
-
-export {
-  on,
-  applyEvent,
-  triggerEventOn,
-  can,
-  is
-}
+export * from './on'
+export * from './can'

package/legacy.js

@@ -0,0 +1,49 @@
+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
+}

package/on.js

@@ -2,67 +2,42 @@
 
 import { isFunction } from '@domql/utils'
 
-export const init = (param, element, state) => {
-  param(element, state)
-}
-
-export const render = (param, element, state) => {
-  param(element, state)
-}
-
-export const applyEvent = (param, element, state, context) => {
+export const applyEvent = (param, element, state, context, updatedObj) => {
+  if (updatedObj) return param(updatedObj, element, state || element.state, context || element.context)
   return param(element, state || element.state, context || element.context)
 }
 
-export const triggerEventOn = (param, element) => {
+export const triggerEventOn = (param, element, updatedObj) => {
   if (element.on && isFunction(element.on[param])) {
+    if (updatedObj) {
+      const { state, context } = element
+      return applyEvent(element.on[param], element, state, context, updatedObj)
+    }
     return applyEvent(element.on[param], element)
   }
 }
 
-export const initUpdate = (element) => {
-  const { ref, state, on } = element
-  const { props } = ref
-  if (on && isFunction(on.initUpdate)) {
-    on.initUpdate(props, state, ref)
-  }
-}
-
-// 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)
+export const applyEventsOnNode = element => {
+  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 === 'initStateUpdated' ||
+      param === 'stateUpdated' ||
+      param === 'initUpdate' ||
+      param === 'update'
+    ) continue
+
+    const appliedFunction = element.on[param]
+    if (isFunction(appliedFunction)) {
+      const { state, context } = element
+      node.addEventListener(param, event => appliedFunction(event, element, state, context))
+    }
   }
-  return params
 }

package/package.json

@@ -1,15 +1,31 @@
 {
   "name": "@domql/event",
-  "version": "2.3.89",
-  "main": "index.js",
+  "version": "2.3.100",
   "license": "MIT",
+  "type": "module",
+  "module": "dist/esm/index.js",
+  "unpkg": "dist/iife/index.js",
+  "jsdelivr": "dist/iife/index.js",
+  "main": "dist/esm/index.js",
+  "exports": "./dist/cjs/index.js",
+  "source": "index.js",
+  "files": [
+    "*.js",
+    "dist"
+  ],
   "scripts": {
-    "vpatch": "npm version patch && npm publish --access public"
+    "copy:package:cjs": "cp ../../.build/package-cjs.json dist/cjs/package.json",
+    "build:esm": "npx esbuild *.js --target=es2020 --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": "yarn build:cjs",
+    "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
   },
   "dependencies": {
     "@domql/globals": "latest",
+    "@domql/registry": "latest",
+    "@domql/report": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "bb45c7f24e08fb579b72c90abeed9f0054c817b0",
-  "source": "index.js"
+  "gitHead": "4d65ad04e488122bfc73ec81dc16c45b842ffa9b"
 }

package/is.js

@@ -1,15 +0,0 @@
-'use strict'
-
-import { window } from '@domql/globals'
-
-export const node = (node) => {
-  const { Node } = window
-  return (
-    typeof Node === 'function'
-      ? node instanceof Node
-      : node &&
-        typeof node === 'object' &&
-        typeof node.nodeType === 'number' &&
-        typeof node.tag === 'string'
-  )
-}