@domql/state 2.5.200 → 3.0.1

package/dist/cjs/updateState.js

@@ -18,14 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var updateState_exports = {};
 __export(updateState_exports, {
+  hoistStateUpdate: () => hoistStateUpdate,
   updateState: () => updateState
 });
 module.exports = __toCommonJS(updateState_exports);
 var import_report = require("@domql/report");
 var import_event = require("@domql/event");
-var import_ignore = require("./ignore.js");
 var import_utils = require("@domql/utils");
-var import_inherit = require("./inherit.js");
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
   preventHoistElementUpdate: false,
@@ -43,51 +42,45 @@ 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)("beforeStateUpdate", obj, element, options);
+    const beforeStateUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeStateUpdate",
+      obj,
+      element,
+      options
+    );
     if (beforeStateUpdateReturns === false) return element;
   }
-  applyOverwrite(state, obj, options);
-  const updateIsHoisted = hoistStateUpdate(state, obj, options);
+  (0, import_utils.overwriteState)(state, obj, options);
+  const updateIsHoisted = await hoistStateUpdate(state, obj, options);
   if (updateIsHoisted) return state;
-  updateDependentState(state, obj, options);
-  applyElementUpdate(state, obj, options);
+  await updateDependentState(state, obj, options);
+  await applyElementUpdate(state, obj, options);
   if (!options.preventStateUpdateListener) {
     await (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
   }
   return state;
 };
