@domql/element 2.5.141 → 2.5.143

package/create.js

@@ -252,6 +252,9 @@ const renderElement = (element, parent, options, attachOptions) => {
 
   // run `on.done`
   triggerEventOn('done', element, options)
+
+  // run `on.done`
+  triggerEventOn('create', element, options)
 }
 
 const checkIfPrimitive = (element) => is(element)('string', 'number')
@@ -362,7 +365,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     for (const k in element) {
       if (
         isUndefined(element[k]) ||
-        isMethod(k) ||
+        isMethod(k, element) ||
         isObject(registry[k]) ||
         isVariant(k)
       ) continue

package/dist/cjs/create.js

@@ -203,6 +203,7 @@ const renderElement = (element, parent, options, attachOptions) => {
   (0, import_event.triggerEventOn)("renderRouter", element, options);
   (0, import_event.triggerEventOn)("render", element, options);
   (0, import_event.triggerEventOn)("done", element, options);
+  (0, import_event.triggerEventOn)("create", element, options);
 };
 const checkIfPrimitive = (element) => (0, import_utils.is)(element)("string", "number");
 const applyValueAsText = (element, parent, key) => {
@@ -290,7 +291,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_iterate.throughInitialDefine)(element);
     (0, import_iterate.throughInitialExec)(element);
     for (const k in element) {
-      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k) || (0, import_utils.isObject)(import_mixins.registry[k]) || (0, import_utils.isVariant)(k))
+      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)(import_mixins.registry[k]) || (0, import_utils.isVariant)(k))
         continue;
       const hasDefine = element.define && element.define[k];
       const contextHasDefine = element.context && element.context.define && element.context.define[k];

package/dist/cjs/extend.js

@@ -60,11 +60,11 @@ const applyExtend = (element, parent, options = {}) => {
     stack = extendStack;
   } else if (childExtendLength) {
     stack = childExtendStack;
-  } else if (!options.extend)
+  } else if (!context.defaultExtends)
     return element;
