domql 1.6.17 → 1.6.19

package/package.json

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

package/src/element/create.js

@@ -25,7 +25,7 @@ import {
   applyComponentFromContext,
   applyKeyComponentAsExtend,
   checkIfKeyIsComponent
-} from '../utils/component'
+} from './utils/component'
 import { removeContentElement } from './remove'
 
 const ENV = process.env.NODE_ENV
@@ -126,11 +126,11 @@ const create = (element, parent, key, options = OPTIONS.create || {}) => {
   if (__ref.__if) createProps(element, parent)
 
   // run `on.init`
-  const initReturns = triggerEventOn('init', element)
+  const initReturns = triggerEventOn('init', element, options)
   if (initReturns === false) return element
 
   // run `on.beforeClassAssign`
-  triggerEventOn('beforeClassAssign', element)
+  triggerEventOn('beforeClassAssign', element, options)
 
   // generate a CLASS name
   assignClass(element)
@@ -144,10 +144,10 @@ const create = (element, parent, key, options = OPTIONS.create || {}) => {
   assignNode(element, parent, key)
 
   // run `on.renderRouter`
-  triggerEventOn('renderRouter', element)
+  triggerEventOn('renderRouter', element, options)
 
   // run `on.render`
-  triggerEventOn('render', element)
+  triggerEventOn('render', element, options)
 
   if (parent.__ref && parent.__ref.__children) parent.__ref.__children.push(element.key)
 
@@ -193,17 +193,17 @@ const applyContext = (element, parent, options) => {
 }
 
 const checkIf = (element, parent) => {
-  const { __ref } = element
+  const { __ref: ref } = element
 
   if (isFunction(element.if)) {
     // TODO: move as fragment
     const ifPassed = element.if(element, element.state)
     if (!ifPassed) {
       const ifFragment = cacheNode({ tag: 'fragment' })
-      __ref.__ifFragment = appendNode(ifFragment, parent.node)
-      delete __ref.__if
-    } else __ref.__if = true
-  } else __ref.__if = true
+      ref.__ifFragment = appendNode(ifFragment, parent.node)
+      delete ref.__if
+    } else ref.__if = true
+  } else ref.__if = true
 }
 
 const addCaching = (element, parent) => {

package/src/element/extend.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import { isFunction, exec, isString } from '@domql/utils'
-import { getExtendStack, jointStacks, cloneAndMergeArrayExtend, deepMergeExtend, replaceStringsWithComponents } from '../utils'
+import { getExtendStack, jointStacks, cloneAndMergeArrayExtend, deepMergeExtend, replaceStringsWithComponents } from './utils'
 
 const ENV = process.env.NODE_ENV
 

package/src/element/iterate.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import { isObject, exec, isFunction, isNumber, isString } from '@domql/utils'
-import { METHODS_EXL, overwrite } from '../utils'
+import { METHODS_EXL, overwrite } from './utils'
 import { isMethod } from '@domql/methods'
 
 export const throughInitialExec = element => {

package/src/element/mixins/content.js

@@ -12,7 +12,7 @@ export default (param, element, node, options) => {
       // const parsedContent = element.content.parseDeep(['class', 'on', 'tag'])
       // console.log(parsedContent)
       // if (!element.content.__ref) element.content.__ref = {}
-      element.content.update()
+      element.content.update({}, options)
     } else {
       // if (element.$setCollection || element.$setStateCollection || element.$setPropsCollection) return
       set.call(element, param, options)

package/src/element/node.js

@@ -19,21 +19,21 @@ const ENV = process.env.NODE_ENV
 
 export const createNode = (element, options) => {
   // create and assign a node
-  let { node, tag, __ref } = element
+  let { node, tag, __ref: ref } = element
 
   let isNewNode
 
   if (!node) {
     isNewNode = true
 
-    if (!__ref.__if) return element
+    if (!ref.__if) return element
 
     if (tag === 'shadow') {
       node = element.node = element.parent.node.attachShadow({ mode: 'open' })
     } else node = element.node = cacheNode(element)
 
     // trigger `on.attachNode`
-    triggerEventOn('attachNode', element)
+    triggerEventOn('attachNode', element, options)
   }
 
   // node.dataset // .key = element.key
@@ -43,7 +43,7 @@ export const createNode = (element, options) => {
     if (isFunction(node.setAttribute)) node.setAttribute('key', element.key)
   }
 
-  if (!__ref.__if) return element
+  if (!ref.__if) return element
 
   // iterate through all given params
   if (element.tag !== 'string' || element.tag !== 'fragment') {

package/src/element/update.js

@@ -2,13 +2,13 @@
 
 import { window } from '@domql/globals'
 import { exec, isFunction, isNumber, isObject, isString, merge, overwriteDeep } from '@domql/utils'
-import { applyEvent, triggerEventOn } from '@domql/event'
+import { applyEvent, triggerEventOn, triggerEventOnUpdate } 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 } from '../utils'
+import { METHODS_EXL } from './utils'
 import create from './create'
 import { throughUpdatedDefine, throughUpdatedExec } from './iterate'
 import { registry } from './mixins'
@@ -36,8 +36,8 @@ const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
   if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return
   if (!excludes) merge(options, UPDATE_DEFAULT_OPTIONS)
 
-  let __ref = element.__ref
-  if (!__ref) __ref = element.__ref = {}
+  let ref = element.__ref
+  if (!ref) ref = element.__ref = {}
 
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options)
   if (snapshotHasUpdated) return
@@ -46,21 +46,21 @@ const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
     params = { text: params }
   }
 
-  const ifFails = checkIfOnUpdate(element, parent, options,)
+  const ifFails = checkIfOnUpdate(element, parent, options)
   if (ifFails) return
 
   const inheritState = inheritStateUpdates(element, options)
   if (inheritState === false) return
 
-  if (__ref.__if && !options.preventPropsUpdate) {
+  if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps)
-    const hasFunctionInProps = element.__ref.__props.filter(v => isFunction(v))
+    const hasFunctionInProps = ref.__props.filter(v => isFunction(v))
     const props = params.props || hasParentProps || hasFunctionInProps.length
     if (props) updateProps(props, element, parent)
   }
 
   if (!options.preventInitUpdateListener) {
-    const initUpdateReturns = triggerEventOn('initUpdate', element, params)
+    const initUpdateReturns = triggerEventOnUpdate('initUpdate', params, element, options)
     if (initUpdateReturns === false) return element
   }
 
@@ -73,7 +73,7 @@ const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
     element.__stackChanges.push(stackChanges)
   }
 
