@domql/state 2.5.185 → 2.5.186

package/create.js

@@ -2,7 +2,7 @@
 
 import { triggerEventOn } from '@domql/event'
 import { deepClone, exec, is, isArray, isFunction, isObject, isUndefined } from '@domql/utils'
-import { IGNORE_STATE_PARAMS } from './ignore'
+import { IGNORE_STATE_PARAMS } from './ignore.js'
 import {
   add,
   apply,
@@ -27,9 +27,9 @@ import {
   getByPath,
   keys,
   values
-} from './methods'
-import { updateState } from './updateState'
-import { checkIfInherits, createInheritedState } from './inherit'
+} from './methods.js'
+import { updateState } from './updateState.js'
+import { checkIfInherits, createInheritedState } from './inherit.js'
 
 export const createState = async function (element, parent, options) {
   element.state = await applyInitialState(element, parent, options)

package/dist/cjs/create.js

@@ -24,10 +24,10 @@ __export(create_exports, {
 module.exports = __toCommonJS(create_exports);
 var import_event = require("@domql/event");
 var import_utils = require("@domql/utils");
-var import_ignore = require("./ignore");
-var import_methods = require("./methods");
-var import_updateState = require("./updateState");
-var import_inherit = require("./inherit");
+var import_ignore = require("./ignore.js");
+var import_methods = require("./methods.js");
+var import_updateState = require("./updateState.js");
+var import_inherit = require("./inherit.js");
 const createState = async function(element, parent, options) {
   element.state = await applyInitialState(element, parent, options);
   return element.state;

package/dist/cjs/index.js

@@ -15,8 +15,8 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var state_exports = {};
 module.exports = __toCommonJS(state_exports);
-__reExport(state_exports, require("./ignore"), module.exports);
-__reExport(state_exports, require("./create"), module.exports);
-__reExport(state_exports, require("./updateState"), module.exports);
-__reExport(state_exports, require("./methods"), module.exports);
-__reExport(state_exports, require("./inherit"), module.exports);
+__reExport(state_exports, require("./ignore.js"), module.exports);
+__reExport(state_exports, require("./create.js"), module.exports);
+__reExport(state_exports, require("./updateState.js"), module.exports);
+__reExport(state_exports, require("./methods.js"), module.exports);
+__reExport(state_exports, require("./inherit.js"), module.exports);

package/dist/cjs/inherit.js

@@ -29,7 +29,7 @@ __export(inherit_exports, {
 });
 module.exports = __toCommonJS(inherit_exports);
 var import_utils = require("@domql/utils");
-var import_ignore = require("./ignore");
+var import_ignore = require("./ignore.js");
 const getRootStateInKey = (stateKey, parentState) => {
   if (!stateKey.includes("~/"))
     return;

package/dist/cjs/methods.js

@@ -44,7 +44,7 @@ __export(methods_exports, {
 });
 module.exports = __toCommonJS(methods_exports);
 var import_utils = require("@domql/utils");
-var import_ignore = require("./ignore");
+var import_ignore = require("./ignore.js");
 const parse = function() {
   const state = this;
   if ((0, import_utils.isObject)(state)) {

package/dist/cjs/updateState.js

@@ -23,9 +23,9 @@ __export(updateState_exports, {
 module.exports = __toCommonJS(updateState_exports);
 var import_report = require("@domql/report");
 var import_event = require("@domql/event");
-var import_ignore = require("./ignore");
+var import_ignore = require("./ignore.js");
 var import_utils = require("@domql/utils");
-var import_inherit = require("./inherit");
+var import_inherit = require("./inherit.js");
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,
   preventHoistElementUpdate: false,

package/dist/esm/create.js

@@ -0,0 +1,167 @@
+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";
+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);
+  if (objectizeState === false)
+    return parent.state || {};
+  else
+    element.state = objectizeState;
+  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 = applyDependentState(element, element.state || parent.state || {});
+  if (dependentState)
+    element.state = dependentState;
+  applyMethods(element);
+  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/ignore.js

@@ -0,0 +1,37 @@
+const IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+export {
+  IGNORE_STATE_PARAMS
+};

package/dist/esm/index.js

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

package/dist/esm/inherit.js

@@ -0,0 +1,110 @@
+import { deepClone, is, isObjectLike, isUndefined } from "@domql/utils";
+import { IGNORE_STATE_PARAMS } from "./ignore.js";
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/"))
+    return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1)
+    return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../"))
+    return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent)
+      return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = stateKey.split("/");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__")
+      return;
+    let childInParent = parentState[childKey];
+    if (!childInParent)
+      childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey])
+      childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent)
+    return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element))
+    return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState)
+    return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if (isUndefined(inheritedState))
+    return element.state;
+  if (is(inheritedState)("object", "array")) {
+    return deepClone(inheritedState, { exclude: IGNORE_STATE_PARAMS });
+  } else if (is(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const ref = element.__ref;
+  const stateKey = ref.__state;
+  if (stateKey && is(stateKey)("number", "string", "boolean"))
+    return true;
+  return false;
+};
+const isState = function(state) {
+  if (!isObjectLike(state))
+    return false;
+  return state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children;
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys.forEach((key, index) => {
+    ref[key] = index === keys.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+export {
+  checkIfInherits,
+  createInheritedState,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getChildStateInKey,
+  getParentStateInKey,
+  getRootStateInKey,
+  isState
+};

package/dist/esm/methods.js

@@ -0,0 +1,244 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import {
+  isArray,
+  deepClone,
+  isFunction,
+  isObject,
+  isString,
+  removeFromArray,
+  removeFromObject,
+  overwriteDeep,
+  createNestedObject,
+  getInObjectByPath,
+  removeNestedKeyByPath,
+  setInObjectByPath
+} from "@domql/utils";
+import { IGNORE_STATE_PARAMS } from "./ignore.js";
+const parse = function() {
+  const state = this;
+  if (isObject(state)) {
+    const obj = {};
+    for (const param in state) {
+      if (!IGNORE_STATE_PARAMS.includes(param)) {
+        obj[param] = state[param];
+      }
+    }
+    return obj;
+  } else if (isArray(state)) {
+    return state.filter((item) => !IGNORE_STATE_PARAMS.includes(item));
+  }
+};
+const clean = function(options = {}) {
+  const state = this;
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param) && Object.hasOwnProperty.call(state, param)) {
+      delete state[param];
+    }
+  }
+  if (!options.preventStateUpdate) {
+    state.update(state, __spreadValues({ replace: true }, options));
+  }
+  return state;
+};
+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));
+    return element.state;
+  }
+  delete element.state;
+  element.state = state.parent;
+  if (state.parent) {
+    delete state.parent.__children[element.key];
+  }
+  if (state.__children) {
+    for (const key in state.__children) {
+      const child = state.__children[key];
+      if (child.state) {
+        if (isArray(child.state)) {
+          Object.defineProperty(child.state, "parent", {
+            value: state.parent,
+            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
+          });
+        } else {
+          Object.setPrototypeOf(child, { parent: state.parent });
+        }
+      }
+    }
+  }
+  element.state.update({}, __spreadValues({ isHoisted: true }, options));
+  return element.state;
+};
+const parentUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state || !state.parent)
+    return;
+  return state.parent.update(obj, __spreadValues({ isHoisted: true }, options));
+};
+const rootUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = state.__element.__ref.root.state;
+  return rootState.update(obj, __spreadValues({ isHoisted: false }, options));
+};
+const add = function(value, options = {}) {
+  const state = this;
+  if (isArray(state)) {
+    state.push(value);
+    state.update(state.parse(), __spreadValues({ overwrite: true }, options));
+  } else if (isObject(state)) {
+    const key = Object.keys(state).length;
+    state.update({ [key]: value }, options);
+  }
+};
+const toggle = function(key, options = {}) {
+  const state = this;
+  state.update({ [key]: !state[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 state.set(state.parse(), __spreadValues({ replace: true }, options));
+  return state.update();
+};
+const set = function(val, options = {}) {
+  const state = this;
+  const value = deepClone(val);
+  return state.clean(__spreadValues({ preventStateUpdate: true }, options)).update(value, __spreadValues({ replace: true }, options));
+};
+const setByPath = function(path, val, options = {}) {
+  const state = this;
+  const value = deepClone(val);
+  setInObjectByPath(state, path, val);
+  const update = createNestedObject(path, value);
+  if (options.preventUpdate)
+    return update;
+  return state.update(update, options);
+};
+const setPathCollection = function(changes, options = {}) {
+  const state = this;
+  const update = changes.reduce((acc, change) => {
+    const result = setByPath(...change.slice(1), { preventUpdate: true });
+    return overwriteDeep(acc, result);
+  }, {});
+  return state.update(update, options);
+};
+const removeByPath = function(path, options = {}) {
+  const state = this;
+  removeNestedKeyByPath(state, path);
+  if (options.preventUpdate)
+    return path;
+  return state.update({}, options);
+};
+const removePathCollection = function(changes, options = {}) {
+  const state = this;
+  changes.forEach((item) => {
+    removeByPath(item, { preventUpdate: true });
+  });
+  return state.update({}, options);
+};
+const getByPath = function(path, options = {}) {
+  const state = this;
+  return getInObjectByPath(state, path);
+};
+const reset = function(options = {}) {
+  const state = this;
+  const value = deepClone(state.parse());
+  return state.set(value, __spreadValues({ replace: true }, options));
+};
+const apply = function(func, options = {}) {
+  const state = this;
+  if (isFunction(func)) {
+    const value = func(state);
+    return state.update(value, __spreadValues({ replace: true }, options));
+  }
+};
+const applyReplace = function(func, options = {}) {
+  const state = this;
+  if (isFunction(func)) {
+    const value = func(state);
+    return state.replace(value, options);
+  }
+};
+const applyFunction = function(func, options = {}) {
+  const state = this;
+  if (isFunction(func)) {
+    func(state);
+    return state.update(state.parse(), __spreadValues({ replace: true }, options));
+  }
+};
+const quietUpdate = function(obj, options = {}) {
+  const state = this;
+  return state.update(obj, __spreadValues({ preventUpdate: true }, options));
+};
+const replace = function(obj, options = {}) {
+  const state = this;
+  for (const param in obj) {
+    state[param] = obj[param];
+  }
+  return state.update(obj, options);
+};
+const quietReplace = function(obj, options = {}) {
+  const state = this;
+  return state.replace(obj, __spreadValues({ preventUpdate: true }, options));
+};
+const keys = function(obj, options = {}) {
+  const state = this;
+  return Object.keys(state);
+};
+const values = function(obj, options = {}) {
+  const state = this;
+  return Object.values(state);
+};
+export {
+  add,
+  apply,
+  applyFunction,
+  applyReplace,
+  clean,
+  destroy,
+  getByPath,
+  keys,
+  parentUpdate,
+  parse,
+  quietReplace,
+  quietUpdate,
+  remove,
+  removeByPath,
+  removePathCollection,
+  replace,
+  reset,
+  rootUpdate,
+  set,
+  setByPath,
+  setPathCollection,
+  toggle,
+  values
+};

package/dist/esm/updateState.js

@@ -0,0 +1,133 @@
+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 { IGNORE_STATE_PARAMS } from "./ignore.js";
+import { deepMerge, merge, overwriteDeep, overwriteShallow } from "@domql/utils";
+import { checkIfInherits, createNestedObjectByKeyPath, findInheritedState, getParentStateInKey, getRootStateInKey } from "./inherit.js";
+const STATE_UPDATE_OPTIONS = {
+  overwrite: true,
+  preventHoistElementUpdate: false,
+  updateByState: true,
+  isHoisted: true,
+  execStateFunction: true
+};
+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);
+  if (!options.updateByState)
+    merge(options, STATE_UPDATE_OPTIONS);
+  if (!state.__element)
+    report("ElementOnStateIsNotDefined");
+  if (options.preventInheritAtCurrentState === true) {
+    options.preventInheritAtCurrentState = state;
+  } else if (options.preventInheritAtCurrentState)
+    return;
+  if (!options.preventBeforeStateUpdateListener) {
+    const beforeStateUpdateReturns = triggerEventOnUpdate("beforeStateUpdate", obj, element, options);
+    if (beforeStateUpdateReturns === false)
+      return element;
+  }
+  applyOverwrite(state, obj, options);
+  const updateIsHoisted = hoistStateUpdate(state, obj, options);
+  if (updateIsHoisted)
+    return state;
+  updateDependentState(state, obj, options);
+  applyElementUpdate(state, obj, options);
+  if (!options.preventStateUpdateListener) {
+    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) {
+    deepMerge(state, obj, IGNORE_STATE_PARAMS);
+    return;
+  }
+  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+  if (options.overwrite === "shallow-once")
+    options.overwrite = true;
+  overwriteFunc(state, obj, IGNORE_STATE_PARAMS);
+};
+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;
+  if (!stateKey)
+    return;
+  const asksForInherit = checkIfInherits(element);
+  const inheritedState = 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 = getRootStateInKey(stateKey, parent.state);
+  const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+  const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
+  const targetParent = findRootState || findGrandParentState || parent.state;
+  if (options.replace)
+    overwriteDeep(targetParent, changesValue || value);
+  targetParent.update(changesValue, __spreadValues({
+    execStateFunction: false,
+    isHoisted: true,
+    preventUpdate: options.preventHoistElementUpdate,
+    overwrite: !options.replace
+  }, options));
+  const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
+  if (!options.preventStateUpdateListener && hasNotUpdated) {
+    triggerEventOnUpdate("stateUpdate", obj, element, options);
+  }
+  return true;
+};
+const updateDependentState = (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 applyElementUpdate = (state, obj, options) => {
+  const element = state.__element;
+  if (options.preventUpdate !== true) {
+    element.update({}, __spreadProps(__spreadValues({}, options), {
+      updateByState: true
+    }));
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, __spreadProps(__spreadValues({}, options), {
+      isHoisted: false,
+      updateByState: true,
+      preventUpdate: true
+    }));
+  }
+};
+export {
+  updateState
+};

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
-export * from './ignore'
-export * from './create'
-export * from './updateState'
-export * from './methods'
-export * from './inherit'
+export * from './ignore.js'
+export * from './create.js'
+export * from './updateState.js'
+export * from './methods.js'
+export * from './inherit.js'

