@domql/state 3.1.2 → 3.2.7

package/create.js

@@ -1,27 +1,27 @@
 'use strict'
 
-import { triggerEventOn } from '@domql/event'
 import {
   applyDependentState,
   checkForStateTypes,
   checkIfInherits,
   createInheritedState,
-  isUndefined
+  isUndefined,
+  triggerEventOn
 } from '@domql/utils'
 
-import { applyStateMethods } from './methods'
+import { applyStateMethods } from './methods.js'
 
-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

@@ -22,29 +22,28 @@ __export(create_exports, {
   createState: () => createState
 });
 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);
+var import_methods = require("./methods.js");
+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_utils.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_utils.triggerEventOn)("stateCreated", element);
   return element.state;
 };

package/dist/cjs/methods.js

@@ -52,28 +52,28 @@ const parse = function() {
   if ((0, import_utils.isObject)(state)) {
     const obj = {};
     for (const param in state) {
-      if (!import_utils.STATE_METHODS.includes(param)) {
+      if (!import_utils.STATE_METHODS.has(param)) {
         obj[param] = state[param];
       }
     }
     return obj;
   } else if ((0, import_utils.isArray)(state)) {
-    return state.filter((item) => !import_utils.STATE_METHODS.includes(item));
+    return state.filter((item) => !import_utils.STATE_METHODS.has(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)) {
+    if (!import_utils.STATE_METHODS.has(param) && Object.prototype.hasOwnProperty.call(state, param)) {
       delete state[param];
     }
   }
   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,133 +106,132 @@ 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);
+  else 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((acc, change) => {
     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
       });
     }
     return acc;
-  }, 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 });
-  });
-  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 (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;
@@ -243,7 +242,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 = {
@@ -265,7 +263,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),
@@ -275,7 +273,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 ((0, import_utils.isArray)(state)) {
     (0, import_utils.addProtoToArray)(state, proto);

package/dist/cjs/updateState.js

@@ -23,7 +23,6 @@ __export(updateState_exports, {
 });
 module.exports = __toCommonJS(updateState_exports);
 var import_report = require("@domql/report");
-var import_event = require("@domql/event");
 var import_utils = require("@domql/utils");
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
@@ -32,7 +31,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 +41,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_utils.triggerEventOnUpdate)(
       "beforeStateUpdate",
       obj,
       element,
@@ -51,20 +50,20 @@ 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_utils.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 = (0, import_utils.checkIfInherits)(element);
   const inheritedState = (0, import_utils.findInheritedState)(element, parent, {
@@ -80,7 +79,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 +88,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_utils.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 +111,7 @@ const applyElementUpdate = async (state, obj, options) => {
       }
     );
   } else if (options.preventUpdate === "recursive") {
-    await element.update(
+    element.update(
       {},
       {
         ...options,

package/dist/esm/create.js

@@ -1,33 +1,33 @@
-import { triggerEventOn } from "@domql/event";
 import {
   applyDependentState,
   checkForStateTypes,
   checkIfInherits,
   createInheritedState,
-  isUndefined
+  isUndefined,
+  triggerEventOn
 } from "@domql/utils";
-import { applyStateMethods } from "./methods";
-const createState = async function(element, parent, options) {
-  element.state = await applyInitialState(element, parent, options);
+import { applyStateMethods } from "./methods.js";
+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 {