@domql/state 2.3.118 → 2.3.120

package/createState.js

@@ -0,0 +1,91 @@
+'use strict'
+
+import { triggerEventOn } from '@domql/event'
+import { deepClone, exec, is, isFunction, isObject } from '@domql/utils'
+import { IGNORE_STATE_PARAMS } from './ignore'
+import { add, apply, clean, destroy, parse, remove, rootUpdate, toggle } from './methods'
+import { updateState } from './updateState'
+import { checkIfInherits, createInheritedState } from './utils'
+
+export const createState = function (element, parent, opts) {
+  const skip = (opts && opts.skip) ? opts.skip : false
+  let { state, __ref: __elementRef } = element
+
+  state = element.state = checkForTypes(element)
+
+  triggerEventOn('stateInit', element)
+
+  if (checkIfInherits(element)) {
+    state = element.state = createInheritedState(element, parent) || {}
+  }
+
+  if (!state) {
+    if (parent && parent.state) return parent.state
+    return {}
+  } else {
+    __elementRef.__hasRootState = true
+  }
+
+  // reference other state
+  // TODO: check why __ref is assigned with element
+  // /docs/intro
+  const { __ref } = state
+  if (__ref) {
+    state = deepClone(__ref, IGNORE_STATE_PARAMS)
+    if (isObject(__ref.__depends)) {
+      __ref.__depends[element.key] = state
+    } else __ref.__depends = { [element.key]: state }
+  } else {
+    state = deepClone(state, IGNORE_STATE_PARAMS)
+  }
+
+  element.state = state
+
+  // NOTE: Only true when 'onlyResolveExtends' option is set to true
+  if (skip) return state
+
+  applyMethods(element, state)
+
+  // trigger `on.stateCreated`
+  triggerEventOn('stateCreated', element)
+
+  return state
+}
+
+const checkForTypes = (element) => {
+  const { state, __ref: __elementRef } = element
+  if (isFunction(state)) {
+    __elementRef.__state = state
+    return exec(state, element)
+  }
+  if (is(state)('string', 'number')) {
+    __elementRef.__state = state
+    return {}
+  }
+  if (state === true) {
+    __elementRef.__state = element.key
+    return {}
+  }
+  return state
+}
+
+const applyMethods = (element, state) => {
+  const __elementRef = element.__ref
+
+  state.clean = clean
+  state.parse = parse
+  state.destroy = destroy
+  state.update = updateState
+  state.rootUpdate = rootUpdate
+  state.create = createState
+  state.add = add
+  state.toggle = toggle
+  state.remove = remove
+  state.apply = apply
+  state.parent = element.parent.state
+  state.__element = element
+  state.__children = {}
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state
+
+  if (state.parent) state.parent.__children[element.key] = state
+}

package/dist/cjs/createState.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createState_exports = {};
+__export(createState_exports, {
+  createState: () => createState
+});
+module.exports = __toCommonJS(createState_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_utils2 = require("./utils");
+const createState = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state, __ref: __elementRef } = element;
+  state = element.state = checkForTypes(element);
+  (0, import_event.triggerEventOn)("stateInit", element);
+  if ((0, import_utils2.checkIfInherits)(element)) {
+    state = element.state = (0, import_utils2.createInheritedState)(element, parent) || {};
+  }
+  if (!state) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  const { __ref } = state;
+  if (__ref) {
+    state = (0, import_utils.deepClone)(__ref, import_ignore.IGNORE_STATE_PARAMS);
+    if ((0, import_utils.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state;
+    } else
+      __ref.__depends = { [element.key]: state };
+  } else {
+    state = (0, import_utils.deepClone)(state, import_ignore.IGNORE_STATE_PARAMS);
+  }
+  element.state = state;
+  if (skip)
+    return state;
+  applyMethods(element, state);
+  (0, import_event.triggerEventOn)("stateCreated", element);
+  return state;
+};
+const checkForTypes = (element) => {
+  const { state, __ref: __elementRef } = element;
+  if ((0, import_utils.isFunction)(state)) {
+    __elementRef.__state = state;
+    return (0, import_utils.exec)(state, element);
+  }
+  if ((0, import_utils.is)(state)("string", "number")) {
+    __elementRef.__state = state;
+    return {};
+  }
+  if (state === true) {
+    __elementRef.__state = element.key;
+    return {};
+  }
+  return state;
+};
+const applyMethods = (element, state) => {
+  const __elementRef = element.__ref;
+  state.clean = import_methods.clean;
+  state.parse = import_methods.parse;
+  state.destroy = import_methods.destroy;
+  state.update = import_updateState.updateState;
+  state.rootUpdate = import_methods.rootUpdate;
+  state.create = createState;
+  state.add = import_methods.add;
+  state.toggle = import_methods.toggle;
+  state.remove = import_methods.remove;
+  state.apply = import_methods.apply;
+  state.parent = element.parent.state;
+  state.__element = element;
+  state.__children = {};
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
+  if (state.parent)
+    state.parent.__children[element.key] = state;
+};

