@domql/state 2.3.152 → 2.4.1

package/{createState.js → create.js}

@@ -1,15 +1,17 @@
 'use strict'
 
 import { triggerEventOn } from '@domql/event'
-import { deepClone, exec, is, isFunction, isObject } from '@domql/utils'
+import { deepClone, exec, is, isArray, isFunction, isObject } from '@domql/utils'
 import { IGNORE_STATE_PARAMS } from './ignore'
 import { add, apply, clean, destroy, parentUpdate, parse, remove, rootUpdate, set, toggle } from './methods'
 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`
@@ -72,6 +68,17 @@ const checkForTypes = (element) => {
   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
@@ -95,7 +102,12 @@ const applyMethods = (element) => {
     __root: ref.__root ? ref.__root.state : state
   }
 
-  Object.setPrototypeOf(state, proto)
+  if (isArray(state)) {
+    addProtoToArray(state, proto)
+  } else {
+    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/createState.js

@@ -85,6 +85,19 @@ const checkForTypes = (element) => {
   }
   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;
@@ -106,7 +119,11 @@ const applyMethods = (element) => {
     __children: {},
     __root: ref.__root ? ref.__root.state : state
   };
-  Object.setPrototypeOf(state, proto);
+  if ((0, import_utils.isArray)(state)) {
+    addProtoToArray(state, proto);
+  } else {
+    Object.setPrototypeOf(state, proto);
+  }
   if (state.parent)
     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/dist/cjs/inherit.js

@@ -99,8 +99,7 @@ const checkIfInherits = (element) => {
 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"]);
+  return state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.toggle && state.add && state.apply && state.__element && state.__children;
 };
 const createChangesByKey = (path, value) => {
   if (!path) {

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/inherit.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { arrayContainsOtherArray, deepClone, is, isNot, isObjectLike } from '@domql/utils'
+import { deepClone, is, isNot, isObjectLike } from '@domql/utils'
 import { IGNORE_STATE_PARAMS } from './ignore'
 
 export const getParentStateInKey = (stateKey, parentState) => {
@@ -74,8 +74,20 @@ export const checkIfInherits = (element) => {
 
 export const isState = function (state) {
   if (!isObjectLike(state)) return false
-  const keys = Object.keys(state)
-  return arrayContainsOtherArray(keys, ['update', 'parse', 'clean', 'create', 'parent', 'rootUpdate'])
+  return state.update &&
+    state.parse &&
+    state.clean &&
+    state.create &&
+    state.parent &&
+    state.destroy &&
+    state.rootUpdate &&
+    state.parentUpdate &&
+    state.toggle &&
+    state.add &&
+    state.apply &&
+    state.__element &&
+    state.__children
+  // return arrayContainsOtherArray(keys, ['update', 'parse', 'clean', 'create', 'parent', 'rootUpdate'])
 }
 
 export const createChangesByKey = (path, value) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/state",
-  "version": "2.3.152",
+  "version": "2.4.1",
   "license": "MIT",
   "type": "module",
   "module": "dist/esm/index.js",
@@ -19,7 +19,7 @@
     "dist"
   ],
   "scripts": {
-    "copy:package:cjs": "cp ../../.build/package-cjs.json dist/cjs/package.json",
+    "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",
@@ -31,5 +31,5 @@
     "@domql/report": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "9424c9efe8b2b9e4b39bf7dfac3caf1f964ddb9a"
+  "gitHead": "86251c1d94b9e87288cc9e84fd9badb6461b2973"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016 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.