@domql/element 2.5.142 → 2.5.144

package/create.js

@@ -2,6 +2,7 @@
 
 import createNode from './node'
 import { ROOT } from './tree'
+
 import {
   HTML_TAGS,
   isObject,
@@ -20,6 +21,7 @@ import {
   detectInfiniteLoop,
   addChildrenIfNotInOriginal
 } from '@domql/utils'
+
 import { triggerEventOn } from '@domql/event'
 import { assignNode } from '@domql/render'
 import { createState } from '@domql/state'
@@ -306,6 +308,7 @@ const addCaching = (element, parent) => {
 
   // enable EXEC
   if (!ref.__exec) ref.__exec = {}
+  if (!ref.__execProps) ref.__execProps = {}
 
   // enable CLASS CACHING
   if (!ref.__class) ref.__class = {}

package/dist/cjs/create.js

@@ -246,6 +246,8 @@ const addCaching = (element, parent) => {
     ref.__defineCache = {};
   if (!ref.__exec)
     ref.__exec = {};
+  if (!ref.__execProps)
+    ref.__execProps = {};
   if (!ref.__class)
     ref.__class = {};
   if (!ref.__classNames)

package/dist/cjs/iterate.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var iterate_exports = {};
 __export(iterate_exports, {
+  throughExecProps: () => throughExecProps,
   throughInitialDefine: () => throughInitialDefine,
   throughInitialExec: () => throughInitialExec,
   throughUpdatedDefine: () => throughUpdatedDefine,
@@ -63,6 +64,20 @@ const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS
   }
   return changes;
 };
+const throughExecProps = (element) => {
+  const { __ref: ref } = element;
+  const { props } = element;
+  for (const k in props) {
+    const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    const cachedExecProp = ref.__execProps[k];
+    if ((0, import_utils.isFunction)(cachedExecProp)) {
+      props[k] = (0, import_utils.exec)(cachedExecProp, element);
+    } else if (isDefine && (0, import_utils.isFunction)(props[k])) {
+      ref.__execProps[k] = props[k];
+      props[k] = (0, import_utils.exec)(props[k], element);
+    }
+  }
+};
 const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};

package/dist/cjs/methods/set.js

@@ -36,30 +36,30 @@ var import_set = __toESM(require("../set"), 1);
 var import_update = __toESM(require("../update"), 1);
 var import__ = require("./");
 var import_content = require("../mixins/content");
-const addMethods = (element, parent) => {
+const addMethods = (element, parent, options) => {
   const proto = {
-    set: import_set.default.bind(element),
-    reset: import_set.reset.bind(element),
-    update: import_update.default.bind(element),
-    variables: import__.variables.bind(element),
-    remove: import__.remove.bind(element),
-    updateContent: import_content.updateContent.bind(element),
-    removeContent: import_content.removeContent.bind(element),
-    setProps: import__.setProps.bind(element),
-    lookup: import__.lookup.bind(element),
-    lookdown: import__.lookdown.bind(element),
-    lookdownAll: import__.lookdownAll.bind(element),
-    setNodeStyles: import__.setNodeStyles.bind(element),
-    spotByPath: import__.spotByPath.bind(element),
-    parse: import__.parse.bind(element),
-    parseDeep: import__.parseDeep.bind(element),
-    keys: import__.keys.bind(element),
-    nextElement: import__.nextElement.bind(element),
-    previousElement: import__.previousElement.bind(element)
+    set: import_set.default,
+    reset: import_set.reset,
+    update: import_update.default,
+    variables: import__.variables,
+    remove: import__.remove,
+    updateContent: import_content.updateContent,
+    removeContent: import_content.removeContent,
+    setProps: import__.setProps,
+    lookup: import__.lookup,
+    lookdown: import__.lookdown,
+    lookdownAll: import__.lookdownAll,
+    setNodeStyles: import__.setNodeStyles,
+    spotByPath: import__.spotByPath,
+    parse: import__.parse,
+    parseDeep: import__.parseDeep,
+    keys: import__.keys,
+    nextElement: import__.nextElement,
+    previousElement: import__.previousElement
   };
   if (element.context.methods)
     (0, import_utils.merge)(proto, element.context.methods);
   if ((0, import_utils.isDevelopment)())
-    proto.log = import__.log.bind(element);
+    proto.log = import__.log;
   Object.setPrototypeOf(element, proto);
 };

package/dist/cjs/node.js

@@ -60,6 +60,7 @@ const createNode = (element, options) => {
     if ((0, import_utils.isFunction)(node.setAttribute))
       node.setAttribute("key", element.key);
   }
+  (0, import_iterate.throughExecProps)(element);
   (0, import_iterate.throughInitialDefine)(element);
   (0, import_iterate.throughInitialExec)(element);
   if (element.tag !== "string" && element.tag !== "fragment") {

package/dist/cjs/update.js

@@ -93,16 +93,13 @@ const update = function(params = {}, opts) {
     if (beforeUpdateReturns === false)
       return element;
   }
-  const overwriteChanges = (0, import_utils.overwriteDeep)(element, params, import_utils2.METHODS_EXL);
-  const execChanges = (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
-  const definedChanges = (0, import_iterate.throughUpdatedDefine)(element);
+  (0, import_utils.overwriteDeep)(element, params, import_utils2.METHODS_EXL);
+  (0, import_iterate.throughExecProps)(element);
+  (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  (0, import_iterate.throughUpdatedDefine)(element);
   if (!options.isForced && !options.preventListeners) {
     (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
-  if (options.stackChanges && element.__stackChanges) {
-    const stackChanges = (0, import_utils.merge)(definedChanges, (0, import_utils.merge)(execChanges, overwriteChanges));
-    element.__stackChanges.push(stackChanges);
-  }
   if (!ref.__if)
     return false;
   if (!node) {
@@ -147,6 +144,9 @@ const update = function(params = {}, opts) {
       if (!canUpdate)
         continue;
       const lazyLoad = element.props.lazyLoad || options.lazyLoad;
+      if (options.onEachUpdate) {
+        options.onEachUpdate(param, element, element.state, element.context);
+      }
       const childUpdateCall = () => update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,

package/dist/cjs/utils/onlyResolveExtends.js

@@ -42,6 +42,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
       ref2.__defineCache = {};
     if (!ref2.__exec)
       ref2.__exec = {};
+    if (!ref2.__execProps)
+      ref2.__execProps = {};
     if (!ref2.__class)
       ref2.__class = {};
     if (!ref2.__classNames)

package/iterate.js

@@ -58,6 +58,21 @@ export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL })
   return changes
 }
 
+export const throughExecProps = (element) => {
+  const { __ref: ref } = element
+  const { props } = element
+  for (const k in props) {
+    const isDefine = k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
+    const cachedExecProp = ref.__execProps[k]
+    if (isFunction(cachedExecProp)) {
+      props[k] = exec(cachedExecProp, element)
+    } else if (isDefine && isFunction(props[k])) {
+      ref.__execProps[k] = props[k]
+      props[k] = exec(props[k], element)
+    }
+  }
+}
+
 export const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element
 

package/methods/set.js

@@ -24,28 +24,28 @@ import {
 
 import { removeContent, updateContent } from '../mixins/content'
 
-export const addMethods = (element, parent) => {
+export const addMethods = (element, parent, options) => {
   const proto = {
-    set: set.bind(element),
-    reset: reset.bind(element),
-    update: update.bind(element),
-    variables: variables.bind(element),
-    remove: remove.bind(element),
-    updateContent: updateContent.bind(element),
-    removeContent: removeContent.bind(element),
-    setProps: setProps.bind(element),
-    lookup: lookup.bind(element),
-    lookdown: lookdown.bind(element),
-    lookdownAll: lookdownAll.bind(element),
-    setNodeStyles: setNodeStyles.bind(element),
-    spotByPath: spotByPath.bind(element),
-    parse: parse.bind(element),
-    parseDeep: parseDeep.bind(element),
-    keys: keys.bind(element),
-    nextElement: nextElement.bind(element),
-    previousElement: previousElement.bind(element)
+    set,
+    reset,
+    update,
+    variables,
+    remove,
+    updateContent,
+    removeContent,
+    setProps,
+    lookup,
+    lookdown,
+    lookdownAll,
+    setNodeStyles,
+    spotByPath,
+    parse,
+    parseDeep,
+    keys,
+    nextElement,
+    previousElement
   }
   if (element.context.methods) merge(proto, element.context.methods)
-  if (isDevelopment()) proto.log = log.bind(element)
+  if (isDevelopment()) proto.log = log
   Object.setPrototypeOf(element, proto)
 }

package/node.js

@@ -8,6 +8,7 @@ import { isMethod } from './methods'
 import create from './create'
 
 import {
+  throughExecProps,
   throughInitialDefine,
   throughInitialExec
 } from './iterate'
@@ -44,6 +45,9 @@ export const createNode = (element, options) => {
     if (isFunction(node.setAttribute)) node.setAttribute('key', element.key)
   }
 
+  // iterate through exec props
+  throughExecProps(element)
+
   // iterate through define
   throughInitialDefine(element)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.5.142",
+  "version": "2.5.144",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -26,12 +26,12 @@
     "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.5.142",
-    "@domql/render": "^2.5.142",
-    "@domql/state": "^2.5.142",
-    "@domql/utils": "^2.5.142"
+    "@domql/event": "^2.5.144",
+    "@domql/render": "^2.5.144",
+    "@domql/state": "^2.5.144",
+    "@domql/utils": "^2.5.144"
   },
-  "gitHead": "65537c9b9a818948e1835b75a5c8a3e79bffdecd",
+  "gitHead": "9026efab1932521ec5eec3e88261eadb81f2e3cb",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/update.js

@@ -21,7 +21,7 @@ import { updateProps } from './props'
 import { createState, findInheritedState } from '@domql/state'
 
 import create from './create'
-import { throughUpdatedDefine, throughUpdatedExec } from './iterate'
+import { throughExecProps, throughUpdatedDefine, throughUpdatedExec } from './iterate'
 import { registry } from './mixins'
 import { applyParam } from './utils/applyParam'
 import OPTIONS from './cache/options'
@@ -80,20 +80,15 @@ const update = function (params = {}, opts) {
     if (beforeUpdateReturns === false) return element
   }
 
-  const overwriteChanges = overwriteDeep(element, params, METHODS_EXL)
-  // const overwriteChanges = overwriteDeep(element, params)
-  const execChanges = throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
-  const definedChanges = throughUpdatedDefine(element)
+  overwriteDeep(element, params, METHODS_EXL)
+  throughExecProps(element)
+  throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
+  throughUpdatedDefine(element)
 
   if (!options.isForced && !options.preventListeners) {
     triggerEventOn('beforeClassAssign', element, options)
   }
 
-  if (options.stackChanges && element.__stackChanges) {
-    const stackChanges = merge(definedChanges, merge(execChanges, overwriteChanges))
-    element.__stackChanges.push(stackChanges)
-  }
-
   if (!ref.__if) return false
   if (!node) {
     // return createNode(element, options)
@@ -146,6 +141,10 @@ const update = function (params = {}, opts) {
 
       const lazyLoad = element.props.lazyLoad || options.lazyLoad
 
+      if (options.onEachUpdate) {
+        options.onEachUpdate(param, element, element.state, element.context)
+      }
+
       const childUpdateCall = () => update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,
@@ -311,3 +310,14 @@ const createStateUpdate = (element, parent, options) => {
 }
 
 export default update
+
+// save updates history
+// const overwriteChanges = overwriteDeep(element, params, METHODS_EXL)
+// // const overwriteChanges = overwriteDeep(element, params)
+// const propsChanges = throughExecProps(element)
+// const execChanges = throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
+// const definedChanges = throughUpdatedDefine(element)
+// if (options.stackChanges && ref.__stackChanges) {
+//   const stackChanges = merge(definedChanges, merge(execChanges, overwriteChanges))
+//   ref.__stackChanges.push(stackChanges)
+// }

package/utils/onlyResolveExtends.js

@@ -32,6 +32,7 @@ export const onlyResolveExtends = (element, parent, key, options) => {
 
     // enable EXEC
     if (!ref.__exec) ref.__exec = {}
+    if (!ref.__execProps) ref.__execProps = {}
 
     // enable CLASS CACHING
     if (!ref.__class) ref.__class = {}