package/dist/cjs/ignore.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ignore_exports = {};
+__export(ignore_exports, {
+  IGNORE_STATE_PARAMS: () => IGNORE_STATE_PARAMS
+});
+module.exports = __toCommonJS(ignore_exports);
+const IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "rootUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "__root"
+];

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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("./createState"), module.exports);
+__reExport(state_exports, require("./updateState"), module.exports);
+__reExport(state_exports, require("./methods"), module.exports);
+__reExport(state_exports, require("./utils"), module.exports);

package/dist/cjs/methods.js

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var methods_exports = {};
+__export(methods_exports, {
+  add: () => add,
+  apply: () => apply,
+  clean: () => clean,
+  destroy: () => destroy,
+  parse: () => parse,
+  remove: () => remove,
+  rootUpdate: () => rootUpdate,
+  toggle: () => toggle
+});
+module.exports = __toCommonJS(methods_exports);
+var import_utils = require("@domql/utils");
+var import_ignore = require("./ignore");
+const parse = function() {
+  const state = this;
+  if ((0, import_utils.isObject)(state)) {
+    const obj = {};
+    for (const param in state) {
+      if (!import_ignore.IGNORE_STATE_PARAMS.includes(param)) {
+        obj[param] = state[param];
+      }
+    }
+    return obj;
+  } else if ((0, import_utils.isArray)(state)) {
+    return state.filter((item) => !import_ignore.IGNORE_STATE_PARAMS.includes(item));
+  }
+};
+const clean = function(options = {}) {
+  const state = this;
+  for (const param in state) {
+    if (!import_ignore.IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param];
+    }
+  }
+  state.update(state, { skipOverwrite: true, options });
+  return state;
+};
+const destroy = function() {
+  const state = this;
+  const element = state.__element;
+  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) {
+        child.parent = state.parent;
+      }
+    }
+  }
+  element.state.update();
+  return element.state;
+};
+const rootUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = state.__element.__ref.__root.state;
+  return rootState.update(obj, options);
+};
+const add = function(value, options = {}) {
+  const state = this;
+  if ((0, import_utils.isArray)(state)) {
+    state.push(value);
+    state.update(state.parse(), { skipOverwrite: true, ...options });
+  }
+};
+const toggle = function(key, options = {}) {
+  const state = this;
+  state[key] = !state[key];
+  state.update({ [key]: !state[key] }, { skipOverwrite: true, ...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);
+  return state.update(state.parse(), { skipOverwrite: true, ...options });
+};
+const apply = function(func, options = {}) {
+  const state = this;
+  if ((0, import_utils.isFunction)(func)) {
+    func(state);
+    return state.update(state, { skipOverwrite: true, ...options });
+  }
+};

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}

