@domql/state 2.3.119 → 2.3.121

package/createState.js

@@ -9,68 +9,68 @@ import { checkIfInherits, createInheritedState } from './utils'
 
 export const createState = function (element, parent, opts) {
   const skip = (opts && opts.skip) ? opts.skip : false
-  let { state, __ref: __elementRef } = element
 
-  state = checkForTypes(element)
+  const objectizeState = checkForTypes(element)
+  if (objectizeState === false) return parent.state || {}
+  else element.state = objectizeState
 
-  triggerEventOn('stateInit', element)
+  const whatInitReturns = triggerEventOn('stateInit', element)
+  if (whatInitReturns === false) return element.state
 
   if (checkIfInherits(element)) {
-    state = element.state = createInheritedState(element, parent) || {}
+    element.state = createInheritedState(element, parent) || {}
   }
 
-  if (!state) {
-    if (parent && parent.state) return parent.state
-    return {}
-  } else {
-    __elementRef.__hasRootState = true
-  }
-
-  // reference other state
-  // TODO: check why __ref is assigned with element
-  // /docs/intro
-  const { __ref } = state
-  if (__ref) {
-    state = deepClone(__ref, IGNORE_STATE_PARAMS)
-    if (isObject(__ref.__depends)) {
-      __ref.__depends[element.key] = state
-    } else __ref.__depends = { [element.key]: state }
-  } else {
-    state = deepClone(state, IGNORE_STATE_PARAMS)
-  }
-
-  element.state = state
+  const dependentState = applyDependentState(element, state)
+  if (dependentState) element.state = dependentState
 
   // NOTE: Only true when 'onlyResolveExtends' option is set to true
-  if (skip) return state
+  if (skip) return element.state
 
-  applyMethods(element, state)
+  applyMethods(element)
 
   // trigger `on.stateCreated`
   triggerEventOn('stateCreated', element)
 
-  return state
+  return element.state
+}
+
+const applyDependentState = (element, state) => {
+  const { __ref: ref } = state
+  if (!ref) return
+  const dependentState = deepClone(ref, IGNORE_STATE_PARAMS)
+  const newDepends = { [element.key]: dependentState }
+  ref.__depends = isObject(ref.__depends)
+    ? { ...ref.__depends, ...newDepends }
+    : newDepends
+
+  return dependentState
 }
 
 const checkForTypes = (element) => {
-  const { state, __ref: __elementRef } = element
+  const { state, __ref: ref } = element
   if (isFunction(state)) {
-    __elementRef.__state = state
+    ref.__state = state
     return exec(state, element)
   }
   if (is(state)('string', 'number')) {
-    __elementRef.__state = state
+    ref.__state = state
     return {}
   }
   if (state === true) {
-    __elementRef.__state = element.key
+    ref.__state = element.key
     return {}
   }
-  return state
+  if (state) {
+    ref.__hasRootState = true
+    return state
+  }
+  return false
 }
 