package/inherit.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import { deepClone, is, isObjectLike, isUndefined } from '@domql/utils'
-import { IGNORE_STATE_PARAMS } from './ignore'
+import { IGNORE_STATE_PARAMS } from './ignore.js'
 
 export const getRootStateInKey = (stateKey, parentState) => {
   if (!stateKey.includes('~/')) return

package/methods.js

@@ -15,7 +15,7 @@ import {
   setInObjectByPath
 } from '@domql/utils'
 
-import { IGNORE_STATE_PARAMS } from './ignore'
+import { IGNORE_STATE_PARAMS } from './ignore.js'
 
 export const parse = function () {
   const state = this

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@domql/state",
-  "version": "2.5.185",
+  "version": "2.5.186",
   "license": "MIT",
   "type": "module",
-  "module": "dist/esm/index.js",
+  "module": "index.js",
+  "main": "index.js",
   "unpkg": "dist/iife/index.js",
   "jsdelivr": "dist/iife/index.js",
-  "main": "dist/esm/index.js",
   "exports": {
     ".": {
-      "kalduna": "./index.js",
-      "default": "./dist/cjs/index.js"
+      "default": "./dist/esm/index.js",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
     }
   },
   "source": "index.js",
@@ -23,13 +24,13 @@
     "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": "npm run build:cjs",
+    "build": "rimraf -I dist; npm run build:cjs; npm run build:esm",
     "prepublish": "rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.5.185",
-    "@domql/report": "^2.5.162",
+    "@domql/event": "^2.5.186",
+    "@domql/report": "^2.5.186",
     "@domql/utils": "^2.5.185"
   },
-  "gitHead": "ccab034f188b6a1f55f741c0b29a9d3b0c9bee6f"
+  "gitHead": "1fa4d0c2683c11578893632ca11a765c3997685e"
 }

package/updateState.js

@@ -2,9 +2,9 @@
 
 import { report } from '@domql/report'
 import { triggerEventOnUpdate } from '@domql/event'
-import { IGNORE_STATE_PARAMS } from './ignore'
+import { IGNORE_STATE_PARAMS } from './ignore.js'
 import { deepMerge, merge, overwriteDeep, overwriteShallow } from '@domql/utils'
-import { checkIfInherits, createNestedObjectByKeyPath, findInheritedState, getParentStateInKey, getRootStateInKey } from './inherit'
+import { checkIfInherits, createNestedObjectByKeyPath, findInheritedState, getParentStateInKey, getRootStateInKey } from './inherit.js'
 
 const STATE_UPDATE_OPTIONS = {
   overwrite: true,