-const applyOverwrite = (state, obj, options) => {
-  const { overwrite } = options;
-  if (!overwrite) return;
-  const shallow = overwrite === "shallow" || overwrite === "shallow-once";
-  const merge2 = overwrite === "merge";
-  if (merge2) {
-    (0, import_utils.deepMerge)(state, obj, import_ignore.IGNORE_STATE_PARAMS);
-    return;
-  }
-  const overwriteFunc = shallow ? import_utils.overwriteShallow : import_utils.overwriteDeep;
-  if (options.overwrite === "shallow-once") options.overwrite = true;
-  overwriteFunc(state, obj, import_ignore.IGNORE_STATE_PARAMS);
-};
-const hoistStateUpdate = (state, obj, options) => {
+const hoistStateUpdate = async (state, obj, options) => {
   const element = state.__element;
   const { parent, __ref: ref } = element;
   const stateKey = ref == null ? void 0 : ref.__state;
   const stateType = ref == null ? void 0 : ref.__stateType;
   if (!stateKey) return;
-  const asksForInherit = (0, import_inherit.checkIfInherits)(element);
-  const inheritedState = (0, import_inherit.findInheritedState)(element, parent, { returnParent: true });
+  const asksForInherit = (0, import_utils.checkIfInherits)(element);
+  const inheritedState = (0, import_utils.findInheritedState)(element, parent, {
+    returnParent: true
+  });
   const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation;
   if (!shouldPropagateState) return;
   const isStringState = stateType === "string" || stateType === "number" || stateType === "boolean";
   const value = isStringState ? state.value : state.parse();
   const passedValue = isStringState ? state.value : obj;
-  const findRootState = (0, import_inherit.getRootStateInKey)(stateKey, parent.state);
-  const findGrandParentState = (0, import_inherit.getParentStateInKey)(stateKey, parent.state);
-  const changesValue = (0, import_inherit.createNestedObjectByKeyPath)(stateKey, passedValue);
+  const findRootState = (0, import_utils.getRootStateInKey)(stateKey, parent.state);
+  const findGrandParentState = (0, import_utils.getParentStateInKey)(stateKey, parent.state);
+  const changesValue = (0, import_utils.createNestedObjectByKeyPath)(stateKey, passedValue);
   const targetParent = findRootState || findGrandParentState || parent.state;
   if (options.replace) (0, import_utils.overwriteDeep)(targetParent, changesValue || value);
-  targetParent.update(changesValue, {
+  await targetParent.update(changesValue, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -96,30 +89,37 @@ const hoistStateUpdate = (state, obj, options) => {
   });
   const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
+    await (0, import_event.triggerEventOnUpdate)("stateUpdate", obj, element, options);
   }
   return true;
 };
-const updateDependentState = (state, obj, options) => {
+const updateDependentState = async (state, obj, options) => {
   if (!state.__depends) return;
   for (const el in state.__depends) {
     const dependentState = state.__depends[el];
-    dependentState.clean().update(state.parse(), options);
+    const cleanState = await dependentState.clean();
+    await cleanState.update(state.parse(), options);
   }
 };
-const applyElementUpdate = (state, obj, options) => {
+const applyElementUpdate = async (state, obj, options) => {
   const element = state.__element;
   if (options.preventUpdate !== true) {
-    element.update({}, {
-      ...options,
-      updateByState: true
-    });
+    await element.update(
+      {},
+      {
+        ...options,
+        updateByState: true
+      }
+    );
   } else if (options.preventUpdate === "recursive") {
-    element.update({}, {
-      ...options,
-      isHoisted: false,
-      updateByState: true,
-      preventUpdate: true
-    });
+    await element.update(
+      {},
+      {
+        ...options,
+        isHoisted: false,
+        updateByState: true,
+        preventUpdate: true
+      }
+    );
   }
 };

package/dist/esm/create.js

@@ -1,161 +1,35 @@
-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 { triggerEventOn } from "@domql/event";
-import { deepClone, exec, is, isArray, isFunction, isObject, isUndefined } from "@domql/utils";
-import { IGNORE_STATE_PARAMS } from "./ignore.js";
 import {
-  add,
-  apply,
-  applyFunction,
-  clean,
-  destroy,
-  parentUpdate,
-  parse,
-  remove,
-  rootUpdate,
-  set,
-  reset,
-  toggle,
-  replace,
-  quietUpdate,
-  quietReplace,
-  applyReplace,
-  setByPath,
-  setPathCollection,
-  removeByPath,
-  removePathCollection,
-  getByPath,
-  keys,
-  values
-} from "./methods.js";
-import { updateState } from "./updateState.js";
-import { checkIfInherits, createInheritedState } from "./inherit.js";
+  applyDependentState,
+  checkForStateTypes,
+  checkIfInherits,
+  createInheritedState,
+  isUndefined
+} from "@domql/utils";
+import { applyStateMethods } from "./methods";
 const createState = async function(element, parent, options) {
   element.state = await applyInitialState(element, parent, options);
   return element.state;
 };
 const applyInitialState = async function(element, parent, options) {
-  const objectizeState = await checkForTypes(element);
+  const objectizeState = await checkForStateTypes(element);
   if (objectizeState === false) return parent.state || {};
   else element.state = objectizeState;
-  const whatInitReturns = triggerEventOn("stateInit", element, options);
+  const whatInitReturns = await 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 = applyDependentState(element, element.state || parent.state || {});
+  const dependentState = await applyDependentState(
+    element,
+    element.state || parent.state || {}
+  );
   if (dependentState) element.state = dependentState;
-  applyMethods(element);
-  triggerEventOn("stateCreated", element);
+  applyStateMethods(element);
+  await triggerEventOn("stateCreated", element);
   return element.state;
 };
-const applyDependentState = (element, state) => {
-  const { __ref, ref, __element } = state;
-  const origState = exec(__ref || ref || (__element == null ? void 0 : __element.state), element);
-  if (!origState) return;
-  const dependentState = deepClone(origState, IGNORE_STATE_PARAMS);
-  const newDepends = { [element.key]: dependentState };
-  const __depends = isObject(origState.__depends) ? __spreadValues(__spreadValues({}, origState.__depends), newDepends) : newDepends;
-  if (Array.isArray(origState)) {
-    addProtoToArray(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), { __depends }));
-  } else {
-    Object.setPrototypeOf(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), { __depends }));
-  }
-  return dependentState;
-};
-const checkForTypes = async (element) => {
-  const { state: orig, props, __ref: ref } = element;
-  const state = (props == null ? void 0 : props.state) || orig;
-  if (isFunction(state)) {
-    ref.__state = state;
-    return await exec(state, element);
-  } else if (is(state)("string", "number")) {
-    ref.__state = state;
-    return { value: state };
-  } else if (state === true) {
-    ref.__state = element.key;
-    return {};
-  } else if (state) {
-    ref.__hasRootState = true;
-    return state;
-  } else {
-    return false;
-  }
-};
-const addProtoToArray = (state, proto) => {
-  for (const key in proto) {
-    Object.defineProperty(state, key, {
-      value: proto[key],
-      enumerable: false,
-      // Set this to true if you want the method to appear in for...in loops
-      configurable: true,
-      // Set this to true if you want to allow redefining/removing the property later
-      writable: true
-      // Set this to true if you want to allow changing the function later
-    });
-  }
-};
-const applyMethods = (element) => {
-  const state = element.state;
-  const ref = element.__ref;
-  const proto = {
-    clean: clean.bind(state),
-    parse: parse.bind(state),
-    destroy: destroy.bind(state),
-    update: updateState.bind(state),
-    rootUpdate: rootUpdate.bind(state),
-    parentUpdate: parentUpdate.bind(state),
-    create: createState.bind(state),
-    add: add.bind(state),
-    toggle: toggle.bind(state),
-    remove: remove.bind(state),
-    apply: apply.bind(state),
-    applyReplace: applyReplace.bind(state),
-    applyFunction: applyFunction.bind(state),
-    set: set.bind(state),
-    quietUpdate: quietUpdate.bind(state),
-    replace: replace.bind(state),
-    quietReplace: quietReplace.bind(state),
-    reset: reset.bind(state),
-    parent: element.parent.state || state,
-    setByPath: setByPath.bind(state),
-    setPathCollection: setPathCollection.bind(state),
-    removeByPath: removeByPath.bind(state),
-    removePathCollection: removePathCollection.bind(state),
-    getByPath: getByPath.bind(state),
-    keys: keys.bind(state),
-    values: values.bind(state),
-    __element: element,
-    __children: {},
-    root: ref.root ? ref.root.state : state
-  };
-  if (isArray(state)) {
-    addProtoToArray(state, proto);
-  } else {
-    Object.setPrototypeOf(state, proto);
-  }
-  if (state.parent && state.parent.__children) {
-    state.parent.__children[element.key] = state;
-  }
-};
 export {
   applyInitialState,
   createState

package/dist/esm/index.js

@@ -1,5 +1,3 @@
-export * from "./ignore.js";
 export * from "./create.js";
 export * from "./updateState.js";
 export * from "./methods.js";
-export * from "./inherit.js";

package/dist/esm/methods.js

@@ -1,4 +1,6 @@
 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;
@@ -14,6 +16,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import {
   isArray,
   deepClone,
@@ -26,36 +29,39 @@ import {
   createNestedObject,
   getInObjectByPath,
   removeNestedKeyByPath,
-  setInObjectByPath
+  setInObjectByPath,
+  STATE_METHODS,
+  addProtoToArray
 } from "@domql/utils";
-import { IGNORE_STATE_PARAMS } from "./ignore.js";
+import { updateState } from "./updateState.js";
+import { createState } from "./create.js";
 const parse = function() {
   const state = this;
   if (isObject(state)) {
     const obj = {};
     for (const param in state) {
-      if (!IGNORE_STATE_PARAMS.includes(param)) {
+      if (!STATE_METHODS.includes(param)) {
         obj[param] = state[param];
       }
     }
     return obj;
   } else if (isArray(state)) {
-    return state.filter((item) => !IGNORE_STATE_PARAMS.includes(item));
+    return state.filter((item) => !STATE_METHODS.includes(item));
   }
 };
-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)) {
+    if (!STATE_METHODS.includes(param) && Object.hasOwnProperty.call(state, param)) {
       delete state[param];
     }
   }
   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;
@@ -88,124 +94,132 @@ 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.update(state.parse(), __spreadValues({ overwrite: true }, options));
   } else if (isObject(state)) {
     const key = Object.keys(state).length;
-    state.update({ [key]: value }, options);
+    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);
+  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();
+  if (options.applyReset) {
+    return await state.set(state.parse(), __spreadValues({ replace: true }, options));
+  }
+  return await state.update({}, options);
 };
