domql 1.6.15 → 1.6.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "domql",
   "description": "DOM rendering Javascript framework at early stage.",
-  "version": "1.6.15",
+  "version": "1.6.16",
   "repository": "https://github.com/domql/domql",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/element/create.js

@@ -204,40 +204,41 @@ const checkIf = (element, parent) => {
 }
 
 const addCaching = (element, parent) => {
-  const { __ref } = element
-  let { __ref: __parentRef } = parent
+  const { __ref: ref } = element
+  let { __ref: parentRef } = parent
 
   // enable TRANSFORM in data
   if (!element.transform) element.transform = {}
 
   // enable CACHING
-  if (!__ref.__cached) __ref.__cached = {}
+  if (!ref.__cached) ref.__cached = {}
+  if (!ref.__defineCache) ref.__defineCache = {}
 
   // enable EXEC
-  if (!__ref.__exec) __ref.__exec = {}
+  if (!ref.__exec) ref.__exec = {}
 
   // enable CLASS CACHING
-  if (!__ref.__class) __ref.__class = {}
-  if (!__ref.__classNames) __ref.__classNames = {}
+  if (!ref.__class) ref.__class = {}
+  if (!ref.__classNames) ref.__classNames = {}
 
   // enable CLASS CACHING
-  if (!__ref.__attr) __ref.__attr = {}
+  if (!ref.__attr) ref.__attr = {}
 
   // enable CHANGES storing
-  if (!__ref.__changes) __ref.__changes = []
+  if (!ref.__changes) ref.__changes = []
 
   // enable CHANGES storing
-  if (!__ref.__children) __ref.__children = []
+  if (!ref.__children) ref.__children = []
 
   // Add _root element property
   const hasRoot = parent && parent.key === ':root'
-  if (!__ref.__root) __ref.__root = hasRoot ? element : __parentRef.__root
+  if (!ref.__root) ref.__root = hasRoot ? element : parentRef.__root
 
   // set the PATH array
   if (ENV === 'test' || ENV === 'development') {
-    if (!__parentRef) __parentRef = parent.__ref = {}
-    if (!__parentRef.__path) __parentRef.__path = []
-    __ref.__path = __parentRef.__path.concat(element.key)
+    if (!parentRef) parentRef = parent.ref = {}
+    if (!parentRef.__path) parentRef.__path = []
+    ref.__path = parentRef.__path.concat(element.key)
   }
 }
 

package/src/element/iterate.js

@@ -1,35 +1,36 @@
 'use strict'
 
 import { isObject, exec, isFunction, isNumber, isString } from '@domql/utils'
-import { overwrite } from '../utils'
+import { METHODS_EXL, overwrite } from '../utils'
 import { isMethod } from '@domql/methods'
 
 export const throughInitialExec = element => {
-  const { __ref } = element
-  const { __exec } = __ref
+  const { __ref: ref } = element
   for (const param in element) {
     const prop = element[param]
     if (isFunction(prop) && !isMethod(param)) {
-      __exec[param] = prop
+      ref.__exec[param] = prop
       element[param] = prop(element, element.state)
     }
   }
 }
 
