@domql/state 2.4.0 → 2.4.1

package/{createState.js → create.js}

@@ -8,8 +8,10 @@ import { updateState } from './updateState'
 import { checkIfInherits, createInheritedState } from './inherit'
 
 export const createState = function (element, parent, options) {
-  const skipApplyMethods = Boolean(options && options.skipApplyMethods)
+  element.state = applyInitialState(element, parent, options)
+}
 
+export const applyInitialState = function (element, parent, options) {
   const objectizeState = checkForTypes(element)
   if (objectizeState === false) return parent.state || {}
   else element.state = deepClone(objectizeState, IGNORE_STATE_PARAMS)
@@ -25,12 +27,6 @@ export const createState = function (element, parent, options) {
   const dependentState = applyDependentState(element, element.state)
   if (dependentState) element.state = dependentState
 
-  // NOTE: Only true when 'onlyResolveExtends' option is set to true
-  if (skipApplyMethods) {
-    if (element.parent && element.parent.state) { element.state.parent = element.parent.state } else { element.state.parent = {} }
-    return element.state
-  }
-
   applyMethods(element)
 
   // trigger `on.stateCreated`
@@ -112,5 +108,6 @@ const applyMethods = (element) => {
     Object.setPrototypeOf(state, proto)
   }
 
-  if (state.parent) state.parent.__children[element.key] = state
+  if (state.parent && state.parent.__children)
+    state.parent.__children[element.key] = state
 }

package/dist/cjs/create.js

@@ -0,0 +1,124 @@
+"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 create_exports = {};
+__export(create_exports, {
+  applyInitialState: () => applyInitialState,
+  createState: () => createState
+});
+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");
+const createState = function(element, parent, options) {
+  element.state = applyInitialState(element, parent, options);
+};
+const applyInitialState = function(element, parent, options) {
+  const objectizeState = checkForTypes(element);
+  if (objectizeState === false)
+    return parent.state || {};
+  else
+    element.state = (0, import_utils.deepClone)(objectizeState, import_ignore.IGNORE_STATE_PARAMS);
+  const whatInitReturns = (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);
+    element.state = inheritedState || {};
+  }
+  const dependentState = applyDependentState(element, element.state);
+  if (dependentState)
+    element.state = dependentState;
+  applyMethods(element);
+  (0, import_event.triggerEventOn)("stateCreated", element);
+  return element.state;
+};
+const applyDependentState = (element, state) => {
+  const { __ref: ref } = state;
+  if (!ref)
+    return;
+  const dependentState = (0, import_utils.deepClone)(ref, import_ignore.IGNORE_STATE_PARAMS);
+  const newDepends = { [element.key]: dependentState };
+  ref.__depends = (0, import_utils.isObject)(ref.__depends) ? { ...ref.__depends, ...newDepends } : newDepends;
+  return dependentState;
+};
+const checkForTypes = (element) => {
+  const { state, __ref: ref } = element;
+  if ((0, import_utils.isFunction)(state)) {
+    ref.__state = state;
+    return (0, import_utils.exec)(state, element);
+  }
+  if ((0, import_utils.is)(state)("string", "number")) {
+    ref.__state = state;
+    return {};
+  }
+  if (state === true) {
+    ref.__state = element.key;
+    return {};
+  }
+  if (state) {
+    ref.__hasRootState = true;
+    return state;
+  }
+  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),
+    set: import_methods.set.bind(state),
+    parent: element.parent.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

@@ -16,7 +16,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 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("./create"), module.exports);
 __reExport(state_exports, require("./updateState"), module.exports);
 __reExport(state_exports, require("./methods"), module.exports);
 __reExport(state_exports, require("./inherit"), module.exports);

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "license": "MIT",
   "type": "module",
   "module": "dist/esm/index.js",
@@ -31,5 +31,5 @@
     "@domql/report": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "d01a7237a0065a5a439a03062064076c5fdc91b7"
+  "gitHead": "86251c1d94b9e87288cc9e84fd9badb6461b2973"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 symbo.ls
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.