package/dist/cjs/updateState.js

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var updateState_exports = {};
+__export(updateState_exports, {
+  updateState: () => updateState
+});
+module.exports = __toCommonJS(updateState_exports);
+var import_report = require("@domql/report");
+var import_event = require("@domql/event");
+var import_ignore = require("./ignore");
+var import_utils = require("@domql/utils");
+var import_utils2 = require("./utils");
+const updateState = function(obj, options = {}) {
+  const state = this;
+  const element = state.__element;
+  if (!state.__element)
+    (0, import_report.report)("ElementOnStateIsNotDefined");
+  if (!options.preventInitStateUpdateListener) {
+    const initStateUpdateReturns = (0, import_event.triggerEventOn)("initStateUpdated", element, obj);
+    if (initStateUpdateReturns === false)
+      return element;
+  }
+  applyOverwrite(state, obj, options);
+  hoistStateUpdate(state, obj, options);
+  applyDependentState(state, obj, options);
+  applyElementUpdate(state, obj, options);
+  if (!options.preventStateUpdateListener) {
+    (0, import_event.triggerEventOn)("stateUpdated", element, obj);
+  }
+  return state;
+};
+const applyOverwrite = (state, obj, options) => {
+  const { skipOverwrite, shallow } = options;
+  if (skipOverwrite === "merge") {
+    (0, import_utils.deepMerge)(state, obj, import_ignore.IGNORE_STATE_PARAMS);
+    return;
+  }
+  if (!skipOverwrite) {
+    const overwriteFunc = shallow ? import_utils.overwriteShallow : import_utils.overwriteDeep;
+    overwriteFunc(state, obj, import_ignore.IGNORE_STATE_PARAMS);
+  }
+};
+const hoistStateUpdate = (state, obj, options) => {
+  const element = state.__element;
+  const __elementRef = element.__ref;
+  const stateKey = __elementRef.__state;
+  const hasParentState = (0, import_utils2.checkIfInherits)(element);
+  const shouldPropagateState = stateKey && hasParentState && !options.stopStatePropagation;
+  const parentState = element.parent.state;
+  if (shouldPropagateState) {
+    const isStringState = __elementRef.__stateType === "string";
+    const value = isStringState ? state.value : state.parse();
+    const passedValue = isStringState ? state.value : obj;
+    parentState[stateKey] = value;
+    parentState.update({ [stateKey]: passedValue }, {
+      skipOverwrite: true,
+      preventUpdate: options.preventHoistElementUpdate,
+      ...options
+    });
+  }
+};
+const applyDependentState = (state, obj, options) => {
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el];
+      findElement.clean().update(state.parse(), options);
+    }
+  }
+};
+const applyElementUpdate = (state, obj, options) => {
+  const element = state.__element;
+  if (!options.preventUpdate) {
+    element.update({}, {
+      ...options,
+      updateByState: true,
+      preventUpdateTriggerStateUpdate: true
+    });
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, {
+      ...options,
+      preventUpdateTriggerStateUpdate: true,
+      updateByState: true,
+      preventUpdate: true
+    });
+  }
+};

