@domql/state 3.1.1 → 3.2.3

package/create.js

@@ -11,17 +11,17 @@ import {
 
 import { applyStateMethods } from './methods'
 
-export const createState = async function (element, parent, options) {
-  element.state = await applyInitialState(element, parent, options)
+export const createState = function (element, parent, options) {
+  element.state = applyInitialState(element, parent, options)
   return element.state
 }
 
-export const applyInitialState = async function (element, parent, options) {
-  const objectizeState = await checkForStateTypes(element)
+export const applyInitialState = function (element, parent, options) {
+  const objectizeState = checkForStateTypes(element)
   if (objectizeState === false) return parent.state || {}
   else element.state = objectizeState
 
-  const whatInitReturns = await triggerEventOn('stateInit', element, options)
+  const whatInitReturns = triggerEventOn('stateInit', element, options)
   if (whatInitReturns === false) return element.state
 
   if (checkIfInherits(element)) {
@@ -29,7 +29,7 @@ export const applyInitialState = async function (element, parent, options) {
     element.state = isUndefined(inheritedState) ? {} : inheritedState
   }
 
-  const dependentState = await applyDependentState(
+  const dependentState = applyDependentState(
     element,
     element.state || parent.state || {}
   )
@@ -38,7 +38,7 @@ export const applyInitialState = async function (element, parent, options) {
   applyStateMethods(element)
 
   // trigger `on.stateCreated`
-  await triggerEventOn('stateCreated', element)
+  triggerEventOn('stateCreated', element)
 
   return element.state
 }

package/dist/cjs/create.js

@@ -25,26 +25,26 @@ module.exports = __toCommonJS(create_exports);
 var import_event = require("@domql/event");
 var import_utils = require("@domql/utils");
 var import_methods = require("./methods");
-const createState = async function(element, parent, options) {
-  element.state = await applyInitialState(element, parent, options);
+const createState = function(element, parent, options) {
+  element.state = applyInitialState(element, parent, options);
   return element.state;
 };
-const applyInitialState = async function(element, parent, options) {
-  const objectizeState = await (0, import_utils.checkForStateTypes)(element);
+const applyInitialState = function(element, parent, options) {
+  const objectizeState = (0, import_utils.checkForStateTypes)(element);
   if (objectizeState === false) return parent.state || {};
   else element.state = objectizeState;
-  const whatInitReturns = await (0, import_event.triggerEventOn)("stateInit", element, options);
+  const whatInitReturns = (0, import_event.triggerEventOn)("stateInit", element, options);
   if (whatInitReturns === false) return element.state;
   if ((0, import_utils.checkIfInherits)(element)) {
     const inheritedState = (0, import_utils.createInheritedState)(element, parent);
     element.state = (0, import_utils.isUndefined)(inheritedState) ? {} : inheritedState;
   }
-  const dependentState = await (0, import_utils.applyDependentState)(
+  const dependentState = (0, import_utils.applyDependentState)(
     element,
     element.state || parent.state || {}
   );
   if (dependentState) element.state = dependentState;
   (0, import_methods.applyStateMethods)(element);
-  await (0, import_event.triggerEventOn)("stateCreated", element);
+  (0, import_event.triggerEventOn)("stateCreated", element);
   return element.state;
 };

package/dist/cjs/methods.js

@@ -61,7 +61,7 @@ const parse = function() {
     return state.filter((item) => !import_utils.STATE_METHODS.includes(item));
   }
 };
-const clean = async function(options = {}) {
+const clean = function(options = {}) {
   const state = this;
   for (const param in state) {
     if (!import_utils.STATE_METHODS.includes(param) && Object.hasOwnProperty.call(state, param)) {
@@ -69,11 +69,11 @@ const clean = async function(options = {}) {
     }
   }
   if (!options.preventStateUpdate) {
-    await state.update(state, { replace: true, ...options });
+    state.update(state, { replace: true, ...options });
   }
   return state;
 };
-const destroy = async function(options = {}) {
+const destroy = function(options = {}) {
   const state = this;
   const element = state.__element;
   const stateKey = element.__ref.__state;
@@ -106,68 +106,68 @@ const destroy = async function(options = {}) {
       }
     }
   }
-  await element.state.update({}, { isHoisted: true, ...options });
+  element.state.update({}, { isHoisted: true, ...options });
   return element.state;
 };
-const parentUpdate = async function(obj, options = {}) {
+const parentUpdate = function(obj, options = {}) {
   const state = this;
   if (!state || !state.parent) return;
-  return await state.parent.update(obj, { isHoisted: true, ...options });
+  return state.parent.update(obj, { isHoisted: true, ...options });
 };
-const rootUpdate = async function(obj, options = {}) {
+const rootUpdate = function(obj, options = {}) {
   const state = this;
   if (!state) return;
   const rootState = state.__element.__ref.root.state;
-  return await rootState.update(obj, { isHoisted: false, ...options });
+  return rootState.update(obj, { isHoisted: false, ...options });
 };
-const add = async function(value, options = {}) {
+const add = function(value, options = {}) {
   const state = this;
   if ((0, import_utils.isArray)(state)) {
     state.push(value);
-    await state.update(state.parse(), { overwrite: true, ...options });
+    state.update(state.parse(), { overwrite: true, ...options });
   } else if ((0, import_utils.isObject)(state)) {
     const key = Object.keys(state).length;
-    await state.update({ [key]: value }, options);
+    state.update({ [key]: value }, options);
   }
 };
-const toggle = async function(key, options = {}) {
+const toggle = function(key, options = {}) {
   const state = this;
-  await state.update({ [key]: !state[key] }, options);
+  state.update({ [key]: !state[key] }, options);
 };
-const remove = async function(key, options = {}) {
+const remove = function(key, options = {}) {
   const state = this;
   if ((0, import_utils.isArray)(state)) (0, import_utils.removeFromArray)(state, key);
   if ((0, import_utils.isObject)(state)) (0, import_utils.removeFromObject)(state, key);
   if (options.applyReset) {
-    return await state.set(state.parse(), { replace: true, ...options });
+    return state.set(state.parse(), { replace: true, ...options });
   }
-  return await state.update({}, options);
+  return state.update({}, options);
 };
-const set = async function(val, options = {}) {
+const set = function(val, options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(val);
-  const cleanState = await state.clean({ preventStateUpdate: true, ...options });
-  return await cleanState.update(value, { replace: true, ...options });
+  const cleanState = state.clean({ preventStateUpdate: true, ...options });
+  return cleanState.update(value, { replace: true, ...options });
 };
-const setByPath = async function(path, val, options = {}) {
+const setByPath = function(path, val, options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(val);
-  (0, import_utils.setInObjectByPath)(state, path, val);
+  if (!options.preventReplace) (0, import_utils.setInObjectByPath)(state, path, val);
   const update = (0, import_utils.createNestedObject)(path, value);
   if (options.preventStateUpdate) return update;
-  return await state.update(update, options);
+  return state.update(update, options);
 };
-const setPathCollection = async function(changes, options = {}) {
+const setPathCollection = function(changes, options = {}) {
   const state = this;
-  const update = await changes.reduce(async (promise, change) => {
-    const acc = await promise;
+  const update = changes.reduce((promise, change) => {
+    const acc = promise;
     if (change[0] === "update") {
       const result = setByPath.call(state, change[1], change[2], {
         preventStateUpdate: true
       });
       return (0, import_utils.overwriteDeep)(acc, result);
     } else if (change[0] === "delete") {
-      await removeByPath.call(state, change[1], {
+      removeByPath.call(state, change[1], {
         ...options,
         preventUpdate: true
       });
@@ -176,63 +176,63 @@ const setPathCollection = async function(changes, options = {}) {
   }, Promise.resolve({}));
   return state.update(update, options);
 };
-const removeByPath = async function(path, options = {}) {
+const removeByPath = function(path, options = {}) {
   const state = this;
   (0, import_utils.removeNestedKeyByPath)(state, path);
   if (options.preventUpdate) return path;
-  return await state.update({}, options);
+  return state.update({}, options);
 };
-const removePathCollection = async function(changes, options = {}) {
+const removePathCollection = function(changes, options = {}) {
   const state = this;
-  changes.forEach(async (item) => {
-    await removeByPath(item, { preventUpdate: true });
+  changes.forEach((item) => {
+    removeByPath(item, { preventUpdate: true });
   });
-  return await state.update({}, options);
+  return state.update({}, options);
 };
 const getByPath = function(path, options = {}) {
   const state = this;
   return (0, import_utils.getInObjectByPath)(state, path);
 };
-const reset = async function(options = {}) {
+const reset = function(options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(state.parse());
-  return await state.set(value, { replace: true, ...options });
+  return state.set(value, { replace: true, ...options });
 };
-const apply = async function(func, options = {}) {
+const apply = function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
     const value = func(state);
-    return await state.update(value, { replace: true, ...options });
+    return state.update(value, { replace: true, ...options });
   }
 };
-const applyReplace = async function(func, options = {}) {
+const applyReplace = function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
     const value = func(state);
-    return await state.replace(value, options);
+    return state.replace(value, options);
   }
 };
-const applyFunction = async function(func, options = {}) {
+const applyFunction = function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
-    await func(state);
-    return await state.update(state.parse(), { replace: true, ...options });
+    func(state);
+    return state.update(state.parse(), { replace: true, ...options });
   }
 };
-const quietUpdate = async function(obj, options = {}) {
+const quietUpdate = function(obj, options = {}) {
   const state = this;
-  return await state.update(obj, { preventUpdate: true, ...options });
+  return state.update(obj, { preventUpdate: true, ...options });
 };
-const replace = async function(obj, options = {}) {
+const replace = function(obj, options = {}) {
   const state = this;
   for (const param in obj) {
     state[param] = obj[param];
   }
-  return await state.update(obj, options);
+  return state.update(obj, options);
 };
-const quietReplace = async function(obj, options = {}) {
+const quietReplace = function(obj, options = {}) {
   const state = this;
-  return await state.replace(obj, { preventUpdate: true, ...options });
+  return state.replace(obj, { preventUpdate: true, ...options });
 };
 const keys = function(obj, options = {}) {
   const state = this;

package/dist/cjs/updateState.js

@@ -32,7 +32,7 @@ const STATE_UPDATE_OPTIONS = {
   isHoisted: true,
   execStateFunction: true
 };
-const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
+const updateState = function(obj, options = STATE_UPDATE_OPTIONS) {
   const state = this;
   const element = state.__element;
   if (options.onEach) options.onEach(element, state, element.context, options);
@@ -42,7 +42,7 @@ const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
     options.preventInheritAtCurrentState = state;
   } else if (options.preventInheritAtCurrentState) return;
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+    const beforeStateUpdateReturns = (0, import_event.triggerEventOnUpdate)(
       "beforeStateUpdate",
       obj,
       element,
@@ -51,16 +51,16 @@ const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
     if (beforeStateUpdateReturns === false) return element;
   }
   (0, import_utils.overwriteState)(state, obj, options);
-  const updateIsHoisted = await hoistStateUpdate(state, obj, options);
+  const updateIsHoisted = hoistStateUpdate(state, obj, options);
   if (updateIsHoisted) return state;
-  await updateDependentState(state, obj, options);
-  await applyElementUpdate(state, obj, options);
+  updateDependentState(state, obj, options);
+  applyElementUpdate(state, obj, options);
   if (!options.preventStateUpdateListener) {
-    await (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
+    (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
   }
   return state;
 };
-const hoistStateUpdate = async (state, obj, options) => {
+const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element;
   const { parent, __ref: ref } = element;
   const stateKey = ref == null ? void 0 : ref.__state;
@@ -80,7 +80,7 @@ const hoistStateUpdate = async (state, obj, options) => {
   const changesValue = (0, import_utils.createNestedObjectByKeyPath)(stateKey, passedValue);
   const targetParent = findRootState || findGrandParentState || parent.state;
   if (options.replace) (0, import_utils.overwriteDeep)(targetParent, changesValue || value);
-  await targetParent.update(changesValue, {
+  targetParent.update(changesValue, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -89,22 +89,22 @@ const hoistStateUpdate = async (state, obj, options) => {
   });
   const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    await (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
+    (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
   }
   return true;
 };
-const updateDependentState = async (state, obj, options) => {
+const updateDependentState = (state, obj, options) => {
   if (!state.__depends) return;
   for (const el in state.__depends) {
     const dependentState = state.__depends[el];
-    const cleanState = await dependentState.clean();
-    await cleanState.update(state.parse(), options);
+    const cleanState = dependentState.clean();
+    cleanState.update(state.parse(), options);
   }
 };
-const applyElementUpdate = async (state, obj, options) => {
+const applyElementUpdate = (state, obj, options) => {
   const element = state.__element;
   if (options.preventUpdate !== true) {
-    await element.update(
+    element.update(
       {},
       {
         ...options,
@@ -112,7 +112,7 @@ const applyElementUpdate = async (state, obj, options) => {
       }
     );
   } else if (options.preventUpdate === "recursive") {
-    await element.update(
+    element.update(
       {},
       {
         ...options,

package/dist/esm/create.js

@@ -7,27 +7,27 @@ import {
   isUndefined
 } from "@domql/utils";
 import { applyStateMethods } from "./methods";
-const createState = async function(element, parent, options) {
-  element.state = await applyInitialState(element, parent, options);
+const createState = function(element, parent, options) {
+  element.state = applyInitialState(element, parent, options);
   return element.state;
 };
-const applyInitialState = async function(element, parent, options) {
-  const objectizeState = await checkForStateTypes(element);
+const applyInitialState = function(element, parent, options) {
+  const objectizeState = checkForStateTypes(element);
   if (objectizeState === false) return parent.state || {};
   else element.state = objectizeState;
-  const whatInitReturns = await triggerEventOn("stateInit", element, options);
+  const whatInitReturns = triggerEventOn("stateInit", element, options);
   if (whatInitReturns === false) return element.state;
   if (checkIfInherits(element)) {
     const inheritedState = createInheritedState(element, parent);
     element.state = isUndefined(inheritedState) ? {} : inheritedState;
   }
-  const dependentState = await applyDependentState(
+  const dependentState = applyDependentState(
     element,
     element.state || parent.state || {}
   );
   if (dependentState) element.state = dependentState;
   applyStateMethods(element);
-  await triggerEventOn("stateCreated", element);
+  triggerEventOn("stateCreated", element);
   return element.state;
 };
 export {

package/dist/esm/methods.js

@@ -49,7 +49,7 @@ const parse = function() {
     return state.filter((item) => !STATE_METHODS.includes(item));
   }
 };
-const clean = async function(options = {}) {
+const clean = function(options = {}) {
   const state = this;
   for (const param in state) {
     if (!STATE_METHODS.includes(param) && Object.hasOwnProperty.call(state, param)) {
@@ -57,11 +57,11 @@ const clean = async function(options = {}) {
     }
   }
   if (!options.preventStateUpdate) {
-    await state.update(state, __spreadValues({ replace: true }, options));
+    state.update(state, __spreadValues({ replace: true }, options));
   }
   return state;
 };
-const destroy = async function(options = {}) {
+const destroy = function(options = {}) {
   const state = this;
   const element = state.__element;
   const stateKey = element.__ref.__state;
@@ -94,68 +94,68 @@ const destroy = async function(options = {}) {
       }
     }
   }
-  await element.state.update({}, __spreadValues({ isHoisted: true }, options));
+  element.state.update({}, __spreadValues({ isHoisted: true }, options));
   return element.state;
 };
-const parentUpdate = async function(obj, options = {}) {
+const parentUpdate = function(obj, options = {}) {
   const state = this;
   if (!state || !state.parent) return;
-  return await state.parent.update(obj, __spreadValues({ isHoisted: true }, options));
+  return state.parent.update(obj, __spreadValues({ isHoisted: true }, options));
 };
-const rootUpdate = async function(obj, options = {}) {
+const rootUpdate = function(obj, options = {}) {
   const state = this;
   if (!state) return;
   const rootState = state.__element.__ref.root.state;
-  return await rootState.update(obj, __spreadValues({ isHoisted: false }, options));
+  return rootState.update(obj, __spreadValues({ isHoisted: false }, options));
 };
-const add = async function(value, options = {}) {
+const add = function(value, options = {}) {
   const state = this;
   if (isArray(state)) {
     state.push(value);
-    await state.update(state.parse(), __spreadValues({ overwrite: true }, options));
+    state.update(state.parse(), __spreadValues({ overwrite: true }, options));
   } else if (isObject(state)) {
     const key = Object.keys(state).length;
-    await state.update({ [key]: value }, options);
+    state.update({ [key]: value }, options);
   }
 };
-const toggle = async function(key, options = {}) {
+const toggle = function(key, options = {}) {
   const state = this;
-  await state.update({ [key]: !state[key] }, options);
+  state.update({ [key]: !state[key] }, options);
 };
-const remove = async function(key, options = {}) {
+const remove = function(key, options = {}) {
   const state = this;
   if (isArray(state)) removeFromArray(state, key);
   if (isObject(state)) removeFromObject(state, key);
   if (options.applyReset) {
-    return await state.set(state.parse(), __spreadValues({ replace: true }, options));
+    return state.set(state.parse(), __spreadValues({ replace: true }, options));
   }
-  return await state.update({}, options);
+  return state.update({}, options);
 };
-const set = async function(val, options = {}) {
+const set = function(val, options = {}) {
   const state = this;
   const value = deepClone(val);
-  const cleanState = await state.clean(__spreadValues({ preventStateUpdate: true }, options));
-  return await cleanState.update(value, __spreadValues({ replace: true }, options));
+  const cleanState = state.clean(__spreadValues({ preventStateUpdate: true }, options));
+  return cleanState.update(value, __spreadValues({ replace: true }, options));
 };
-const setByPath = async function(path, val, options = {}) {
+const setByPath = function(path, val, options = {}) {
   const state = this;
   const value = deepClone(val);
-  setInObjectByPath(state, path, val);
+  if (!options.preventReplace) setInObjectByPath(state, path, val);
   const update = createNestedObject(path, value);
   if (options.preventStateUpdate) return update;
-  return await state.update(update, options);
+  return state.update(update, options);
 };
-const setPathCollection = async function(changes, options = {}) {
+const setPathCollection = function(changes, options = {}) {
   const state = this;
-  const update = await changes.reduce(async (promise, change) => {
-    const acc = await promise;
+  const update = changes.reduce((promise, change) => {
+    const acc = promise;
     if (change[0] === "update") {
       const result = setByPath.call(state, change[1], change[2], {
         preventStateUpdate: true
       });
       return overwriteDeep(acc, result);
     } else if (change[0] === "delete") {
-      await removeByPath.call(state, change[1], __spreadProps(__spreadValues({}, options), {
+      removeByPath.call(state, change[1], __spreadProps(__spreadValues({}, options), {
         preventUpdate: true
       }));
     }
@@ -163,63 +163,63 @@ const setPathCollection = async function(changes, options = {}) {
   }, Promise.resolve({}));
   return state.update(update, options);
 };
-const removeByPath = async function(path, options = {}) {
+const removeByPath = function(path, options = {}) {
   const state = this;
   removeNestedKeyByPath(state, path);
   if (options.preventUpdate) return path;
-  return await state.update({}, options);
+  return state.update({}, options);
 };
-const removePathCollection = async function(changes, options = {}) {
+const removePathCollection = function(changes, options = {}) {
   const state = this;
-  changes.forEach(async (item) => {
-    await removeByPath(item, { preventUpdate: true });
+  changes.forEach((item) => {
+    removeByPath(item, { preventUpdate: true });
   });
-  return await state.update({}, options);
+  return state.update({}, options);
 };
 const getByPath = function(path, options = {}) {
   const state = this;
   return getInObjectByPath(state, path);
 };
-const reset = async function(options = {}) {
+const reset = function(options = {}) {
   const state = this;
   const value = deepClone(state.parse());
-  return await state.set(value, __spreadValues({ replace: true }, options));
+  return state.set(value, __spreadValues({ replace: true }, options));
 };
-const apply = async function(func, options = {}) {
+const apply = function(func, options = {}) {
   const state = this;
   if (isFunction(func)) {
     const value = func(state);
-    return await state.update(value, __spreadValues({ replace: true }, options));
+    return state.update(value, __spreadValues({ replace: true }, options));
   }
 };
-const applyReplace = async function(func, options = {}) {
+const applyReplace = function(func, options = {}) {
   const state = this;
   if (isFunction(func)) {
     const value = func(state);
-    return await state.replace(value, options);
+    return state.replace(value, options);
   }
 };
-const applyFunction = async function(func, options = {}) {
+const applyFunction = function(func, options = {}) {
   const state = this;
   if (isFunction(func)) {
-    await func(state);
-    return await state.update(state.parse(), __spreadValues({ replace: true }, options));
+    func(state);
+    return state.update(state.parse(), __spreadValues({ replace: true }, options));
   }
 };
-const quietUpdate = async function(obj, options = {}) {
+const quietUpdate = function(obj, options = {}) {
   const state = this;
-  return await state.update(obj, __spreadValues({ preventUpdate: true }, options));
+  return state.update(obj, __spreadValues({ preventUpdate: true }, options));
 };
-const replace = async function(obj, options = {}) {
+const replace = function(obj, options = {}) {
   const state = this;
   for (const param in obj) {
     state[param] = obj[param];
   }
-  return await state.update(obj, options);
+  return state.update(obj, options);
 };
-const quietReplace = async function(obj, options = {}) {
+const quietReplace = function(obj, options = {}) {
   const state = this;
-  return await state.replace(obj, __spreadValues({ preventUpdate: true }, options));
+  return state.replace(obj, __spreadValues({ preventUpdate: true }, options));
 };
 const keys = function(obj, options = {}) {
   const state = this;

package/dist/esm/updateState.js

@@ -36,7 +36,7 @@ const STATE_UPDATE_OPTIONS = {
   isHoisted: true,
   execStateFunction: true
 };
-const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
+const updateState = function(obj, options = STATE_UPDATE_OPTIONS) {
   const state = this;
   const element = state.__element;
   if (options.onEach) options.onEach(element, state, element.context, options);
@@ -46,7 +46,7 @@ const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
     options.preventInheritAtCurrentState = state;
   } else if (options.preventInheritAtCurrentState) return;
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+    const beforeStateUpdateReturns = triggerEventOnUpdate(
       "beforeStateUpdate",
       obj,
       element,
@@ -55,16 +55,16 @@ const updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
     if (beforeStateUpdateReturns === false) return element;
   }
   overwriteState(state, obj, options);
-  const updateIsHoisted = await hoistStateUpdate(state, obj, options);
+  const updateIsHoisted = hoistStateUpdate(state, obj, options);
   if (updateIsHoisted) return state;
-  await updateDependentState(state, obj, options);
-  await applyElementUpdate(state, obj, options);
+  updateDependentState(state, obj, options);
+  applyElementUpdate(state, obj, options);
   if (!options.preventStateUpdateListener) {
-    await triggerEventOnUpdate("stateUpdate", obj, element, options);
+    triggerEventOnUpdate("stateUpdate", obj, element, options);
   }
   return state;
 };
-const hoistStateUpdate = async (state, obj, options) => {
+const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element;
   const { parent, __ref: ref } = element;
   const stateKey = ref == null ? void 0 : ref.__state;
@@ -84,7 +84,7 @@ const hoistStateUpdate = async (state, obj, options) => {
   const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
   const targetParent = findRootState || findGrandParentState || parent.state;
   if (options.replace) overwriteDeep(targetParent, changesValue || value);
-  await targetParent.update(changesValue, __spreadValues({
+  targetParent.update(changesValue, __spreadValues({
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -92,29 +92,29 @@ const hoistStateUpdate = async (state, obj, options) => {
   }, options));
   const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    await triggerEventOnUpdate("stateUpdate", obj, element, options);
+    triggerEventOnUpdate("stateUpdate", obj, element, options);
   }
   return true;
 };
-const updateDependentState = async (state, obj, options) => {
+const updateDependentState = (state, obj, options) => {
   if (!state.__depends) return;
   for (const el in state.__depends) {
     const dependentState = state.__depends[el];
-    const cleanState = await dependentState.clean();
-    await cleanState.update(state.parse(), options);
+    const cleanState = dependentState.clean();
+    cleanState.update(state.parse(), options);
   }
 };
-const applyElementUpdate = async (state, obj, options) => {
+const applyElementUpdate = (state, obj, options) => {
   const element = state.__element;
   if (options.preventUpdate !== true) {
-    await element.update(
+    element.update(
       {},
       __spreadProps(__spreadValues({}, options), {
         updateByState: true
       })
     );
   } else if (options.preventUpdate === "recursive") {
-    await element.update(
+    element.update(
       {},
       __spreadProps(__spreadValues({}, options), {
         isHoisted: false,

package/methods.js

@@ -35,7 +35,7 @@ export const parse = function () {
   }
 }
 
-export const clean = async function (options = {}) {
+export const clean = function (options = {}) {
   const state = this
   for (const param in state) {
     if (
@@ -46,12 +46,12 @@ export const clean = async function (options = {}) {
     }
   }
   if (!options.preventStateUpdate) {
-    await state.update(state, { replace: true, ...options })
+    state.update(state, { replace: true, ...options })
   }
   return state
 }
 
-export const destroy = async function (options = {}) {
+export const destroy = function (options = {}) {
   const state = this
   const element = state.__element
 
@@ -86,76 +86,76 @@ export const destroy = async function (options = {}) {
     }
   }
 
-  await element.state.update({}, { isHoisted: true, ...options })
+  element.state.update({}, { isHoisted: true, ...options })
   return element.state
 }
 
-export const parentUpdate = async function (obj, options = {}) {
+export const parentUpdate = function (obj, options = {}) {
   const state = this
   if (!state || !state.parent) return
-  return await state.parent.update(obj, { isHoisted: true, ...options })
+  return state.parent.update(obj, { isHoisted: true, ...options })
 }
 
-export const rootUpdate = async function (obj, options = {}) {
+export const rootUpdate = function (obj, options = {}) {
   const state = this
   if (!state) return
   const rootState = state.__element.__ref.root.state
-  return await rootState.update(obj, { isHoisted: false, ...options })
+  return rootState.update(obj, { isHoisted: false, ...options })
 }
 
-export const add = async function (value, options = {}) {
+export const add = function (value, options = {}) {
   const state = this
   if (isArray(state)) {
     state.push(value)
-    await state.update(state.parse(), { overwrite: true, ...options })
+    state.update(state.parse(), { overwrite: true, ...options })
   } else if (isObject(state)) {
     const key = Object.keys(state).length
-    await state.update({ [key]: value }, options)
+    state.update({ [key]: value }, options)
   }
 }
 
-export const toggle = async function (key, options = {}) {
+export const toggle = function (key, options = {}) {
   const state = this
-  await state.update({ [key]: !state[key] }, options)
+  state.update({ [key]: !state[key] }, options)
 }
 
-export const remove = async function (key, options = {}) {
+export const remove = function (key, options = {}) {
   const state = this
   if (isArray(state)) removeFromArray(state, key)
   if (isObject(state)) removeFromObject(state, key)
   if (options.applyReset) {
-    return await state.set(state.parse(), { replace: true, ...options })
+    return state.set(state.parse(), { replace: true, ...options })
   }
-  return await state.update({}, options)
+  return state.update({}, options)
 }
 
-export const set = async function (val, options = {}) {
+export const set = function (val, options = {}) {
   const state = this
   const value = deepClone(val)
-  const cleanState = await state.clean({ preventStateUpdate: true, ...options })
-  return await cleanState.update(value, { replace: true, ...options })
+  const cleanState = state.clean({ preventStateUpdate: true, ...options })
+  return cleanState.update(value, { replace: true, ...options })
 }
 
-export const setByPath = async function (path, val, options = {}) {
+export const setByPath = function (path, val, options = {}) {
   const state = this
   const value = deepClone(val)
-  setInObjectByPath(state, path, val)
+  if (!options.preventReplace) setInObjectByPath(state, path, val)
   const update = createNestedObject(path, value)
   if (options.preventStateUpdate) return update
-  return await state.update(update, options)
+  return state.update(update, options)
 }
 
-export const setPathCollection = async function (changes, options = {}) {
+export const setPathCollection = function (changes, options = {}) {
   const state = this
-  const update = await changes.reduce(async (promise, change) => {
-    const acc = await promise
+  const update = changes.reduce((promise, change) => {
+    const acc = promise
     if (change[0] === 'update') {
       const result = setByPath.call(state, change[1], change[2], {
         preventStateUpdate: true
       })
       return overwriteDeep(acc, result)
     } else if (change[0] === 'delete') {
-      await removeByPath.call(state, change[1], {
+      removeByPath.call(state, change[1], {
         ...options,
         preventUpdate: true
       })
@@ -166,19 +166,19 @@ export const setPathCollection = async function (changes, options = {}) {
   return state.update(update, options)
 }
 
-export const removeByPath = async function (path, options = {}) {
+export const removeByPath = function (path, options = {}) {
   const state = this
   removeNestedKeyByPath(state, path)
   if (options.preventUpdate) return path
-  return await state.update({}, options)
+  return state.update({}, options)
 }
 
-export const removePathCollection = async function (changes, options = {}) {
+export const removePathCollection = function (changes, options = {}) {
   const state = this
-  changes.forEach(async item => {
-    await removeByPath(item, { preventUpdate: true })
+  changes.forEach(item => {
+    removeByPath(item, { preventUpdate: true })
   })
-  return await state.update({}, options)
+  return state.update({}, options)
 }
 
 export const getByPath = function (path, options = {}) {
@@ -186,54 +186,54 @@ export const getByPath = function (path, options = {}) {
   return getInObjectByPath(state, path)
 }
 
-export const reset = async function (options = {}) {
+export const reset = function (options = {}) {
   const state = this
   const value = deepClone(state.parse())
-  return await state.set(value, { replace: true, ...options })
+  return state.set(value, { replace: true, ...options })
 }
 
-export const apply = async function (func, options = {}) {
+export const apply = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return await state.update(value, { replace: true, ...options })
+    return state.update(value, { replace: true, ...options })
   }
 }
 
-export const applyReplace = async function (func, options = {}) {
+export const applyReplace = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return await state.replace(value, options)
+    return state.replace(value, options)
   }
 }
 
-export const applyFunction = async function (func, options = {}) {
+export const applyFunction = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
-    await func(state)
-    return await state.update(state.parse(), { replace: true, ...options })
+    func(state)
+    return state.update(state.parse(), { replace: true, ...options })
   }
 }
 
-export const quietUpdate = async function (obj, options = {}) {
+export const quietUpdate = function (obj, options = {}) {
   const state = this
-  return await state.update(obj, { preventUpdate: true, ...options })
+  return state.update(obj, { preventUpdate: true, ...options })
 }
 
-export const replace = async function (obj, options = {}) {
+export const replace = function (obj, options = {}) {
   const state = this
 
   for (const param in obj) {
     state[param] = obj[param]
   }
 
-  return await state.update(obj, options)
+  return state.update(obj, options)
 }
 
-export const quietReplace = async function (obj, options = {}) {
+export const quietReplace = function (obj, options = {}) {
   const state = this
-  return await state.replace(obj, { preventUpdate: true, ...options })
+  return state.replace(obj, { preventUpdate: true, ...options })
 }
 
 export const keys = function (obj, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "3.1.1",
+  "version": "3.2.3",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -9,9 +9,9 @@
   "jsdelivr": "dist/iife/index.js",
   "exports": {
     ".": {
-      "default": "./dist/esm/index.js",
       "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
     }
   },
   "source": "index.js",
@@ -21,16 +21,16 @@
   ],
   "scripts": {
     "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
-    "build:esm": "npx esbuild *.js --target=es2017 --format=esm --outdir=dist/esm",
-    "build:cjs": "npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs",
-    "build:iife": "npx esbuild *.js --target=node16 --format=iife --outdir=dist/iife",
+    "build:esm": "npx cross-env NODE_ENV=$NODE_ENV npx esbuild *.js --target=es2017 --format=esm --outdir=dist/esm",
+    "build:cjs": "npx cross-env NODE_ENV=$NODE_ENV npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs",
+    "build:iife": "npx cross-env NODE_ENV=$NODE_ENV npx esbuild *.js --target=node16 --format=iife --outdir=dist/iife",
     "build": "npx rimraf -I dist; npm run build:cjs; npm run build:esm",
     "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^3.1.1",
-    "@domql/report": "^3.1.1",
-    "@domql/utils": "^3.1.1"
+    "@domql/event": "^3.2.3",
+    "@domql/report": "^3.2.3",
+    "@domql/utils": "^3.2.3"
   },
-  "gitHead": "39fb7a8c07355468ccce79e2f787ca3fa0715692"
+  "gitHead": "9fc1b79b41cdc725ca6b24aec64920a599634681"
 }

package/updateState.js

@@ -21,10 +21,7 @@ const STATE_UPDATE_OPTIONS = {
   execStateFunction: true
 }
 
-export const updateState = async function (
-  obj,
-  options = STATE_UPDATE_OPTIONS
-) {
+export const updateState = function (obj, options = STATE_UPDATE_OPTIONS) {
   const state = this
   const element = state.__element
 
@@ -38,7 +35,7 @@ export const updateState = async function (
   } else if (options.preventInheritAtCurrentState) return
 
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+    const beforeStateUpdateReturns = triggerEventOnUpdate(
       'beforeStateUpdate',
       obj,
       element,
@@ -48,21 +45,21 @@ export const updateState = async function (
   }
 
   overwriteState(state, obj, options)
-  const updateIsHoisted = await hoistStateUpdate(state, obj, options)
+  const updateIsHoisted = hoistStateUpdate(state, obj, options)
   if (updateIsHoisted) return state
 
-  await updateDependentState(state, obj, options)
+  updateDependentState(state, obj, options)
 
-  await applyElementUpdate(state, obj, options)
+  applyElementUpdate(state, obj, options)
 
   if (!options.preventStateUpdateListener) {
-    await triggerEventOnUpdate('stateUpdate', obj, element, options)
+    triggerEventOnUpdate('stateUpdate', obj, element, options)
   }
 
   return state
 }
 
-export const hoistStateUpdate = async (state, obj, options) => {
+export const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element
   const { parent, __ref: ref } = element
 
@@ -88,7 +85,7 @@ export const hoistStateUpdate = async (state, obj, options) => {
   const changesValue = createNestedObjectByKeyPath(stateKey, passedValue)
   const targetParent = findRootState || findGrandParentState || parent.state
   if (options.replace) overwriteDeep(targetParent, changesValue || value) // check with createNestedObjectByKeyPath
-  await targetParent.update(changesValue, {
+  targetParent.update(changesValue, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -98,24 +95,24 @@ export const hoistStateUpdate = async (state, obj, options) => {
   const hasNotUpdated =
     options.preventUpdate !== true || !options.preventHoistElementUpdate
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    await triggerEventOnUpdate('stateUpdate', obj, element, options)
+    triggerEventOnUpdate('stateUpdate', obj, element, options)
   }
   return true
 }
 
-const updateDependentState = async (state, obj, options) => {
+const updateDependentState = (state, obj, options) => {
   if (!state.__depends) return
   for (const el in state.__depends) {
     const dependentState = state.__depends[el]
-    const cleanState = await dependentState.clean()
-    await cleanState.update(state.parse(), options)
+    const cleanState = dependentState.clean()
+    cleanState.update(state.parse(), options)
   }
 }
 
-const applyElementUpdate = async (state, obj, options) => {
+const applyElementUpdate = (state, obj, options) => {
   const element = state.__element
   if (options.preventUpdate !== true) {
-    await element.update(
+    element.update(
       {},
       {
         ...options,
@@ -123,7 +120,7 @@ const applyElementUpdate = async (state, obj, options) => {
       }
     )
   } else if (options.preventUpdate === 'recursive') {
-    await element.update(
+    element.update(
       {},
       {
         ...options,