@domql/state 2.5.198 → 3.0.0

package/dist/esm/updateState.js

@@ -19,9 +19,16 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { report } from "@domql/report";
 import { triggerEventOnUpdate } from "@domql/event";
-import { IGNORE_STATE_PARAMS } from "./ignore.js";
-import { deepMerge, merge, overwriteDeep, overwriteShallow } from "@domql/utils";
-import { checkIfInherits, createNestedObjectByKeyPath, findInheritedState, getParentStateInKey, getRootStateInKey } from "./inherit.js";
+import {
+  checkIfInherits,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getParentStateInKey,
+  getRootStateInKey,
+  merge,
+  overwriteDeep,
+  overwriteState
+} from "@domql/utils";
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
   preventHoistElementUpdate: false,
@@ -32,59 +39,43 @@ const STATE_UPDATE_OPTIONS = {
 const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
   const state = this;
   const element = state.__element;
-  if (options.onEach)
-    options.onEach(element, state, element.context, options);
-  if (!options.updateByState)
-    merge(options, STATE_UPDATE_OPTIONS);
-  if (!state.__element)
-    report("ElementOnStateIsNotDefined");
+  if (options.onEach) options.onEach(element, state, element.context, options);
+  if (!options.updateByState) merge(options, STATE_UPDATE_OPTIONS);
+  if (!state.__element) report("ElementOnStateIsNotDefined");
   if (options.preventInheritAtCurrentState === true) {
     options.preventInheritAtCurrentState = state;
-  } else if (options.preventInheritAtCurrentState)
-    return;
+  } else if (options.preventInheritAtCurrentState) return;
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await triggerEventOnUpdate("beforeStateUpdate", obj, element, options);
-    if (beforeStateUpdateReturns === false)
-      return element;
+    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+      "beforeStateUpdate",
+      obj,
+      element,
+      options
+    );
+    if (beforeStateUpdateReturns === false) return element;
   }
-  applyOverwrite(state, obj, options);
-  const updateIsHoisted = hoistStateUpdate(state, obj, options);
-  if (updateIsHoisted)
-    return state;
-  updateDependentState(state, obj, options);
-  applyElementUpdate(state, obj, options);
+  overwriteState(state, obj, options);
+  const updateIsHoisted = await hoistStateUpdate(state, obj, options);
+  if (updateIsHoisted) return state;
+  await updateDependentState(state, obj, options);
+  await applyElementUpdate(state, obj, options);
   if (!options.preventStateUpdateListener) {
     await triggerEventOnUpdate("stateUpdate", obj, element, options);
   }
   return state;
 };