package/dist/cjs/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  checkIfInherits: () => checkIfInherits,
+  createInheritedState: () => createInheritedState,
+  getChildStateInKey: () => getChildStateInKey,
+  getParentStateInKey: () => getParentStateInKey,
+  isState: () => isState
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@domql/utils");
+const getParentStateInKey = (stateKey, parentState) => {
+  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) => {
+  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];
+    const childInParent = parentState[childKey];
+    if (childInParent && childInParent[grandChildKey]) {
+      stateKey = grandChildKey;
+      parentState = childInParent;
+    } else
+      return;
+  }
+  return parentState[stateKey];
+};
+const createInheritedState = (element, parent) => {
+  const __elementRef = element.__ref;
+  let stateKey = __elementRef.__state;
+  if (!stateKey || (0, import_utils.isNot)(stateKey)("number", "string"))
+    return element.state;
+  let parentState = parent.state;
+  if (stateKey.includes("../")) {
+    parentState = getParentStateInKey(stateKey, parent.state);
+    stateKey = stateKey.replaceAll("../", "");
+  }
+  if (!parentState)
+    return;
+  const keyInParentState = getChildStateInKey(stateKey, parentState);
+  if (!keyInParentState)
+    return;
+  if ((0, import_utils.is)(keyInParentState)("object", "array")) {
+    return (0, import_utils.deepClone)(keyInParentState);
+  } else if ((0, import_utils.is)(keyInParentState)("string", "number")) {
+    __elementRef.__stateType = "string";
+    return { value: keyInParentState };
+  }
+  console.warn(stateKey, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const __elementRef = element.__ref;
+  const stateKey = __elementRef.__state;
+  if (!stateKey || (0, import_utils.isNot)(stateKey)("number", "string"))
+    return false;
+  return true;
+};
+const isState = function(state) {
+  if (!(0, import_utils.isObjectLike)(state))
+    return false;
+  const keys = Object.keys(state);
+  return (0, import_utils.arrayContainsOtherArray)(keys, ["update", "parse", "clean", "create", "parent", "rootUpdate"]);
+};

package/ignore.js

@@ -1,6 +1,6 @@
 'use strict'
 
 export const IGNORE_STATE_PARAMS = [
-  'update', 'parse', 'clean', 'create', 'destroy', 'add', 'remove', 'apply', 'rootUpdate',
-  'parent', '__element', '__depends', '__ref', '__children', '__root'
+  'update', 'parse', 'clean', 'create', 'destroy', 'add', 'toggle', 'remove', 'apply',
+  'rootUpdate', 'parent', '__element', '__depends', '__ref', '__children', '__root'
 ]

package/index.js

@@ -1,280 +1,7 @@
 'use strict'
 
-import { IGNORE_STATE_PARAMS } from './ignore'
-
-import { triggerEventOn } from '@domql/event'
-import {
-  is,
-  isObject,
-  exec,
-  isFunction,
-  isUndefined,
-  arrayContainsOtherArray,
-  isObjectLike,
-  isArray,
-  removeFromArray,
-  removeFromObject,
-  deepClone,
-  overwriteShallow,
-  overwriteDeep
-} from '@domql/utils'
-
-export 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))
-  }
-}
-
-export const clean = function (options = {}) {
-  const state = this
-  for (const param in state) {
-    if (!IGNORE_STATE_PARAMS.includes(param)) {
-      delete state[param]
-    }
-  }
-  state.update(state, { skipOverwrite: true, options })
-  return state
-}
-
-export const destroy = function () {
-  const state = this
-  const element = state.__element
-  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) {
-        child.parent = state.parent
-      }
-    }
-  }
-
-  element.state.update()
-  return element.state
-}
-
-export const rootUpdate = function (obj, options = {}) {
-  const state = this
-  if (!state) return
-  const rootState = (state.__element.__ref.__root).state
-  return rootState.update(obj, options)
-}
-
-export const updateState = function (obj, options = {}) {
-  const state = this
-  const element = state.__element
-  const __elementRef = element.__ref
-  const parentState = element.parent.state
-  state.parent = parentState
-
-  for (const param in state) {
-    if (isUndefined(state[param])) {
-      delete state[param]
-    }
-  }
-
-  if (!state.__element) {
-    create(element, element.parent)
-  }
-
-  const initStateUpdateReturns = triggerEventOn('initStateUpdated', element, obj)
-  if (initStateUpdateReturns === false) return element
-
-  if (!options.skipOverwrite) {
-    if (options.shallow) {
-      overwriteShallow(state, obj, IGNORE_STATE_PARAMS)
-    } else {
-      overwriteDeep(state, obj, IGNORE_STATE_PARAMS)
-    }
-  }
-
-  const stateKey = __elementRef.__state
-  const shouldPropagateState = stateKey && parentState && parentState[stateKey] && !options.stopStatePropagation
-  if (shouldPropagateState) {
-    const isStringState = (__elementRef.__stateType === 'string')
-    const value = isStringState ? state.value : state.parse()
-    parentState[stateKey] = value
-    parentState.update(value, { skipOverwrite: true, ...options })
-    return state
-  }
-
-  if (!options.preventUpdate) {
-    element.update({}, options)
-  } else if (options.preventUpdate === 'recursive') {
-    element.update({}, { ...options, preventUpdate: true })
-  }
-
-  if (state.__depends) {
-    for (const el in state.__depends) {
-      const findElement = state.__depends[el]
-      findElement.clean().update(state.parse(), options)
-    }
-  }
-
-  if (!options.preventUpdateListener) {
-    triggerEventOn('stateUpdated', element, obj)
-  }
-
-  return state
-}
-
-export const remove = function (key, options) {
-  const state = this
-  if (isArray(state)) removeFromArray(state, key)
-  if (isObject(state)) removeFromObject(state, key)
-  return state.update(state, { skipOverwrite: true, options })
-}
-
-export const apply = function (func, options) {
-  const state = this
-  if (isFunction(func)) {
-    func(state)
-    return state.update(state, { skipOverwrite: true, options })
-  }
-}
-
-const getParentStateInKey = (stateKey, parentState) => {
-  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) => {
-  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]
-    const childInParent = parentState[childKey]
-    if (childInParent && childInParent[grandChildKey]) {
-      stateKey = grandChildKey
-      parentState = childInParent
-    } else return
-  }
-  return parentState[stateKey]
-}
-
-const createInheritedState = function (element, parent) {
-  const __elementRef = element.__ref
-  let stateKey = __elementRef.__state
-  if (!stateKey) return element.state
-
-  let parentState = parent.state
-  if (stateKey.includes('../')) {
-    parentState = getParentStateInKey(stateKey, parent.state)
-    stateKey = stateKey.replaceAll('../', '')
-  }
-  if (!parentState) return {}
-
-  const keyInParentState = getChildStateInKey(stateKey, parentState)
-  if (!keyInParentState) return {}
-
-  if (is(keyInParentState)('object', 'array')) {
-    return deepClone(keyInParentState, IGNORE_STATE_PARAMS)
-  } else if (is(keyInParentState)('string', 'number')) {
-    __elementRef.__stateType = 'string'
-    return { value: keyInParentState }
-  }
-
-  console.warn(stateKey, 'is not present. Replacing with', {})
-  return {}
-}
-
-export const createState = function (element, parent, opts) {
-  const skip = (opts && opts.skip) ? opts.skip : false
-  let { state, __ref: __elementRef } = element
-
-  if (isFunction(state)) element.state = exec(state, element)
-
-  if (is(state)('string', 'number')) {
-    __elementRef.__state = state
-    element.state = {}
-  }
-  if (state === true) {
-    __elementRef.__state = element.key
-    element.state = {}
-  }
-
-  // trigger `on.stateInit`
-  triggerEventOn('stateInit', element)
-
-  state = element.state = createInheritedState(element, parent)
-
-  if (!state) {
-    if (parent && parent.state) return parent.state
-    return {}
-  } else {
-    __elementRef.__hasRootState = true
-  }
-
-  // reference other state
-  // TODO: check why __ref is assigned with element
-  // /docs/intro
-  const { __ref } = state
-  if (__ref) {
-    state = deepClone(__ref, IGNORE_STATE_PARAMS)
-    if (isObject(__ref.__depends)) {
-      __ref.__depends[element.key] = state
-    } else __ref.__depends = { [element.key]: state }
-  } else {
-    state = deepClone(state, IGNORE_STATE_PARAMS)
-  }
-
-  element.state = state
-
-  // NOTE: Only true when 'onlyResolveExtends' option is set to true
-  if (skip) return state
-
-  applyMethods(element, state)
-
-  // trigger `on.stateCreated`
-  triggerEventOn('stateCreated', element)
-
-  return state
-}
-
-export const isState = function (state) {
-  if (!isObjectLike(state)) return false
-  const keys = Object.keys(state)
-  return arrayContainsOtherArray(keys, ['update', 'parse', 'clean', 'create', 'parent', 'rootUpdate'])
-}
-
-const applyMethods = (element, state) => {
-  const __elementRef = element.__ref
-
-  state.clean = clean
-  state.parse = parse
-  state.destroy = destroy
-  state.update = updateState
-  state.rootUpdate = rootUpdate
-  state.create = createState
-  state.remove = remove
-  state.apply = apply
-  state.parent = element.parent.state
-  state.__element = element
-  state.__children = {}
-  state.__root = __elementRef.__root ? __elementRef.__root.state : state
-
-  if (state.parent) state.parent.__children[element.key] = state
-}
-
-export default createState
+export * from './ignore'
+export * from './createState'
+export * from './updateState'
+export * from './methods'
+export * from './utils'