-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));
+  const cleanState = await state.clean(__spreadValues({ preventStateUpdate: true }, options));
+  return await cleanState.update(value, __spreadValues({ replace: true }, options));
 };
-const setByPath = function(path, val, options = {}) {
+const setByPath = async function(path, val, options = {}) {
   const state = this;
   const value = deepClone(val);
   setInObjectByPath(state, path, val);
   const update = createNestedObject(path, value);
   if (options.preventStateUpdate) return update;
-  return state.update(update, options);
+  return await state.update(update, options);
 };
-const setPathCollection = function(changes, options = {}) {
+const setPathCollection = async function(changes, options = {}) {
   const state = this;
-  const update = changes.reduce((acc, change) => {
+  const update = await changes.reduce(async (promise, change) => {
+    const acc = await promise;
     if (change[0] === "update") {
-      const result = setByPath.call(state, change[1], change[2], { preventStateUpdate: true });
+      const result = setByPath.call(state, change[1], change[2], {
+        preventStateUpdate: true
+      });
       return overwriteDeep(acc, result);
     } else if (change[0] === "delete") {
-      removeByPath.call(state, change[1], options);
+      await removeByPath.call(state, change[1], __spreadProps(__spreadValues({}, options), {
+        preventUpdate: true
+      }));
     }
     return acc;
-  }, {});
+  }, Promise.resolve({}));
   return state.update(update, options);
 };
-const removeByPath = function(path, options = {}) {
+const removeByPath = async function(path, options = {}) {
   const state = this;
   removeNestedKeyByPath(state, path);
   if (options.preventUpdate) return path;
-  return state.update({}, options);
+  return await state.update({}, options);
 };
-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));
+    await func(state);
+    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;
@@ -215,11 +229,56 @@ const values = function(obj, options = {}) {
   const state = this;
   return Object.values(state);
 };
+const applyStateMethods = (element) => {
+  var _a;
+  const state = element.state;
+  const ref = element.__ref;
+  const proto = {
+    clean: clean.bind(state),
+    parse: parse.bind(state),
+    destroy: destroy.bind(state),
+    update: updateState.bind(state),
+    rootUpdate: rootUpdate.bind(state),
+    parentUpdate: parentUpdate.bind(state),
+    create: createState.bind(state),
+    add: add.bind(state),
+    toggle: toggle.bind(state),
+    remove: remove.bind(state),
+    apply: apply.bind(state),
+    applyReplace: applyReplace.bind(state),
+    applyFunction: applyFunction.bind(state),
+    set: set.bind(state),
+    quietUpdate: quietUpdate.bind(state),
+    replace: replace.bind(state),
+    quietReplace: quietReplace.bind(state),
+    reset: reset.bind(state),
+    parent: ((_a = element.parent) == null ? void 0 : _a.state) || state,
+    setByPath: setByPath.bind(state),
+    setPathCollection: setPathCollection.bind(state),
+    removeByPath: removeByPath.bind(state),
+    removePathCollection: removePathCollection.bind(state),
+    getByPath: getByPath.bind(state),
+    keys: keys.bind(state),
+    values: values.bind(state),
+    __element: element,
+    __children: {},
+    root: (ref == null ? void 0 : ref.root) ? ref.root.state : state
+  };
+  if (isArray(state)) {
+    addProtoToArray(state, proto);
+  } else {
+    Object.setPrototypeOf(state, proto);
+  }
+  if (state.parent && state.parent.__children) {
+    state.parent.__children[element.key] = state;
+  }
+};
 export {
   add,
   apply,
   applyFunction,
   applyReplace,
+  applyStateMethods,
   clean,
   destroy,
   getByPath,