@domql/state 3.1.2 → 3.2.7

package/dist/esm/methods.js

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import {
   isArray,
   deepClone,
@@ -40,33 +21,33 @@ const parse = function() {
   if (isObject(state)) {
     const obj = {};
     for (const param in state) {
-      if (!STATE_METHODS.includes(param)) {
+      if (!STATE_METHODS.has(param)) {
         obj[param] = state[param];
       }
     }
     return obj;
   } else if (isArray(state)) {
-    return state.filter((item) => !STATE_METHODS.includes(item));
+    return state.filter((item) => !STATE_METHODS.has(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)) {
+    if (!STATE_METHODS.has(param) && Object.prototype.hasOwnProperty.call(state, param)) {
       delete state[param];
     }
   }
   if (!options.preventStateUpdate) {
-    await state.update(state, __spreadValues({ 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;
   if (isString(stateKey)) {
-    element.parent.state.remove(stateKey, __spreadValues({ isHoisted: true }, options));
+    element.parent.state.remove(stateKey, { isHoisted: true, ...options });
     return element.state;
   }
   delete element.state;
@@ -94,132 +75,132 @@ const destroy = async function(options = {}) {
       }
     }
   }
-  await element.state.update({}, __spreadValues({ 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, __spreadValues({ 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, __spreadValues({ 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 (isArray(state)) {
     state.push(value);
-    await state.update(state.parse(), __spreadValues({ 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);
   }
 };
-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);
+  else if (isObject(state)) removeFromObject(state, key);
   if (options.applyReset) {
-    return await state.set(state.parse(), __spreadValues({ 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 = deepClone(val);
-  const cleanState = await state.clean(__spreadValues({ preventStateUpdate: true }, options));
-  return await cleanState.update(value, __spreadValues({ 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 = 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((acc, change) => {
     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], {
+        ...options,
         preventUpdate: true
-      }));
+      });
     }
     return acc;
-  }, 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 });
-  });
-  return await state.update({}, options);
+  for (let i = 0; i < changes.length; i++) {
+    removeByPath(changes[i], { preventUpdate: true });
+  }
+  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, { 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, { 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(), { 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, { 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, { preventUpdate: true, ...options });
 };
 const keys = function(obj, options = {}) {
   const state = this;
@@ -230,7 +211,6 @@ const values = function(obj, options = {}) {
   return Object.values(state);
 };
 const applyStateMethods = (element) => {
-  var _a;
   const state = element.state;
   const ref = element.__ref;
   const proto = {
@@ -252,7 +232,7 @@ const applyStateMethods = (element) => {
     replace: replace.bind(state),
     quietReplace: quietReplace.bind(state),
     reset: reset.bind(state),
-    parent: ((_a = element.parent) == null ? void 0 : _a.state) || state,
+    parent: element.parent?.state || state,
     setByPath: setByPath.bind(state),
     setPathCollection: setPathCollection.bind(state),
     removeByPath: removeByPath.bind(state),
@@ -262,7 +242,7 @@ const applyStateMethods = (element) => {
     values: values.bind(state),
     __element: element,
     __children: {},
-    root: (ref == null ? void 0 : ref.root) ? ref.root.state : state
+    root: ref?.root ? ref.root.state : state
   };
   if (isArray(state)) {
     addProtoToArray(state, proto);

package/dist/esm/updateState.js

@@ -1,24 +1,4 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { report } from "@domql/report";
-import { triggerEventOnUpdate } from "@domql/event";
 import {
   checkIfInherits,
   createNestedObjectByKeyPath,
@@ -27,7 +7,8 @@ import {
   getRootStateInKey,
   merge,
   overwriteDeep,
-  overwriteState
+  overwriteState,
+  triggerEventOnUpdate
 } from "@domql/utils";
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
@@ -36,7 +17,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 +27,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,20 +36,20 @@ 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;
-  const stateType = ref == null ? void 0 : ref.__stateType;
+  const stateKey = ref?.__state;
+  const stateType = ref?.__stateType;
   if (!stateKey) return;
   const asksForInherit = checkIfInherits(element);
   const inheritedState = findInheritedState(element, parent, {
@@ -84,43 +65,46 @@ 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, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
-    overwrite: !options.replace
-  }, options));
+    overwrite: !options.replace,
+    ...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), {
+      {
+        ...options,
         updateByState: true
-      })
+      }
     );
   } else if (options.preventUpdate === "recursive") {
-    await element.update(
+    element.update(
       {},
-      __spreadProps(__spreadValues({}, options), {
+      {
+        ...options,
         isHoisted: false,
         updateByState: true,
         preventUpdate: true
-      })
+      }
     );
   }
 };