package/methods.js

@@ -0,0 +1,90 @@
+'use strict'
+
+import { isArray, isFunction, isObject, removeFromArray, removeFromObject } from '@domql/utils'
+
+import { IGNORE_STATE_PARAMS } from './ignore'
+
+export 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))
+  }
+}
+
+export const clean = function (options = {}) {
+  const state = this
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param]
+    }
+  }
+  state.update(state, { skipOverwrite: true, options })
+  return state
+}
+
+export const destroy = function () {
+  const state = this
+  const element = state.__element
+  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) {
+        child.parent = state.parent
+      }
+    }
+  }
+
+  element.state.update()
+  return element.state
+}
+
+export const rootUpdate = function (obj, options = {}) {
+  const state = this
+  if (!state) return
+  const rootState = (state.__element.__ref.__root).state
+  return rootState.update(obj, options)
+}
+
+export const add = function (value, options = {}) {
+  const state = this
+  if (isArray(state)) {
+    state.push(value)
+    state.update(state.parse(), { skipOverwrite: true, ...options })
+  }
+}
+
+export const toggle = function (key, options = {}) {
+  const state = this
+  state[key] = !state[key]
+  state.update({ [key]: !state[key] }, { skipOverwrite: true, ...options })
+}
+
+export const remove = function (key, options = {}) {
+  const state = this
+  if (isArray(state)) removeFromArray(state, key)
+  if (isObject(state)) removeFromObject(state, key)
+  return state.update(state.parse(), { skipOverwrite: true, ...options })
+}
+
+export const apply = function (func, options = {}) {
+  const state = this
+  if (isFunction(func)) {
+    func(state)
+    return state.update(state, { skipOverwrite: true, ...options })
+  }
+}

