@domql/state 2.31.26 → 2.31.27

package/create.js

@@ -66,7 +66,7 @@ export const applyInitialState = async function (element, parent, options) {
   applyMethods(element)
 
   // trigger `on.stateCreated`
-  await triggerEventOn('stateCreated', element)
+  await triggerEventOn('stateCreated', element, options)
 
   return element.state
 }

package/dist/cjs/create.js

@@ -48,7 +48,7 @@ const applyInitialState = async function(element, parent, options) {
   );
   if (dependentState) element.state = dependentState;
   applyMethods(element);
-  await (0, import_event.triggerEventOn)("stateCreated", element);
+  await (0, import_event.triggerEventOn)("stateCreated", element, options);
   return element.state;
 };
 const applyDependentState = (element, state) => {

package/dist/cjs/methods.js

@@ -55,11 +55,10 @@ const parse = function() {
       }
     }
     return obj;
-  } else if ((0, import_utils.isArray)(state)) {
-    return state.filter((item) => !import_ignore.IGNORE_STATE_PARAMS.includes(item));
+  } else {
   }
 };
-const clean = function(options = {}) {
+const clean = async function(options = {}) {
   const state = this;
   for (const param in state) {
     if (!import_ignore.IGNORE_STATE_PARAMS.includes(param) && Object.hasOwnProperty.call(state, param)) {
@@ -67,16 +66,16 @@ const clean = function(options = {}) {
     }
   }
   if (!options.preventStateUpdate) {
-    state.update(state, { replace: true, ...options });
+    await state.update(state, { replace: true, ...options });
   }
   return state;
 };
-const destroy = function(options = {}) {
+const destroy = async function(options = {}) {
   const state = this;
   const element = state.__element;
   const stateKey = element.__ref.__state;
   if ((0, import_utils.isString)(stateKey)) {
-    element.parent.state.remove(stateKey, { isHoisted: true, ...options });
+    await element.parent.state.remove(stateKey, { isHoisted: true, ...options });
     return element.state;
   }
   delete element.state;
@@ -104,66 +103,69 @@ const destroy = function(options = {}) {
       }
     }
   }
-  element.state.update({}, { isHoisted: true, ...options });
+  await element.state.update({}, { isHoisted: true, ...options });
   return element.state;
 };
-const parentUpdate = function(obj, options = {}) {
+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 });
 };
-const rootUpdate = function(obj, options = {}) {
+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 });
+  return await rootState.update(obj, { isHoisted: false, ...options });
 };