-const applyMethods = (element, state) => {
-  const __elementRef = element.__ref
+const applyMethods = (element) => {
+  const state = element.state
+  const ref = element.__ref
 
   state.clean = clean
   state.parse = parse
@@ -85,7 +85,7 @@ const applyMethods = (element, state) => {
   state.parent = element.parent.state
   state.__element = element
   state.__children = {}
-  state.__root = __elementRef.__root ? __elementRef.__root.state : state
+  state.__root = ref.__root ? ref.__root.state : state
 
   if (state.parent) state.parent.__children[element.key] = state
 }

package/dist/cjs/createState.js

@@ -29,68 +29,72 @@ var import_updateState = require("./updateState");
 var import_utils2 = require("./utils");
 const createState = function(element, parent, opts) {
   const skip = opts && opts.skip ? opts.skip : false;
-  let { state, __ref: __elementRef } = element;
-  state = checkForTypes(element);
-  (0, import_event.triggerEventOn)("stateInit", element);
+  const objectizeState = checkForTypes(element);
+  if (objectizeState === false)
+    return parent.state || {};
+  else
+    element.state = objectizeState;
+  const whatInitReturns = (0, import_event.triggerEventOn)("stateInit", element);
+  if (whatInitReturns === false)
+    return element.state;
   if ((0, import_utils2.checkIfInherits)(element)) {
-    state = element.state = (0, import_utils2.createInheritedState)(element, parent) || {};
+    element.state = (0, import_utils2.createInheritedState)(element, parent) || {};
   }
-  if (!state) {
-    if (parent && parent.state)
-      return parent.state;
-    return {};
-  } else {
-    __elementRef.__hasRootState = true;
-  }
-  const { __ref } = state;
-  if (__ref) {
-    state = (0, import_utils.deepClone)(__ref, import_ignore.IGNORE_STATE_PARAMS);
-    if ((0, import_utils.isObject)(__ref.__depends)) {
-      __ref.__depends[element.key] = state;
-    } else
-      __ref.__depends = { [element.key]: state };
-  } else {
-    state = (0, import_utils.deepClone)(state, import_ignore.IGNORE_STATE_PARAMS);
-  }
-  element.state = state;
+  const dependentState = applyDependentState(element, state);
+  if (dependentState)
+    element.state = dependentState;
   if (skip)
-    return state;
-  applyMethods(element, state);
+    return element.state;
+  applyMethods(element);
   (0, import_event.triggerEventOn)("stateCreated", element);
-  return state;
+  return element.state;
+};
+const applyDependentState = (element, state2) => {
+  const { __ref: ref } = state2;
+  if (!ref)
+    return;
+  const dependentState = (0, import_utils.deepClone)(ref, import_ignore.IGNORE_STATE_PARAMS);
+  const newDepends = { [element.key]: dependentState };
+  ref.__depends = (0, import_utils.isObject)(ref.__depends) ? { ...ref.__depends, ...newDepends } : newDepends;
+  return dependentState;
 };
 const checkForTypes = (element) => {
-  const { state, __ref: __elementRef } = element;
-  if ((0, import_utils.isFunction)(state)) {
-    __elementRef.__state = state;
-    return (0, import_utils.exec)(state, element);
+  const { state: state2, __ref: ref } = element;
+  if ((0, import_utils.isFunction)(state2)) {
+    ref.__state = state2;
+    return (0, import_utils.exec)(state2, element);
   }
-  if ((0, import_utils.is)(state)("string", "number")) {
-    __elementRef.__state = state;
+  if ((0, import_utils.is)(state2)("string", "number")) {
+    ref.__state = state2;
     return {};
   }
-  if (state === true) {
-    __elementRef.__state = element.key;
+  if (state2 === true) {
+    ref.__state = element.key;
     return {};
   }
-  return state;
+  if (state2) {
+    ref.__hasRootState = true;
+    return state2;
+  }
+  return false;
 };
-const applyMethods = (element, state) => {
-  const __elementRef = element.__ref;
-  state.clean = import_methods.clean;
-  state.parse = import_methods.parse;
-  state.destroy = import_methods.destroy;
-  state.update = import_updateState.updateState;
-  state.rootUpdate = import_methods.rootUpdate;
-  state.create = createState;
-  state.add = import_methods.add;
-  state.toggle = import_methods.toggle;
-  state.remove = import_methods.remove;
-  state.apply = import_methods.apply;
-  state.parent = element.parent.state;
-  state.__element = element;
-  state.__children = {};
-  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
-  if (state.parent)
-    state.parent.__children[element.key] = state;
+const applyMethods = (element) => {
+  const state2 = element.state;
+  const ref = element.__ref;
+  state2.clean = import_methods.clean;
+  state2.parse = import_methods.parse;
+  state2.destroy = import_methods.destroy;
+  state2.update = import_updateState.updateState;
+  state2.rootUpdate = import_methods.rootUpdate;
+  state2.create = createState;
+  state2.add = import_methods.add;
+  state2.toggle = import_methods.toggle;
+  state2.remove = import_methods.remove;
+  state2.apply = import_methods.apply;
+  state2.parent = element.parent.state;
+  state2.__element = element;
+  state2.__children = {};
+  state2.__root = ref.__root ? ref.__root.state : state2;
+  if (state2.parent)
+    state2.parent.__children[element.key] = state2;
 };

package/dist/cjs/updateState.js

@@ -29,8 +29,6 @@ var import_utils2 = require("./utils");
 const updateState = function(obj, options = {}) {
   const state = this;
   const element = state.__element;
-  const parentState = element.parent.state;
-  state.parent = parentState;
   if (!state.__element)
     (0, import_report.report)("ElementOnStateIsNotDefined");
   if (!options.preventInitStateUpdateListener) {
@@ -40,7 +38,7 @@ const updateState = function(obj, options = {}) {
   }
   applyOverwrite(state, obj, options);
   hoistStateUpdate(state, obj, options);
-  applyDependentState(state, obj, options);
+  updateDependentState(state, obj, options);
   applyElementUpdate(state, obj, options);
   if (!options.preventStateUpdateListener) {
     (0, import_event.triggerEventOn)("stateUpdated", element, obj);
@@ -48,41 +46,43 @@ const updateState = function(obj, options = {}) {
   return state;
 };
 const applyOverwrite = (state, obj, options) => {
-  if (!options.skipOverwrite) {
-    if (options.shallow) {
-      (0, import_utils.overwriteShallow)(state, obj, import_ignore.IGNORE_STATE_PARAMS);
-    } else {
-      (0, import_utils.overwriteDeep)(state, obj, import_ignore.IGNORE_STATE_PARAMS);
-    }
-  } else if (options.skipOverwrite === "merge") {
+  const { skipOverwrite, shallow } = options;
+  if (skipOverwrite === "merge") {
     (0, import_utils.deepMerge)(state, obj, import_ignore.IGNORE_STATE_PARAMS);
+    return;
+  }
+  if (!skipOverwrite) {
+    const overwriteFunc = shallow ? import_utils.overwriteShallow : import_utils.overwriteDeep;
+    overwriteFunc(state, obj, import_ignore.IGNORE_STATE_PARAMS);
   }
 };
 const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element;
   const __elementRef = element.__ref;
   const stateKey = __elementRef.__state;
-  const hasParentState = (0, import_utils2.checkIfInherits)(element);
-  const shouldPropagateState = stateKey && hasParentState && !options.stopStatePropagation;
+  if (!stateKey)
+    return;
+  const asksForInherit = (0, import_utils2.checkIfInherits)(element);
+  const shouldPropagateState = asksForInherit && !options.stopStatePropagation;
   const parentState = element.parent.state;
-  if (shouldPropagateState) {
-    const isStringState = __elementRef.__stateType === "string";
-    const value = isStringState ? state.value : state.parse();
-    const passedValue = isStringState ? state.value : obj;
-    parentState[stateKey] = value;
-    parentState.update({ [stateKey]: passedValue }, {
-      skipOverwrite: true,
-      preventUpdate: options.preventHoistElementUpdate,
-      ...options
-    });
-  }
+  if (!shouldPropagateState)
+    return;
+  const isStringState = __elementRef.__stateType === "string";
+  const value = isStringState ? state.value : state.parse();
+  const passedValue = isStringState ? state.value : obj;
+  parentState[stateKey] = value;
+  parentState.update({ [stateKey]: passedValue }, {
+    skipOverwrite: true,
+    preventUpdate: options.preventHoistElementUpdate,
+    ...options
+  });
 };
-const applyDependentState = (state, obj, options) => {
-  if (state.__depends) {
-    for (const el in state.__depends) {
-      const findElement = state.__depends[el];
-      findElement.clean().update(state.parse(), options);
-    }
+const updateDependentState = (state, obj, options) => {
+  if (!state.__depends)
+    return;
+  for (const el in state.__depends) {
+    const dependentState = state.__depends[el];
+    dependentState.clean().update(state.parse(), options);
   }
 };
 const applyElementUpdate = (state, obj, options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "2.3.119",
+  "version": "2.3.121",
   "license": "MIT",
   "type": "module",
   "module": "dist/esm/index.js",
@@ -26,5 +26,5 @@
     "@domql/report": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "b5b409c827c8b21896d84918f4fe9d133b057916"
+  "gitHead": "7bb63fd5aab7bfa92c0aaa3a7205ff9a002fac1c"
 }

package/updateState.js

@@ -9,8 +9,6 @@ import { checkIfInherits } from './utils'
 export const updateState = function (obj, options = {}) {
   const state = this
   const element = state.__element
-  const parentState = element.parent.state
-  state.parent = parentState
 
   if (!state.__element) report('ElementOnStateIsNotDefined')
 
@@ -23,7 +21,7 @@ export const updateState = function (obj, options = {}) {
 
   hoistStateUpdate(state, obj, options)
 
-  applyDependentState(state, obj, options)
+  updateDependentState(state, obj, options)
 
   applyElementUpdate(state, obj, options)
 
@@ -35,14 +33,16 @@ export const updateState = function (obj, options = {}) {
 }
 
 const applyOverwrite = (state, obj, options) => {
-  if (!options.skipOverwrite) {
-    if (options.shallow) {
-      overwriteShallow(state, obj, IGNORE_STATE_PARAMS)
-    } else {
-      overwriteDeep(state, obj, IGNORE_STATE_PARAMS)
-    }
-  } else if (options.skipOverwrite === 'merge') {
+  const { skipOverwrite, shallow } = options
+
+  if (skipOverwrite === 'merge') {
     deepMerge(state, obj, IGNORE_STATE_PARAMS)
+    return
+  }
+
+  if (!skipOverwrite) {
+    const overwriteFunc = shallow ? overwriteShallow : overwriteDeep
+    overwriteFunc(state, obj, IGNORE_STATE_PARAMS)
   }
 }
 
@@ -50,30 +50,30 @@ const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element
   const __elementRef = element.__ref
   const stateKey = __elementRef.__state
-  const hasParentState = checkIfInherits(element)
-  const shouldPropagateState = stateKey && hasParentState && !options.stopStatePropagation
-  const parentState = element.parent.state
+  if (!stateKey) return
 
-  if (shouldPropagateState) {
-    const isStringState = (__elementRef.__stateType === 'string')
-    const value = isStringState ? state.value : state.parse()
-    const passedValue = isStringState ? state.value : obj
+  const asksForInherit = checkIfInherits(element)
+  const shouldPropagateState = asksForInherit && !options.stopStatePropagation
+  const parentState = element.parent.state
 
-    parentState[stateKey] = value
-    parentState.update({ [stateKey]: passedValue }, {
-      skipOverwrite: true,
-      preventUpdate: options.preventHoistElementUpdate,
-      ...options
-    })
-  }
+  if (!shouldPropagateState) return
+  const isStringState = (__elementRef.__stateType === 'string')
+  const value = isStringState ? state.value : state.parse()
+  const passedValue = isStringState ? state.value : obj
+
+  parentState[stateKey] = value
+  parentState.update({ [stateKey]: passedValue }, {
+    skipOverwrite: true,
+    preventUpdate: options.preventHoistElementUpdate,
+    ...options
+  })
 }
 
-const applyDependentState = (state, obj, options) => {
-  if (state.__depends) {
-    for (const el in state.__depends) {
-      const findElement = state.__depends[el]
-      findElement.clean().update(state.parse(), options)
-    }
+const updateDependentState = (state, obj, options) => {
+  if (!state.__depends) return
+  for (const el in state.__depends) {
+    const dependentState = state.__depends[el]
+    dependentState.clean().update(state.parse(), options)
   }
 }