package/package.json

@@ -1,12 +1,30 @@
 {
   "name": "@domql/state",
-  "version": "2.3.118",
-  "main": "index.js",
+  "version": "2.3.120",
   "license": "MIT",
+  "type": "module",
+  "module": "dist/esm/index.js",
+  "unpkg": "dist/iife/index.js",
+  "jsdelivr": "dist/iife/index.js",
+  "main": "dist/esm/index.js",
+  "exports": "./dist/cjs/index.js",
+  "source": "index.js",
+  "files": [
+    "*.js",
+    "dist"
+  ],
+  "scripts": {
+    "copy:package:cjs": "cp ../../.build/package-cjs.json dist/cjs/package.json",
+    "build:esm": "npx esbuild *.js --target=es2019 --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": "yarn build:cjs",
+    "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
+  },
   "dependencies": {
     "@domql/event": "latest",
+    "@domql/report": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "51d72040aa837fc2b93e7699277750797af276f1",
-  "source": "index.js"
+  "gitHead": "6e932a813b8e6ee0a57a40ebc6dc757cc44e6427"
 }

package/updateState.js

@@ -0,0 +1,96 @@
+'use strict'
+
+import { report } from '@domql/report'
+import { triggerEventOn } from '@domql/event'
+import { IGNORE_STATE_PARAMS } from './ignore'
+import { deepMerge, overwriteDeep, overwriteShallow } from '@domql/utils'
+import { checkIfInherits } from './utils'
+
+export const updateState = function (obj, options = {}) {
+  const state = this
+  const element = state.__element
+
+  if (!state.__element) report('ElementOnStateIsNotDefined')
+
+  if (!options.preventInitStateUpdateListener) {
+    const initStateUpdateReturns = triggerEventOn('initStateUpdated', element, obj)
+    if (initStateUpdateReturns === false) return element
+  }
+
+  applyOverwrite(state, obj, options)
+
+  hoistStateUpdate(state, obj, options)
+
+  applyDependentState(state, obj, options)
+
+  applyElementUpdate(state, obj, options)
+
+  if (!options.preventStateUpdateListener) {
+    triggerEventOn('stateUpdated', element, obj)
+  }
+
+  return state
+}
+
+const applyOverwrite = (state, obj, options) => {
+  const { skipOverwrite, shallow } = options
+
+  if (skipOverwrite === 'merge') {
+    deepMerge(state, obj, IGNORE_STATE_PARAMS)
+    return
+  }
+
+  if (!skipOverwrite) {
+    const overwriteFunc = shallow ? overwriteShallow : overwriteDeep
+    overwriteFunc(state, obj, IGNORE_STATE_PARAMS)
+  }
+}
+
+const hoistStateUpdate = (state, obj, options) => {
+  const element = state.__element
+  const __elementRef = element.__ref
+  const stateKey = __elementRef.__state
+  const hasParentState = checkIfInherits(element)
+  const shouldPropagateState = stateKey && hasParentState && !options.stopStatePropagation
+  const parentState = element.parent.state
+
+  if (shouldPropagateState) {
+    const isStringState = (__elementRef.__stateType === 'string')
+    const value = isStringState ? state.value : state.parse()
+    const passedValue = isStringState ? state.value : obj
+
+    parentState[stateKey] = value
+    parentState.update({ [stateKey]: passedValue }, {
+      skipOverwrite: true,
+      preventUpdate: options.preventHoistElementUpdate,
+      ...options
+    })
+  }
+}
+
+const applyDependentState = (state, obj, options) => {
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el]
+      findElement.clean().update(state.parse(), options)
+    }
+  }
+}
+
+const applyElementUpdate = (state, obj, options) => {
+  const element = state.__element
+  if (!options.preventUpdate) {
+    element.update({}, {
+      ...options,
+      updateByState: true,
+      preventUpdateTriggerStateUpdate: true
+    })
+  } else if (options.preventUpdate === 'recursive') {
+    element.update({}, {
+      ...options,
+      preventUpdateTriggerStateUpdate: true,
+      updateByState: true,
+      preventUpdate: true
+    })
+  }
+}