-const applyOverwrite = (state, obj, options) => {
-  const { overwrite } = options;
-  if (!overwrite)
-    return;
-  const shallow = overwrite === "shallow" || overwrite === "shallow-once";
-  const merge2 = overwrite === "merge";
-  if (merge2) {
-    deepMerge(state, obj, IGNORE_STATE_PARAMS);
-    return;
-  }
-  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
-  if (options.overwrite === "shallow-once")
-    options.overwrite = true;
-  overwriteFunc(state, obj, IGNORE_STATE_PARAMS);
-};
-const hoistStateUpdate = (state, obj, options) => {
+const hoistStateUpdate = async (state, obj, options) => {
   const element = state.__element;
   const { parent, __ref: ref } = element;
   const stateKey = ref == null ? void 0 : ref.__state;
   const stateType = ref == null ? void 0 : ref.__stateType;
-  if (!stateKey)
-    return;
+  if (!stateKey) return;
   const asksForInherit = checkIfInherits(element);
-  const inheritedState = findInheritedState(element, parent, { returnParent: true });
+  const inheritedState = findInheritedState(element, parent, {
+    returnParent: true
+  });
   const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation;
-  if (!shouldPropagateState)
-    return;
+  if (!shouldPropagateState) return;
   const isStringState = stateType === "string" || stateType === "number" || stateType === "boolean";
   const value = isStringState ? state.value : state.parse();
   const passedValue = isStringState ? state.value : obj;
@@ -92,9 +83,8 @@ const hoistStateUpdate = (state, obj, options) => {
   const findGrandParentState = getParentStateInKey(stateKey, parent.state);
   const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
   const targetParent = findRootState || findGrandParentState || parent.state;
-  if (options.replace)
-    overwriteDeep(targetParent, changesValue || value);
-  targetParent.update(changesValue, __spreadValues({
+  if (options.replace) overwriteDeep(targetParent, changesValue || value);
+  await targetParent.update(changesValue, __spreadValues({
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -102,32 +92,39 @@ const hoistStateUpdate = (state, obj, options) => {
   }, options));
   const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    triggerEventOnUpdate("stateUpdate", obj, element, options);
+    await triggerEventOnUpdate("stateUpdate", obj, element, options);
   }
   return true;
 };
-const updateDependentState = (state, obj, options) => {
-  if (!state.__depends)
-    return;
+const updateDependentState = async (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 cleanState = await dependentState.clean();
+    await cleanState.update(state.parse(), options);
   }
 };
-const applyElementUpdate = (state, obj, options) => {
+const applyElementUpdate = async (state, obj, options) => {
   const element = state.__element;
   if (options.preventUpdate !== true) {
-    element.update({}, __spreadProps(__spreadValues({}, options), {
-      updateByState: true
-    }));
+    await element.update(
+      {},
+      __spreadProps(__spreadValues({}, options), {
+        updateByState: true
+      })
+    );
   } else if (options.preventUpdate === "recursive") {
-    element.update({}, __spreadProps(__spreadValues({}, options), {
-      isHoisted: false,
-      updateByState: true,
-      preventUpdate: true
-    }));
+    await element.update(
+      {},
+      __spreadProps(__spreadValues({}, options), {
+        isHoisted: false,
+        updateByState: true,
+        preventUpdate: true
+      })
+    );
   }
 };
 export {
+  hoistStateUpdate,
   updateState
 };

package/index.js

@@ -1,7 +1,5 @@
 'use strict'
 
-export * from './ignore.js'
 export * from './create.js'
 export * from './updateState.js'
 export * from './methods.js'
-export * from './inherit.js'

package/methods.js

@@ -12,40 +12,46 @@ import {
   createNestedObject,
   getInObjectByPath,
   removeNestedKeyByPath,
-  setInObjectByPath
+  setInObjectByPath,
+  STATE_METHODS,
+  addProtoToArray
 } from '@domql/utils'
 
-import { IGNORE_STATE_PARAMS } from './ignore.js'
+import { updateState } from './updateState.js'
+import { createState } from './create.js'
 
 export const parse = function () {
   const state = this
   if (isObject(state)) {
     const obj = {}
     for (const param in state) {
-      if (!IGNORE_STATE_PARAMS.includes(param)) {
+      if (!STATE_METHODS.includes(param)) {
         obj[param] = state[param]
       }
     }
     return obj
   } else if (isArray(state)) {
-    return state.filter(item => !IGNORE_STATE_PARAMS.includes(item))
+    return state.filter(item => !STATE_METHODS.includes(item))
   }
 }
 
-export const clean = function (options = {}) {
+export const clean = async function (options = {}) {
   const state = this
   for (const param in state) {
-    if (!IGNORE_STATE_PARAMS.includes(param) && Object.hasOwnProperty.call(state, param)) {
+    if (
+      !STATE_METHODS.includes(param) &&
+      Object.hasOwnProperty.call(state, param)
+    ) {
       delete state[param]
     }
   }
   if (!options.preventStateUpdate) {
-    state.update(state, { replace: true, ...options })
+    await state.update(state, { replace: true, ...options })
   }
   return state
 }
 
-export const destroy = function (options = {}) {
+export const destroy = async function (options = {}) {
   const state = this
   const element = state.__element
 
@@ -80,90 +86,99 @@ export const destroy = function (options = {}) {
     }
   }
 
-  element.state.update({}, { isHoisted: true, ...options })
+  await element.state.update({}, { isHoisted: true, ...options })
   return element.state
 }
 
-export const parentUpdate = function (obj, options = {}) {
+export const parentUpdate = async function (obj, options = {}) {
   const state = this
   if (!state || !state.parent) return
-  return state.parent.update(obj, { isHoisted: true, ...options })
+  return await state.parent.update(obj, { isHoisted: true, ...options })
 }
 
-export const rootUpdate = function (obj, options = {}) {
+export const rootUpdate = async function (obj, options = {}) {
   const state = this
   if (!state) return
-  const rootState = (state.__element.__ref.root).state
-  return rootState.update(obj, { isHoisted: false, ...options })
+  const rootState = state.__element.__ref.root.state
+  return await rootState.update(obj, { isHoisted: false, ...options })
 }
 
-export const add = function (value, options = {}) {
+export const add = async function (value, options = {}) {
   const state = this
   if (isArray(state)) {
     state.push(value)
-    state.update(state.parse(), { overwrite: true, ...options })
+    await state.update(state.parse(), { overwrite: true, ...options })
   } else if (isObject(state)) {
     const key = Object.keys(state).length
-    state.update({ [key]: value }, options)
+    await state.update({ [key]: value }, options)
   }
 }
 
-export const toggle = function (key, options = {}) {
+export const toggle = async function (key, options = {}) {
   const state = this
-  state.update({ [key]: !state[key] }, options)
+  await state.update({ [key]: !state[key] }, options)
 }
 
-export const remove = function (key, options = {}) {
+export const remove = async function (key, options = {}) {
   const state = this
   if (isArray(state)) removeFromArray(state, key)
   if (isObject(state)) removeFromObject(state, key)
-  if (options.applyReset) return state.set(state.parse(), { replace: true, ...options })
-  return state.update()
+  if (options.applyReset) {
+    return await state.set(state.parse(), { replace: true, ...options })
+  }
+  return await state.update({}, options)
 }
 
-export const set = function (val, options = {}) {
+export const set = async function (val, options = {}) {
   const state = this
   const value = deepClone(val)
-  return state.clean({ preventStateUpdate: true, ...options })
-    .update(value, { replace: true, ...options })
+  const cleanState = await state.clean({ preventStateUpdate: true, ...options })
+  return await cleanState.update(value, { replace: true, ...options })
 }
 
-export const setByPath = function (path, val, options = {}) {
+export const setByPath = async function (path, val, options = {}) {
   const state = this
   const value = deepClone(val)
   setInObjectByPath(state, path, val)
   const update = createNestedObject(path, value)
   if (options.preventStateUpdate) return update
-  return state.update(update, options)
+  return await state.update(update, options)
 }
 
-export const setPathCollection = function (changes, options = {}) {
+export const setPathCollection = async function (changes, options = {}) {
   const state = this
-  const update = changes.reduce((acc, change) => {
+  const update = await changes.reduce(async (promise, change) => {
+    const acc = await promise
     if (change[0] === 'update') {
-      const result = setByPath.call(state, change[1], change[2], { preventStateUpdate: true })
+      const result = setByPath.call(state, change[1], change[2], {
+        preventStateUpdate: true
+      })
       return overwriteDeep(acc, result)
     } else if (change[0] === 'delete') {
-      removeByPath.call(state, change[1], options)
+      await removeByPath.call(state, change[1], {
+        ...options,
+        preventUpdate: true
+      })
     }
     return acc
-  }, {})
+  }, Promise.resolve({}))
+
   return state.update(update, options)
 }
 
-export const removeByPath = function (path, options = {}) {
+export const removeByPath = async function (path, options = {}) {
   const state = this
   removeNestedKeyByPath(state, path)
   if (options.preventUpdate) return path
-  return state.update({}, options)
+  return await state.update({}, options)
 }
 
-export const removePathCollection = function (changes, options = {}) {
+export const removePathCollection = async function (changes, options = {}) {
   const state = this
-  changes.forEach(item => {
-    removeByPath(item, { preventUpdate: true })
+  changes.forEach(async item => {
+    await removeByPath(item, { preventUpdate: true })
   })
-  return state.update({}, options)
+  return await state.update({}, options)
 }
 
 export const getByPath = function (path, options = {}) {
@@ -171,54 +186,54 @@ export const getByPath = function (path, options = {}) {
   return getInObjectByPath(state, path)
 }
 
-export const reset = function (options = {}) {
+export const reset = async function (options = {}) {
   const state = this
   const value = deepClone(state.parse())
-  return state.set(value, { replace: true, ...options })
+  return await state.set(value, { replace: true, ...options })
 }
 
-export const apply = function (func, options = {}) {
+export const apply = async function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return state.update(value, { replace: true, ...options })
+    return await state.update(value, { replace: true, ...options })
   }
 }
 
-export const applyReplace = function (func, options = {}) {
+export const applyReplace = async function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return state.replace(value, options)
+    return await state.replace(value, options)
   }
 }
 
-export const applyFunction = function (func, options = {}) {
+export const applyFunction = async function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
-    func(state)
-    return state.update(state.parse(), { replace: true, ...options })
+    await func(state)
+    return await state.update(state.parse(), { replace: true, ...options })
   }
 }
 
-export const quietUpdate = function (obj, options = {}) {
+export const quietUpdate = async function (obj, options = {}) {
   const state = this
-  return state.update(obj, { preventUpdate: true, ...options })
+  return await state.update(obj, { preventUpdate: true, ...options })
 }
 
-export const replace = function (obj, options = {}) {
+export const replace = async function (obj, options = {}) {
   const state = this
 
   for (const param in obj) {
     state[param] = obj[param]
   }
 
-  return state.update(obj, options)
+  return await state.update(obj, options)
 }
 
-export const quietReplace = function (obj, options = {}) {
+export const quietReplace = async function (obj, options = {}) {
   const state = this
-  return state.replace(obj, { preventUpdate: true, ...options })
+  return await state.replace(obj, { preventUpdate: true, ...options })
 }
 
 export const keys = function (obj, options = {}) {
@@ -230,3 +245,52 @@ export const values = function (obj, options = {}) {
   const state = this
   return Object.values(state)
 }
+
+export const applyStateMethods = element => {
+  const state = element.state
+  const ref = element.__ref
+
+  const proto = {
+    clean: clean.bind(state),
+    parse: parse.bind(state),
+    destroy: destroy.bind(state),
+    update: updateState.bind(state),
+    rootUpdate: rootUpdate.bind(state),
+    parentUpdate: parentUpdate.bind(state),
+    create: createState.bind(state),
+    add: add.bind(state),
+    toggle: toggle.bind(state),
+    remove: remove.bind(state),
+    apply: apply.bind(state),
+    applyReplace: applyReplace.bind(state),
+    applyFunction: applyFunction.bind(state),
+    set: set.bind(state),
+    quietUpdate: quietUpdate.bind(state),
+    replace: replace.bind(state),
+    quietReplace: quietReplace.bind(state),
+    reset: reset.bind(state),
+    parent: element.parent?.state || state,
+
+    setByPath: setByPath.bind(state),
+    setPathCollection: setPathCollection.bind(state),
+    removeByPath: removeByPath.bind(state),
+    removePathCollection: removePathCollection.bind(state),
+    getByPath: getByPath.bind(state),
+
+    keys: keys.bind(state),
+    values: values.bind(state),
+    __element: element,
+    __children: {},
+    root: ref?.root ? ref.root.state : state
+  }
+
+  if (isArray(state)) {
+    addProtoToArray(state, proto)
+  } else {
+    Object.setPrototypeOf(state, proto)
+  }
+
+  if (state.parent && state.parent.__children) {
+    state.parent.__children[element.key] = state
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "2.5.198",
+  "version": "3.0.0",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -28,9 +28,9 @@
     "prepublish": "rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.5.190",
-    "@domql/report": "^2.5.186",
-    "@domql/utils": "^2.5.187"
+    "@domql/event": "^3.0.0",
+    "@domql/report": "^3.0.0",
+    "@domql/utils": "^3.0.0"
   },
-  "gitHead": "045032f5c80a92a1a05b0dfff68c93c9b32e6bd9"
+  "gitHead": "bcbdc271a602b958de6a60ab387ea7715a935dc1"
 }

package/updateState.js

@@ -2,9 +2,16 @@
 
 import { report } from '@domql/report'
 import { triggerEventOnUpdate } from '@domql/event'
-import { IGNORE_STATE_PARAMS } from './ignore.js'
-import { deepMerge, merge, overwriteDeep, overwriteShallow } from '@domql/utils'
-import { checkIfInherits, createNestedObjectByKeyPath, findInheritedState, getParentStateInKey, getRootStateInKey } from './inherit.js'
+import {
+  checkIfInherits,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getParentStateInKey,
+  getRootStateInKey,
+  merge,
+  overwriteDeep,
+  overwriteState
+} from '@domql/utils'
 
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
@@ -14,7 +21,10 @@ const STATE_UPDATE_OPTIONS = {
   execStateFunction: true
 }
 
-export const updateState = async function (obj, options = STATE_UPDATE_OPTIONS) {
+export const updateState = async function (
+  obj,
+  options = STATE_UPDATE_OPTIONS
+) {
   const state = this
   const element = state.__element
 
@@ -28,17 +38,22 @@ export const updateState = async function (obj, options = STATE_UPDATE_OPTIONS)
   } else if (options.preventInheritAtCurrentState) return
 
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await triggerEventOnUpdate('beforeStateUpdate', obj, element, options)
+    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+      'beforeStateUpdate',
+      obj,
+      element,
+      options
+    )
     if (beforeStateUpdateReturns === false) return element
   }
 
-  applyOverwrite(state, obj, options)
-  const updateIsHoisted = hoistStateUpdate(state, obj, options)
+  overwriteState(state, obj, options)
+  const updateIsHoisted = await hoistStateUpdate(state, obj, options)
   if (updateIsHoisted) return state
 
-  updateDependentState(state, obj, options)
+  await updateDependentState(state, obj, options)
 
-  applyElementUpdate(state, obj, options)
+  await applyElementUpdate(state, obj, options)
 
   if (!options.preventStateUpdateListener) {
     await triggerEventOnUpdate('stateUpdate', obj, element, options)
@@ -47,24 +62,7 @@ export const updateState = async function (obj, options = STATE_UPDATE_OPTIONS)
   return state
 }
 
-const applyOverwrite = (state, obj, options) => {
-  const { overwrite } = options
-  if (!overwrite) return
-
-  const shallow = overwrite === 'shallow' || overwrite === 'shallow-once'
-  const merge = overwrite === 'merge'
-
-  if (merge) {
-    deepMerge(state, obj, IGNORE_STATE_PARAMS)
-    return
-  }
-
-  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep
-  if (options.overwrite === 'shallow-once') options.overwrite = true
-  overwriteFunc(state, obj, IGNORE_STATE_PARAMS)
-}
-
-const hoistStateUpdate = (state, obj, options) => {
+export const hoistStateUpdate = async (state, obj, options) => {
   const element = state.__element
   const { parent, __ref: ref } = element
 
@@ -73,11 +71,15 @@ const hoistStateUpdate = (state, obj, options) => {
   if (!stateKey) return
 
   const asksForInherit = checkIfInherits(element)
-  const inheritedState = findInheritedState(element, parent, { returnParent: true })
-  const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation
+  const inheritedState = findInheritedState(element, parent, {
+    returnParent: true
+  })
+  const shouldPropagateState =
+    asksForInherit && inheritedState && !options.stopStatePropagation
   if (!shouldPropagateState) return
 
-  const isStringState = (stateType === 'string' || stateType === 'number' || stateType === 'boolean')
+  const isStringState =
+    stateType === 'string' || stateType === 'number' || stateType === 'boolean'
   const value = isStringState ? state.value : state.parse()
   const passedValue = isStringState ? state.value : obj
 
@@ -86,41 +88,49 @@ const hoistStateUpdate = (state, obj, options) => {
   const changesValue = createNestedObjectByKeyPath(stateKey, passedValue)
   const targetParent = findRootState || findGrandParentState || parent.state
   if (options.replace) overwriteDeep(targetParent, changesValue || value) // check with createNestedObjectByKeyPath
-  targetParent.update(changesValue, {
+  await targetParent.update(changesValue, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
     overwrite: !options.replace,
     ...options
   })
-  const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate
+  const hasNotUpdated =
+    options.preventUpdate !== true || !options.preventHoistElementUpdate
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    triggerEventOnUpdate('stateUpdate', obj, element, options)
+    await triggerEventOnUpdate('stateUpdate', obj, element, options)
   }
   return true
 }
 
-const updateDependentState = (state, obj, options) => {
+const updateDependentState = async (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 cleanState = await dependentState.clean()
+    await cleanState.update(state.parse(), options)
   }
 }
 
-const applyElementUpdate = (state, obj, options) => {
+const applyElementUpdate = async (state, obj, options) => {
   const element = state.__element
   if (options.preventUpdate !== true) {
-    element.update({}, {
-      ...options,
-      updateByState: true
-    })
+    await element.update(
+      {},
+      {
+        ...options,
+        updateByState: true
+      }
+    )
   } else if (options.preventUpdate === 'recursive') {
-    element.update({}, {
-      ...options,
-      isHoisted: false,
-      updateByState: true,
-      preventUpdate: true
-    })
+    await element.update(
+      {},
+      {
+        ...options,
+        isHoisted: false,
+        updateByState: true,
+        preventUpdate: true
+      }
+    )
   }
 }