-  if (!__ref.__if) return false
+  if (!ref.__if) return false
   if (!node) {
     // return createNode(element, options)
     return
@@ -109,21 +109,21 @@ const update = function (params = {}, options = UPDATE_DEFAULT_OPTIONS) {
     }
   }
 
-  if (!options.preventUpdateListener) triggerEventOn('update', element)
+  if (!options.preventUpdateListener) triggerEventOn('update', element, options)
 }
 
 const captureSnapshot = (element, options) => {
-  const __ref = element.__ref
+  const ref = element.__ref
 
   const { currentSnapshot, calleeElement } = options
   const isCallee = calleeElement === element
   if (!calleeElement || isCallee) {
     const createdStanpshot = snapshot.snapshotId()
-    __ref.__currentSnapshot = createdStanpshot
+    ref.__currentSnapshot = createdStanpshot
     return [createdStanpshot, element]
   }
 
-  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot
+  const snapshotOnCallee = ref.__currentSnapshot
   if (currentSnapshot < snapshotOnCallee) {
     return [snapshotOnCallee, calleeElement, true]
   }
@@ -135,7 +135,7 @@ const checkIfOnUpdate = (element, parent, options) => {
   if (!isFunction(element.if)) return
 
   const ref = element.__ref
-  const ifPassed = element.if(element, element.state)
+  const ifPassed = element.if(element, element.state, element.context)
   const itWasFalse = ref.__if !== true
 
   if (ifPassed) {
@@ -162,43 +162,55 @@ const checkIfOnUpdate = (element, parent, options) => {
 }
 
 const inheritStateUpdates = (element, options) => {
-  const { __ref } = element
-  const stateKey = __ref.__state
+  const { __ref: ref } = element
+  const stateKey = ref.__state
   const { parent, state } = element
 
-  if (options.preventUpdateTriggerStateUpdate) return
+  if (options.preventpdateTriggerStateUpdate) return
 
-  if (!stateKey && !__ref.__hasRootState) {
+  if (!stateKey && !ref.__hasRootState) {
     element.state = (parent && parent.state) || {}
     return
   }
 
-  if (options.forceStateFunction && isFunction(stateKey)) {
+  const { isHoisted, execStateFunction, stateFunctionOverwrite } = options
+  const shouldForceStateUpdate = isFunction(stateKey) && (!isHoisted && execStateFunction && stateFunctionOverwrite)
+  if (shouldForceStateUpdate) {
     const execState = exec(stateKey, element)
-    state.update(execState, {
+    state.set(execState, {
       ...options,
-      skipOverwrite: options.stateFunctionOverwrite,
-      preventUpdateTriggerStateUpdate: true
+      preventUpdate: true
     })
-    return false
+    return
   }
 
   const parentState = (parent && parent.state) || {}
   const keyInParentState = parentState[stateKey]
 
-  if (!keyInParentState) return
+  if (!keyInParentState || options.preventInheritedStateUpdate) return
 
-  if (!options.preventInitStateUpdateListener && !options.updateByState) {
-    const initStateReturns = triggerEventOn('initStateUpdated', element, keyInParentState)
+  if (!options.preventInitStateUpdateListener) {
+    const initStateReturns = triggerEventOnUpdate('initStateUpdated', keyInParentState, element, options)
     if (initStateReturns === false) return element
   }
 
+  const newState = createStateUpdate(element, parent, options)
+
+  if (!options.preventStateUpdateListener) {
+    triggerEventOnUpdate('stateUpdated', newState.parse(), element, options)
+  }
+}
+
+const createStateUpdate = (element, parent, options) => {
+  const __stateChildren = element.state.__children
   const newState = createState(element, parent)
   element.state = newState
-
-  if (!options.preventStateUpdateListener && !options.updateByState) {
-    triggerEventOn('stateUpdated', element, newState.parse())
+  for (const child in __stateChildren) {
+    // check this for inherited states
+    if (newState[child]) newState.__children[child] = __stateChildren[child]
+    __stateChildren[child].parent = newState
   }
+  return newState
 }
 
 export default update