package/utils.js

@@ -0,0 +1,66 @@
+'use strict'
+
+import { arrayContainsOtherArray, deepClone, is, isNot, isObjectLike } from '@domql/utils'
+
+export const getParentStateInKey = (stateKey, parentState) => {
+  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
+}
+
+export const getChildStateInKey = (stateKey, parentState) => {
+  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]
+    const childInParent = parentState[childKey]
+    if (childInParent && childInParent[grandChildKey]) {
+      stateKey = grandChildKey
+      parentState = childInParent
+    } else return
+  }
+  return parentState[stateKey]
+}
+
+export const createInheritedState = (element, parent) => {
+  const __elementRef = element.__ref
+  let stateKey = __elementRef.__state
+  if (!stateKey || isNot(stateKey)('number', 'string')) return element.state
+
+  let parentState = parent.state
+  if (stateKey.includes('../')) {
+    parentState = getParentStateInKey(stateKey, parent.state)
+    stateKey = stateKey.replaceAll('../', '')
+  }
+  if (!parentState) return
+
+  const keyInParentState = getChildStateInKey(stateKey, parentState)
+  if (!keyInParentState) return
+
+  if (is(keyInParentState)('object', 'array')) {
+    return deepClone(keyInParentState)
+  } else if (is(keyInParentState)('string', 'number')) {
+    __elementRef.__stateType = 'string'
+    return { value: keyInParentState }
+  }
+
+  console.warn(stateKey, 'is not present. Replacing with', {})
+}
+
+export const checkIfInherits = (element) => {
+  const __elementRef = element.__ref
+  const stateKey = __elementRef.__state
+  if (!stateKey || isNot(stateKey)('number', 'string')) return false
+  return true
+}
+
+export const isState = function (state) {
+  if (!isObjectLike(state)) return false
+  const keys = Object.keys(state)
+  return arrayContainsOtherArray(keys, ['update', 'parse', 'clean', 'create', 'parent', 'rootUpdate'])
+}