-  if (options.extend) {
+  if (context.defaultExtends) {
     if (!mainExtend) {
-      const defaultOptionsExtend = (0, import_utils2.getExtendStack)(options.extend, context);
+      const defaultOptionsExtend = (0, import_utils2.getExtendStack)(context.defaultExtends, context);
       mainExtend = (0, import_utils2.cloneAndMergeArrayExtend)(defaultOptionsExtend);
       delete mainExtend.extend;
     }

package/dist/cjs/iterate.js

@@ -33,7 +33,7 @@ const throughInitialExec = (element, exclude = {}) => {
     if (exclude[param])
       continue;
     const prop = element[param];
-    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param) && !(0, import_utils.isVariant)(param)) {
+    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = prop;
       element[param] = prop(element, element.state, element.context);
     }
@@ -73,7 +73,7 @@ const throughInitialDefine = (element) => {
     defineObj = { ...defineObj, ...context.define };
   for (const param in defineObj) {
     let elementProp = element[param];
-    if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param) && !(0, import_utils.isVariant)(param)) {
+    if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = elementProp;
       const execParam2 = elementProp = (0, import_utils.exec)(elementProp, element);
       if (execParam2) {

package/dist/cjs/methods/index.js

@@ -297,6 +297,7 @@ const METHODS = [
   "nextElement",
   "previousElement"
 ];
-const isMethod = function(param) {
-  return METHODS.includes(param);
+const isMethod = function(param, element) {
+  var _a, _b;
+  return METHODS.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]);
 };

package/dist/cjs/methods/set.js

@@ -36,28 +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

@@ -73,7 +73,7 @@ const createNode = (element, options) => {
     const value = element[param];
     if (!Object.hasOwnProperty.call(element, param))
       continue;
-    if ((0, import_utils.isUndefined)(value) || (0, import_methods.isMethod)(param) || (0, import_utils.isVariant)(param) || (0, import_utils.isObject)(import_mixins.registry[param]))
+    if ((0, import_utils.isUndefined)(value) || (0, import_methods.isMethod)(param, element) || (0, import_utils.isVariant)(param) || (0, import_utils.isObject)(import_mixins.registry[param]))
       continue;
     const isElement = (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {

package/dist/cjs/update.js

@@ -136,7 +136,7 @@ const update = function(params = {}, opts) {
     const isInPreventUpdate = (0, import_utils.isArray)(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = (0, import_utils.isArray)(preventDefineUpdate) && preventDefineUpdate.includes(param);
     const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import_utils.isVariant)(param))
+    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import_utils.isVariant)(param))
       continue;
     if (preventStateUpdate === "once")
       options.preventStateUpdate = false;
@@ -147,6 +147,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,
@@ -174,11 +177,11 @@ const captureSnapshot = (element, options) => {
   return [snapshotOnCallee, calleeElement];
 };
 const checkIfOnUpdate = (element, parent, options) => {
-  var _a, _b;
-  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)(element.props.if) || !parent)
+  var _a, _b, _c;
+  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent)
     return;
   const ref = element.__ref;
-  const ifPassed = (element.if || ((_a = element.props) == null ? void 0 : _a.if))(element, element.state, element.context, options);
+  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(element, element.state, element.context, options);
   const itWasFalse = ref.__if !== true;
   if (ifPassed) {
     ref.__if = true;
@@ -201,7 +204,7 @@ const checkIfOnUpdate = (element, parent, options) => {
       const contentKey = ref.contentElementKey;
       if (element.$collection || element.$stateCollection || element.$propsCollection) {
         element.removeContent();
-      } else if ((_b = element[contentKey]) == null ? void 0 : _b.parseDeep)
+      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep)
         element[contentKey] = element[contentKey].parseDeep();
       const previousElement = element.previousElement();
       const previousNode = previousElement == null ? void 0 : previousElement.node;

package/dist/cjs/utils/component.js

@@ -30,6 +30,7 @@ const replaceOnKeys = (key) => key.replace(/on\w+/g, (match) => match.substring(
 const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
   const newElem = {
     props: {},
+    define: {},
     on: {}
   };
   for (const k in el) {
@@ -39,6 +40,10 @@ const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
       const onKey = replaceOnKeys(prop);
       newElem.on[onKey] = prop;
     }
+    const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    if (isDefine) {
+      newElem.define[k] = prop;
+    }
     const isComponent = (0, import_utils.checkIfKeyIsComponent)(k);
     const isRegistry = import_mixins.registry[k];
     if (isComponent || isRegistry) {

package/dist/cjs/utils/onlyResolveExtends.js

@@ -74,7 +74,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_iterate.throughInitialExec)(element);
     for (const param in element) {
       const prop = element[param];
-      if ((0, import_utils.isUndefined)(prop) || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import__2.isVariant)(param))
+      if ((0, import_utils.isUndefined)(prop) || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import__2.isVariant)(param))
         continue;
       const hasDefine = element.define && element.define[param];
       const contextHasDefine = element.context && element.context.define && element.context.define[param];

package/extend.js

@@ -63,22 +63,20 @@ export const applyExtend = (element, parent, options = {}) => {
     stack = extendStack
   } else if (childExtendLength) {
     stack = childExtendStack
-  } else if (!options.extend) return element
+  } else if (!context.defaultExtends) return element
 
-  if (options.extend) {
+  if (context.defaultExtends) {
     if (!mainExtend) {
-      const defaultOptionsExtend = getExtendStack(options.extend, context)
+      const defaultOptionsExtend = getExtendStack(context.defaultExtends, context)
       mainExtend = cloneAndMergeArrayExtend(defaultOptionsExtend)
       delete mainExtend.extend
     }
     stack = [].concat(stack, mainExtend)
   }
 
-  // check if array contains string extends
   if (__ref) __ref.__extend = stack
   let mergedExtend = cloneAndMergeArrayExtend(stack)
 
-  // apply `component:` property
   const COMPONENTS = (context && context.components) || options.components
   const component = exec(element.component || mergedExtend.component, element)
   if (component && COMPONENTS && COMPONENTS[component]) {

package/iterate.js

@@ -19,7 +19,7 @@ export const throughInitialExec = (element, exclude = {}) => {
   for (const param in element) {
     if (exclude[param]) continue
     const prop = element[param]
-    if (isFunction(prop) && !isMethod(param) && !isVariant(param)) {
+    if (isFunction(prop) && !isMethod(param, element) && !isVariant(param)) {
       ref.__exec[param] = prop
       element[param] = prop(element, element.state, element.context)
       // if (isComponent)
@@ -69,7 +69,7 @@ export const throughInitialDefine = (element) => {
   for (const param in defineObj) {
     let elementProp = element[param]
 
-    if (isFunction(elementProp) && !isMethod(param) && !isVariant(param)) {
+    if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
       ref.__exec[param] = elementProp
       const execParam = elementProp = exec(elementProp, element)
 

package/methods/index.js

@@ -267,6 +267,6 @@ export const METHODS = [
   'previousElement'
 ]
 
-export const isMethod = function (param) {
-  return METHODS.includes(param)
+export const isMethod = function (param, element) {
+  return METHODS.includes(param) || element?.context?.methods?.[param]
 }

package/methods/set.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { isDevelopment } from '@domql/utils'
+import { isDevelopment, merge } from '@domql/utils'
 
 import set, { reset } from '../set'
 import update from '../update'
@@ -24,27 +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 (isDevelopment()) proto.log = log.bind(element)
+  if (element.context.methods) merge(proto, element.context.methods)
+  if (isDevelopment()) proto.log = log
   Object.setPrototypeOf(element, proto)
 }

package/node.js

@@ -68,7 +68,7 @@ export const createNode = (element, options) => {
 
     if (
       isUndefined(value) ||
-      isMethod(param) ||
+      isMethod(param, element) ||
       isVariant(param) ||
       isObject(registry[param])
     ) continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.5.141",
+  "version": "2.5.143",
   "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.141",
-    "@domql/render": "^2.5.141",
-    "@domql/state": "^2.5.141",
-    "@domql/utils": "^2.5.141"
+    "@domql/event": "^2.5.143",
+    "@domql/render": "^2.5.143",
+    "@domql/state": "^2.5.143",
+    "@domql/utils": "^2.5.143"
   },
-  "gitHead": "c77d004ddb710821445be4dce056410b004f13ea",
+  "gitHead": "46440d5034244c18657bf272df1bdc3e8ff666c5",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/update.js

@@ -133,7 +133,7 @@ const update = function (params = {}, opts) {
       preventDefineUpdate === param ||
       (preventContentUpdate && param === 'content' && !hasCollection) ||
       (preventStateUpdate && param) === 'state' ||
-      isMethod(param) || isObject(registry[param]) || isVariant(param)
+      isMethod(param, element) || isObject(registry[param]) || isVariant(param)
     ) continue
 
     if (preventStateUpdate === 'once') options.preventStateUpdate = false
@@ -146,6 +146,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,
@@ -180,7 +184,7 @@ const captureSnapshot = (element, options) => {
 }
 
 const checkIfOnUpdate = (element, parent, options) => {
-  if ((!isFunction(element.if) && !isFunction(element.props.if)) || !parent) return
+  if ((!isFunction(element.if) && !isFunction(element.props?.if)) || !parent) return
 
   const ref = element.__ref
   const ifPassed = (element.if || element.props?.if)(element, element.state, element.context, options)

package/utils/component.js

@@ -18,6 +18,7 @@ const replaceOnKeys = key => key.replace(/on\w+/g, match => match.substring(2))
 export const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
   const newElem = {
     props: {},
+    define: {},
     on: {}
   }
   for (const k in el) {
@@ -29,6 +30,12 @@ export const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
     // } else if (!isMethod && checkIfKeyIsProperty(k)) {
     }
 
+    const isDefine = k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
+    if (isDefine) {
+      newElem.define[k] = prop
+    // } else if (!isMethod && checkIfKeyIsProperty(k)) {
+    }
+
     const isComponent = checkIfKeyIsComponent(k)
     const isRegistry = registry[k]
     if (isComponent || isRegistry) {

package/utils/onlyResolveExtends.js

@@ -80,7 +80,7 @@ export const onlyResolveExtends = (element, parent, key, options) => {
       const prop = element[param]
       if (
         isUndefined(prop) ||
-        isMethod(param) ||
+        isMethod(param, element) ||
         isObject(registry[param]) ||
         isVariant(param)
       ) continue