-const add = function(value, options = {}) {
+const add = async function(value, options = {}) {
   const state = this;
   if ((0, import_utils.isArray)(state)) {
-    state.push(value);
-    state.update(state.parse(), { overwrite: true, ...options });
+    await state.push(value);
+    return await state.update(state.parse(), { overwrite: true, ...options });
   } else if ((0, import_utils.isObject)(state)) {
     const key = Object.keys(state).length;
-    state.update({ [key]: value }, options);
+    return await state.update({ [key]: value }, options);
   }
 };
-const toggle = function(key, options = {}) {
+const toggle = async function(key, options = {}) {
   const state = this;
-  state.update({ [key]: !state[key] }, options);
+  return await state.update({ [key]: !state[key] }, options);
 };
-const remove = function(key, options = {}) {
+const remove = async 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 state.set(state.parse(), { replace: true, ...options });
-  return state.update();
+    return await state.set(state.parse(), { replace: true, ...options });
+  return await state.update();
 };
-const set = function(val, options = {}) {
+const set = async function(val, options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(val);
-  return state.clean({ preventStateUpdate: true, ...options }).update(value, { replace: true, ...options });
+  await state.clean({ preventStateUpdate: true, ...options });
+  await state.update(value, { replace: true, ...options });
+  return state;
 };
-const setByPath = function(path, val, options = {}) {
+const setByPath = async function(path, val, options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(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 state.update(update, options);
+  return await state.update(update, options);
 };
 const setPathCollection = async function(changes, options = {}) {
   const state = this;
-  const update = changes.reduce((acc, change) => {
+  const update = await changes.reduce(async (promacc, change) => {
+    const acc = await promacc;
     if (change[0] === "update") {
-      const result = setByPath.call(state, change[1], change[2], {
+      const result = await setByPath.call(state, change[1], change[2], {
         ...options,
         preventStateUpdate: true
       });
       return (0, import_utils.overwriteDeep)(acc, result);
     } else if (change[0] === "delete") {
-      removeByPath.call(state, change[1], options);
+      await removeByPath.call(state, change[1], options);
     }
     return acc;
   }, {});
@@ -175,57 +177,59 @@ const removeByPath = async function(path, options = {}) {
   if (options.preventUpdate) return path;
   return await state.update({}, options);
 };
-const removePathCollection = function(changes, options = {}) {
+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);
 };
 const getByPath = function(path, options = {}) {
   const state = this;
   return (0, import_utils.getInObjectByPath)(state, path);
 };
-const reset = function(options = {}) {
+const reset = async function(options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(state.parse());
-  return state.set(value, { replace: true, ...options });
+  return await state.set(value, { replace: true, ...options });
 };
-const apply = function(func, options = {}) {
+const apply = async function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
     const value = func(state);
-    return state.update(value, { replace: true, ...options });
+    return await state.update(value, { replace: true, ...options });
   }
 };
-const applyReplace = function(func, options = {}) {
+const applyReplace = async function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
     const value = func(state);
-    return state.replace(value, options);
+    return await state.replace(value, options);
   }
 };
-const applyFunction = function(func, options = {}) {
+const applyFunction = async function(func, options = {}) {
   const state = this;
   if ((0, import_utils.isFunction)(func)) {
-    func(state);
-    return state.update(state.parse(), { replace: true, ...options });
+    const result = func(state);
+    if (result instanceof Promise) await result;
+    else result;
+    return await state.update(state.parse(), { replace: true, ...options });
   }
 };
-const quietUpdate = function(obj, options = {}) {
+const quietUpdate = async function(obj, options = {}) {
   const state = this;
-  return state.update(obj, { preventUpdate: true, ...options });
+  return await state.update(obj, { preventUpdate: true, ...options });
 };
-const replace = function(obj, options = {}) {
+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);
 };
-const quietReplace = function(obj, options = {}) {
+const quietReplace = async function(obj, options = {}) {
   const state = this;
-  return state.replace(obj, { preventUpdate: true, ...options });
+  return await state.replace(obj, { preventUpdate: true, ...options });
 };
 const keys = function(obj, options = {}) {
   const state = this;

package/dist/esm/create.js

@@ -75,7 +75,7 @@ const applyInitialState = async function(element, parent, options) {
   );
   if (dependentState) element.state = dependentState;
   applyMethods(element);
-  await triggerEventOn("stateCreated", element);
+  await triggerEventOn("stateCreated", element, options);
   return element.state;
 };
 const applyDependentState = (element, state) => {

package/dist/esm/methods.js

@@ -42,11 +42,10 @@ const parse = function() {
       }
     }
     return obj;
-  } else if (isArray(state)) {
-    return state.filter((item) => !IGNORE_STATE_PARAMS.includes(item));
+  } else {
   }
 };
-const clean = function(options = {}) {
+const clean = async function(options = {}) {
   const state = this;
   for (const param in state) {
     if (!IGNORE_STATE_PARAMS.includes(param) && Object.hasOwnProperty.call(state, param)) {
@@ -54,16 +53,16 @@ const clean = function(options = {}) {
     }
   }
   if (!options.preventStateUpdate) {
-    state.update(state, __spreadValues({ replace: true }, options));
+    await state.update(state, __spreadValues({ replace: true }, options));
   }
   return state;
 };
-const destroy = function(options = {}) {
+const destroy = async 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));
+    await element.parent.state.remove(stateKey, __spreadValues({ isHoisted: true }, options));
     return element.state;
   }
   delete element.state;
@@ -91,65 +90,68 @@ const destroy = function(options = {}) {
       }
     }
   }
-  element.state.update({}, __spreadValues({ isHoisted: true }, options));
+  await element.state.update({}, __spreadValues({ isHoisted: true }, options));
   return element.state;
 };
-const parentUpdate = function(obj, options = {}) {
+const parentUpdate = async function(obj, options = {}) {
   const state = this;
   if (!state || !state.parent) return;
-  return state.parent.update(obj, __spreadValues({ isHoisted: true }, options));
+  return await state.parent.update(obj, __spreadValues({ isHoisted: true }, options));
 };
-const rootUpdate = function(obj, options = {}) {
+const rootUpdate = async function(obj, options = {}) {
   const state = this;
   if (!state) return;
   const rootState = state.__element.__ref.root.state;
-  return rootState.update(obj, __spreadValues({ isHoisted: false }, options));
+  return await rootState.update(obj, __spreadValues({ isHoisted: false }, options));
 };
-const add = function(value, options = {}) {
+const add = async function(value, options = {}) {
   const state = this;
   if (isArray(state)) {
-    state.push(value);
-    state.update(state.parse(), __spreadValues({ overwrite: true }, options));
+    await state.push(value);
+    return await state.update(state.parse(), __spreadValues({ overwrite: true }, options));
   } else if (isObject(state)) {
     const key = Object.keys(state).length;
-    state.update({ [key]: value }, options);
+    return await state.update({ [key]: value }, options);
   }
 };
-const toggle = function(key, options = {}) {
+const toggle = async function(key, options = {}) {
   const state = this;
-  state.update({ [key]: !state[key] }, options);
+  return await state.update({ [key]: !state[key] }, options);
 };
-const remove = function(key, options = {}) {
+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(), __spreadValues({ replace: true }, options));
-  return state.update();
+    return await state.set(state.parse(), __spreadValues({ replace: true }, options));
+  return await state.update();
 };
-const set = function(val, options = {}) {
+const set = async function(val, options = {}) {
   const state = this;
   const value = deepClone(val);
-  return state.clean(__spreadValues({ preventStateUpdate: true }, options)).update(value, __spreadValues({ replace: true }, options));
+  await state.clean(__spreadValues({ preventStateUpdate: true }, options));
+  await state.update(value, __spreadValues({ replace: true }, options));
+  return state;
 };
-const setByPath = function(path, val, options = {}) {
+const setByPath = async function(path, val, options = {}) {
   const state = this;
   const value = deepClone(val);
   if (!options.preventReplace) 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);
 };
 const setPathCollection = async function(changes, options = {}) {
   const state = this;
-  const update = changes.reduce((acc, change) => {
+  const update = await changes.reduce(async (promacc, change) => {
+    const acc = await promacc;
     if (change[0] === "update") {
-      const result = setByPath.call(state, change[1], change[2], __spreadProps(__spreadValues({}, options), {
+      const result = await setByPath.call(state, change[1], change[2], __spreadProps(__spreadValues({}, options), {
         preventStateUpdate: true
       }));
       return overwriteDeep(acc, result);
     } else if (change[0] === "delete") {
-      removeByPath.call(state, change[1], options);
+      await removeByPath.call(state, change[1], options);
     }
     return acc;
   }, {});
@@ -161,57 +163,59 @@ const removeByPath = async function(path, options = {}) {
   if (options.preventUpdate) return path;
   return await state.update({}, options);
 };
-const removePathCollection = function(changes, options = {}) {
+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);
 };
 const getByPath = function(path, options = {}) {
   const state = this;
   return getInObjectByPath(state, path);
 };
-const reset = function(options = {}) {
+const reset = async function(options = {}) {
   const state = this;
   const value = deepClone(state.parse());
-  return state.set(value, __spreadValues({ replace: true }, options));
+  return await state.set(value, __spreadValues({ replace: true }, options));
 };
-const apply = function(func, options = {}) {
+const apply = async function(func, options = {}) {
   const state = this;
   if (isFunction(func)) {
     const value = func(state);
-    return state.update(value, __spreadValues({ replace: true }, options));
+    return await state.update(value, __spreadValues({ replace: true }, options));
   }
 };
-const applyReplace = function(func, options = {}) {
+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);
   }
 };
-const applyFunction = function(func, options = {}) {
+const applyFunction = async function(func, options = {}) {
   const state = this;
   if (isFunction(func)) {
-    func(state);
-    return state.update(state.parse(), __spreadValues({ replace: true }, options));
+    const result = func(state);
+    if (result instanceof Promise) await result;
+    else result;
+    return await state.update(state.parse(), __spreadValues({ replace: true }, options));
   }
 };
-const quietUpdate = function(obj, options = {}) {
+const quietUpdate = async function(obj, options = {}) {
   const state = this;
-  return state.update(obj, __spreadValues({ preventUpdate: true }, options));
+  return await state.update(obj, __spreadValues({ preventUpdate: true }, options));
 };
-const replace = function(obj, options = {}) {
+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);
 };
-const quietReplace = function(obj, options = {}) {
+const quietReplace = async function(obj, options = {}) {
   const state = this;
-  return state.replace(obj, __spreadValues({ preventUpdate: true }, options));
+  return await state.replace(obj, __spreadValues({ preventUpdate: true }, options));
 };
 const keys = function(obj, options = {}) {
   const state = this;

package/methods.js

@@ -27,12 +27,11 @@ export const parse = function () {
       }
     }
     return obj
-  } else if (isArray(state)) {
-    return state.filter(item => !IGNORE_STATE_PARAMS.includes(item))
+  } else {
   }
 }
 
-export const clean = function (options = {}) {
+export const clean = async function (options = {}) {
   const state = this
   for (const param in state) {
     if (
@@ -43,18 +42,18 @@ export const clean = function (options = {}) {
     }
   }
   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
 
   const stateKey = element.__ref.__state
   if (isString(stateKey)) {
-    element.parent.state.remove(stateKey, { isHoisted: true, ...options })
+    await element.parent.state.remove(stateKey, { isHoisted: true, ...options })
     return element.state
   }
 
@@ -83,76 +82,77 @@ 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 })
+  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.push(value)
+    return await state.update(state.parse(), { overwrite: true, ...options })
   } else if (isObject(state)) {
     const key = Object.keys(state).length
-    state.update({ [key]: value }, options)
+    return 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)
+  return 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()
+    return await state.set(state.parse(), { replace: true, ...options })
+  return await state.update()
 }
 
-export const set = function (val, options = {}) {
+export const set = async function (val, options = {}) {
   const state = this
   const value = deepClone(val)
+  await state.clean({ preventStateUpdate: true, ...options })
+  await state.update(value, { replace: true, ...options })
   return state
-    .clean({ preventStateUpdate: true, ...options })
-    .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)
   if (!options.preventReplace) 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 = async function (changes, options = {}) {
   const state = this
-  const update = changes.reduce((acc, change) => {
+  const update = await changes.reduce(async (promacc, change) => {
+    const acc = await promacc
     if (change[0] === 'update') {
-      const result = setByPath.call(state, change[1], change[2], {
+      const result = await setByPath.call(state, change[1], change[2], {
         ...options,
         preventStateUpdate: true
       })
       return overwriteDeep(acc, result)
     } else if (change[0] === 'delete') {
-      removeByPath.call(state, change[1], options)
+      await removeByPath.call(state, change[1], options)
     }
     return acc
   }, {})
@@ -166,12 +166,12 @@ export const removeByPath = async function (path, 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 = {}) {
@@ -179,54 +179,56 @@ 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 })
+    const result = func(state)
+    if (result instanceof Promise) await result
+    else result
+    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 = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "2.31.26",
+  "version": "2.31.27",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -28,9 +28,9 @@
     "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.31.26",
-    "@domql/report": "^2.31.26",
-    "@domql/utils": "^2.31.26"
+    "@domql/event": "^2.31.27",
+    "@domql/report": "^2.31.27",
+    "@domql/utils": "^2.31.27"
   },
-  "gitHead": "126577d65a218af7e2f66b0a3f9691942ee8b9d2"
+  "gitHead": "0edcd5aae5c16b6a53a7e9b6512bb2562e8eb8a1"
 }