@domql/state 2.5.200 → 3.0.0

package/create.js

@@ -1,35 +1,15 @@
 'use strict'
 
 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'
 
 export const createState = async function (element, parent, options) {
   element.state = await applyInitialState(element, parent, options)
@@ -37,11 +17,11 @@ export const createState = async function (element, parent, options) {
 }
 
 export 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)) {
@@ -49,111 +29,16 @@ export const applyInitialState = async function (element, parent, options) {
     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)
+  applyStateMethods(element)
 
   // trigger `on.stateCreated`
-  triggerEventOn('stateCreated', element)
+  await triggerEventOn('stateCreated', element)
 
   return element.state
 }
-
-const applyDependentState = (element, state) => {
-  const { __ref, ref, __element } = state //
-  const origState = exec(__ref || ref || __element?.state, element)
-  if (!origState) return
-  const dependentState = deepClone(origState, IGNORE_STATE_PARAMS)
-  const newDepends = { [element.key]: dependentState }
-
-  const __depends = isObject(origState.__depends)
-    ? { ...origState.__depends, ...newDepends }
-    : newDepends
-
-  if (Array.isArray(origState)) {
-    addProtoToArray(origState, { ...Object.getPrototypeOf(origState), __depends })
-  } else {
-    Object.setPrototypeOf(origState, { ...Object.getPrototypeOf(origState), __depends })
-  }
-
-  return dependentState
-}
-
-const checkForTypes = async (element) => {
-  const { state: orig, props, __ref: ref } = element
-  const state = 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 }
-}

package/dist/cjs/create.js