-export const throughUpdatedExec = (element, options) => {
-  const { __ref } = element
-  const { __exec, __cached } = __ref
+export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
+  const { __ref: ref } = element
   const changes = {}
 
-  for (const param in __exec) {
+  for (const param in ref.__exec) {
     const prop = element[param]
-    const newExec = __exec[param](element, element.state)
 
-    // if element is string
-    if (prop && prop.node && (isString(newExec) || isNumber(newExec))) {
+    const isDefinedParam = ref.__defineCache[param]
+    if (isDefinedParam) continue
+
+    const newExec = ref.__exec[param](element, element.state)
+    const execReturnsString = isString(newExec) || isNumber(newExec)
+    if (prop && prop.node && execReturnsString) {
       overwrite(prop, { text: newExec }, options)
     } else if (newExec !== prop) {
-      __cached[param] = changes[param] = prop
+      ref.__cached[param] = changes[param] = prop
       element[param] = newExec
     }
   }
@@ -38,32 +39,34 @@ export const throughUpdatedExec = (element, options) => {
 }
 
 export const throughInitialDefine = (element) => {
-  const { define, context, __ref } = element
-  const { __exec, __cached } = __ref
+  const { define, context, __ref: ref } = element
 
-  let obj = {}
-  if (isObject(define)) obj = { ...define }
-  if (context && isObject(context.define)) obj = { ...obj, ...context.define }
+  let defineObj = {}
+  const hasGlobalDefine = context && isObject(context.define)
+  if (isObject(define)) defineObj = { ...define }
+  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define }
 
-  for (const param in obj) {
-    let prop = element[param]
+  for (const param in defineObj) {
+    let elementProp = element[param]
 
-    if (isFunction(prop) && !isMethod(param)) {
-      __exec[param] = prop
-      const execParam = prop = exec(prop, element)
-      if (execParam) element[param] = execParam
+    if (isFunction(elementProp) && !isMethod(param)) {
+      ref.__exec[param] = elementProp
+      const execParam = elementProp = exec(elementProp, element)
+
+      if (execParam) {
+        elementProp = element[param] = execParam.parse ? execParam.parse() : execParam
+        ref.__defineCache[param] = elementProp
+      }
     }
 
-    __cached[param] = prop
-    const execParam = obj[param](prop, element, element.state)
+    const execParam = defineObj[param](elementProp, element, element.state)
     if (execParam) element[param] = execParam
   }
   return element
 }
 
 export const throughUpdatedDefine = (element) => {
-  const { context, define, __ref } = element
-  const { __exec, __cached } = __ref
+  const { context, define, __ref: ref } = element
   const changes = {}
 
   let obj = {}
@@ -71,9 +74,9 @@ export const throughUpdatedDefine = (element) => {
   if (isObject(context && context.define)) obj = { ...obj, ...context.define }
 
   for (const param in obj) {
-    const execParam = __exec[param]
-    if (execParam) __cached[param] = execParam(element, element.state)
-    const cached = exec(__cached[param], element)
+    const execParam = ref.__exec[param]
+    if (execParam) ref.__defineCache[param] = execParam(element, element.state)
+    const cached = exec(ref.__defineCache[param], element)
     const newExecParam = obj[param](cached, element, element.state)
     if (newExecParam) element[param] = newExecParam
   }

package/src/element/update.js

@@ -1,14 +1,14 @@
 'use strict'
 
 import { window } from '@domql/globals'
-import { exec, isFunction, isNumber, isObject, isString, overwriteDeep } from '@domql/utils'
+import { exec, isFunction, isNumber, isObject, isString, merge, overwriteDeep } from '@domql/utils'
 import { applyEvent, triggerEventOn } from '@domql/event'
 import { isMethod } from '@domql/methods'
 import { createSnapshotId } from '@domql/key'
 import { updateProps } from '@domql/props'
 import { createState } from '@domql/state'
 
-import { METHODS_EXL, merge } from '../utils'
+import { METHODS_EXL } from '../utils'
 import create from './create'
 import { throughUpdatedDefine, throughUpdatedExec } from './iterate'
 import { registry } from './mixins'
@@ -23,13 +23,16 @@ const UPDATE_DEFAULT_OPTIONS = {
   cleanExec: true,
   preventRecursive: false,
   currentSnapshot: false,
-  calleeElement: false
+  calleeElement: false,
+  excludes: METHODS_EXL
 }
 
 const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
   const element = this
   const { parent, node, key } = element
 
+  if (!options.excludes) merge(options, UPDATE_DEFAULT_OPTIONS)
+
   let __ref = element.__ref
   if (!__ref) __ref = element.__ref = {}
 
@@ -59,7 +62,7 @@ const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
   }
 
   const overwriteChanges = overwriteDeep(element, params, METHODS_EXL)
-  const execChanges = throughUpdatedExec(element, UPDATE_DEFAULT_OPTIONS)
+  const execChanges = throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
   const definedChanges = throughUpdatedDefine(element)
 
   if (options.stackChanges && element.__stackChanges) {
@@ -167,11 +170,11 @@ const inheritStateUpdates = (element, options) => {
     return
   }
 
-  if (isFunction(stateKey)) {
+  if (options.forceStateFunction && isFunction(stateKey)) {
     const execState = exec(stateKey, element)
     state.update(execState, {
       ...options,
-      skipOverwrite: 'merge',
+      skipOverwrite: options.stateFunctionOverwrite,
       preventUpdateTriggerStateUpdate: true
     })
     return false

package/src/utils/object.js

@@ -12,17 +12,6 @@ export const METHODS_EXL = joinArrays(
   IGNORE_PROPS_PARAMS
 )
 
-export const merge = (element, obj) => {
-  for (const e in obj) {
-    const elementProp = element[e]
-    const objProp = obj[e]
-    if (elementProp === undefined) {
-      element[e] = objProp
-    }
-  }
-  return element
-}
-
 export const deepMerge = (element, extend, exclude = METHODS_EXL) => {
   for (const e in extend) {
     if (exclude.includes(e)) continue