@@ -24,116 +24,27 @@ __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.js");
-var import_methods = require("./methods.js");
-var import_updateState = require("./updateState.js");
-var import_inherit = require("./inherit.js");
+var import_methods = require("./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 (0, import_utils.checkForStateTypes)(element);
   if (objectizeState === false) return parent.state || {};
   else element.state = objectizeState;
-  const whatInitReturns = (0, import_event.triggerEventOn)("stateInit", element, options);
+  const whatInitReturns = await (0, import_event.triggerEventOn)("stateInit", element, options);
   if (whatInitReturns === false) return element.state;
-  if ((0, import_inherit.checkIfInherits)(element)) {
-    const inheritedState = (0, import_inherit.createInheritedState)(element, parent);
+  if ((0, import_utils.checkIfInherits)(element)) {
+    const inheritedState = (0, import_utils.createInheritedState)(element, parent);
     element.state = (0, import_utils.isUndefined)(inheritedState) ? {} : inheritedState;
   }
-  const dependentState = applyDependentState(element, element.state || parent.state || {});
+  const dependentState = await (0, import_utils.applyDependentState)(
+    element,
+    element.state || parent.state || {}
+  );
   if (dependentState) element.state = dependentState;
-  applyMethods(element);
-  (0, import_event.triggerEventOn)("stateCreated", element);
+  (0, import_methods.applyStateMethods)(element);
+  await (0, import_event.triggerEventOn)("stateCreated", element);
   return element.state;
 };
-const applyDependentState = (element, state) => {
-  const { __ref, ref, __element } = state;
-  const origState = (0, import_utils.exec)(__ref || ref || (__element == null ? void 0 : __element.state), element);
-  if (!origState) return;
-  const dependentState = (0, import_utils.deepClone)(origState, import_ignore.IGNORE_STATE_PARAMS);
-  const newDepends = { [element.key]: dependentState };
-  const __depends = (0, import_utils.isObject)(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
-  if (Array.isArray(origState)) {
-    addProtoToArray(origState, { ...Object.getPrototypeOf(origState), __depends });
-  } else {
-    Object.setPrototypeOf(origState, { ...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 ((0, import_utils.isFunction)(state)) {
-    ref.__state = state;
-    return await (0, import_utils.exec)(state, element);
-  } else if ((0, import_utils.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: import_methods.clean.bind(state),
-    parse: import_methods.parse.bind(state),
-    destroy: import_methods.destroy.bind(state),
-    update: import_updateState.updateState.bind(state),
-    rootUpdate: import_methods.rootUpdate.bind(state),
-    parentUpdate: import_methods.parentUpdate.bind(state),
-    create: createState.bind(state),
-    add: import_methods.add.bind(state),
-    toggle: import_methods.toggle.bind(state),
-    remove: import_methods.remove.bind(state),
-    apply: import_methods.apply.bind(state),
-    applyReplace: import_methods.applyReplace.bind(state),
-    applyFunction: import_methods.applyFunction.bind(state),
-    set: import_methods.set.bind(state),
-    quietUpdate: import_methods.quietUpdate.bind(state),
-    replace: import_methods.replace.bind(state),
-    quietReplace: import_methods.quietReplace.bind(state),
-    reset: import_methods.reset.bind(state),
-    parent: element.parent.state || state,
-    setByPath: import_methods.setByPath.bind(state),
-    setPathCollection: import_methods.setPathCollection.bind(state),
-    removeByPath: import_methods.removeByPath.bind(state),
-    removePathCollection: import_methods.removePathCollection.bind(state),
-    getByPath: import_methods.getByPath.bind(state),
-    keys: import_methods.keys.bind(state),
-    values: import_methods.values.bind(state),
-    __element: element,
-    __children: {},
-    root: ref.root ? ref.root.state : state
-  };
-  if ((0, import_utils.isArray)(state)) {
-    addProtoToArray(state, proto);
-  } else {
-    Object.setPrototypeOf(state, proto);
-  }
-  if (state.parent && state.parent.__children) {
-    state.parent.__children[element.key] = state;
-  }
-};

package/dist/cjs/index.js

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

package/dist/cjs/methods.js

@@ -22,6 +22,7 @@ __export(methods_exports, {
   apply: () => apply,
   applyFunction: () => applyFunction,
   applyReplace: () => applyReplace,
+  applyStateMethods: () => applyStateMethods,
   clean: () => clean,
   destroy: () => destroy,
   getByPath: () => getByPath,
@@ -44,34 +45,35 @@ __export(methods_exports, {
 });
 module.exports = __toCommonJS(methods_exports);
 var import_utils = require("@domql/utils");
-var import_ignore = require("./ignore.js");
+var import_updateState = require("./updateState.js");
+var import_create = require("./create.js");
 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)) {
+      if (!import_utils.STATE_METHODS.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));
+    return state.filter((item) => !import_utils.STATE_METHODS.includes(item));
   }
 };
-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)) {
+    if (!import_utils.STATE_METHODS.includes(param) && Object.hasOwnProperty.call(state, param)) {
       delete state[param];
     }
   }
   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;
@@ -104,124 +106,133 @@ 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.update(state.parse(), { overwrite: true, ...options });
   } else if ((0, import_utils.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 ((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();
+  if (options.applyReset) {
+    return await state.set(state.parse(), { replace: true, ...options });
+  }
+  return await state.update({}, options);
 };
-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 });
+  const cleanState = await state.clean({ preventStateUpdate: true, ...options });
+  return await cleanState.update(value, { replace: true, ...options });
 };
-const setByPath = function(path, val, options = {}) {
+const setByPath = async function(path, val, options = {}) {
   const state = this;
   const value = (0, import_utils.deepClone)(val);
   (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 = 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 (0, import_utils.overwriteDeep)(acc, result);
     } else if (change[0] === "delete") {
-      removeByPath.call(state, change[1], options);
+      await removeByPath.call(state, change[1], {
+        ...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;
   (0, import_utils.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 (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 });
+    await func(state);
+    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;
@@ -231,3 +242,47 @@ 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: import_updateState.updateState.bind(state),
+    rootUpdate: rootUpdate.bind(state),
+    parentUpdate: parentUpdate.bind(state),
+    create: import_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 ((0, import_utils.isArray)(state)) {
+    (0, import_utils.addProtoToArray)(state, proto);
+  } else {
+    Object.setPrototypeOf(state, proto);
+  }
+  if (state.parent && state.parent.__children) {
+    state.parent.__children[element.key] = state;
+  }
+};