@domql/state 3.1.2 → 3.2.7

package/methods.js

@@ -25,33 +25,33 @@ export const parse = function () {
   if (isObject(state)) {
     const obj = {}
     for (const param in state) {
-      if (!STATE_METHODS.includes(param)) {
+      if (!STATE_METHODS.has(param)) {
         obj[param] = state[param]
       }
     }
     return obj
   } else if (isArray(state)) {
-    return state.filter(item => !STATE_METHODS.includes(item))
+    return state.filter(item => !STATE_METHODS.has(item))
   }
 }
 
-export const clean = async function (options = {}) {
+export const clean = function (options = {}) {
   const state = this
   for (const param in state) {
     if (
-      !STATE_METHODS.includes(param) &&
-      Object.hasOwnProperty.call(state, param)
+      !STATE_METHODS.has(param) &&
+      Object.prototype.hasOwnProperty.call(state, param)
     ) {
       delete state[param]
     }
   }
   if (!options.preventStateUpdate) {
-    await state.update(state, { replace: true, ...options })
+    state.update(state, { replace: true, ...options })
   }
   return state
 }
 
-export const destroy = async function (options = {}) {
+export const destroy = function (options = {}) {
   const state = this
   const element = state.__element
 
@@ -86,99 +86,98 @@ export const destroy = async function (options = {}) {
     }
   }
 
-  await element.state.update({}, { isHoisted: true, ...options })
+  element.state.update({}, { isHoisted: true, ...options })
   return element.state
 }
 
-export const parentUpdate = async function (obj, options = {}) {
+export const parentUpdate = function (obj, options = {}) {
   const state = this
   if (!state || !state.parent) return
-  return await state.parent.update(obj, { isHoisted: true, ...options })
+  return state.parent.update(obj, { isHoisted: true, ...options })
 }
 
-export const rootUpdate = async function (obj, options = {}) {
+export const rootUpdate = function (obj, options = {}) {
   const state = this
   if (!state) return
   const rootState = state.__element.__ref.root.state
-  return await rootState.update(obj, { isHoisted: false, ...options })
+  return rootState.update(obj, { isHoisted: false, ...options })
 }
 
-export const add = async function (value, options = {}) {
+export const add = function (value, options = {}) {
   const state = this
   if (isArray(state)) {
     state.push(value)
-    await state.update(state.parse(), { overwrite: true, ...options })
+    state.update(state.parse(), { overwrite: true, ...options })
   } else if (isObject(state)) {
     const key = Object.keys(state).length
-    await state.update({ [key]: value }, options)
+    state.update({ [key]: value }, options)
   }
 }
 
-export const toggle = async function (key, options = {}) {
+export const toggle = function (key, options = {}) {
   const state = this
-  await state.update({ [key]: !state[key] }, options)
+  state.update({ [key]: !state[key] }, options)
 }
 
-export const remove = async function (key, options = {}) {
+export const remove = function (key, options = {}) {
   const state = this
   if (isArray(state)) removeFromArray(state, key)
-  if (isObject(state)) removeFromObject(state, key)
+  else if (isObject(state)) removeFromObject(state, key)
   if (options.applyReset) {
-    return await state.set(state.parse(), { replace: true, ...options })
+    return state.set(state.parse(), { replace: true, ...options })
   }
-  return await state.update({}, options)
+  return state.update({}, options)
 }
 
-export const set = async function (val, options = {}) {
+export const set = function (val, options = {}) {
   const state = this
   const value = deepClone(val)
-  const cleanState = await state.clean({ preventStateUpdate: true, ...options })
-  return await cleanState.update(value, { replace: true, ...options })
+  const cleanState = state.clean({ preventStateUpdate: true, ...options })
+  return cleanState.update(value, { replace: true, ...options })
 }
 
-export const setByPath = async function (path, val, options = {}) {
+export const setByPath = function (path, val, options = {}) {
   const state = this
   const value = deepClone(val)
-  setInObjectByPath(state, path, val)
+  if (!options.preventReplace) setInObjectByPath(state, path, val)
   const update = createNestedObject(path, value)
   if (options.preventStateUpdate) return update
-  return await state.update(update, options)
+  return state.update(update, options)
 }
 
-export const setPathCollection = async function (changes, options = {}) {
+export const setPathCollection = function (changes, options = {}) {
   const state = this
-  const update = await changes.reduce(async (promise, change) => {
-    const acc = await promise
+  const update = changes.reduce((acc, change) => {
     if (change[0] === 'update') {
       const result = setByPath.call(state, change[1], change[2], {
         preventStateUpdate: true
       })
       return overwriteDeep(acc, result)
     } else if (change[0] === 'delete') {
-      await removeByPath.call(state, change[1], {
+      removeByPath.call(state, change[1], {
         ...options,
         preventUpdate: true
       })
     }
     return acc
-  }, Promise.resolve({}))
+  }, {})
 
   return state.update(update, options)
 }
 
-export const removeByPath = async function (path, options = {}) {
+export const removeByPath = function (path, options = {}) {
   const state = this
   removeNestedKeyByPath(state, path)
   if (options.preventUpdate) return path
-  return await state.update({}, options)
+  return state.update({}, options)
 }
 
-export const removePathCollection = async function (changes, options = {}) {
+export const removePathCollection = function (changes, options = {}) {
   const state = this
-  changes.forEach(async item => {
-    await removeByPath(item, { preventUpdate: true })
-  })
-  return await state.update({}, options)
+  for (let i = 0; i < changes.length; i++) {
+    removeByPath(changes[i], { preventUpdate: true })
+  }
+  return state.update({}, options)
 }
 
 export const getByPath = function (path, options = {}) {
@@ -186,54 +185,54 @@ export const getByPath = function (path, options = {}) {
   return getInObjectByPath(state, path)
 }
 
-export const reset = async function (options = {}) {
+export const reset = function (options = {}) {
   const state = this
   const value = deepClone(state.parse())
-  return await state.set(value, { replace: true, ...options })
+  return state.set(value, { replace: true, ...options })
 }
 
-export const apply = async function (func, options = {}) {
+export const apply = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return await state.update(value, { replace: true, ...options })
+    return state.update(value, { replace: true, ...options })
   }
 }
 
-export const applyReplace = async function (func, options = {}) {
+export const applyReplace = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
     const value = func(state)
-    return await state.replace(value, options)
+    return state.replace(value, options)
   }
 }
 
-export const applyFunction = async function (func, options = {}) {
+export const applyFunction = function (func, options = {}) {
   const state = this
   if (isFunction(func)) {
-    await func(state)
-    return await state.update(state.parse(), { replace: true, ...options })
+    func(state)
+    return state.update(state.parse(), { replace: true, ...options })
   }
 }
 
-export const quietUpdate = async function (obj, options = {}) {
+export const quietUpdate = function (obj, options = {}) {
   const state = this
-  return await state.update(obj, { preventUpdate: true, ...options })
+  return state.update(obj, { preventUpdate: true, ...options })
 }
 
-export const replace = async function (obj, options = {}) {
+export const replace = function (obj, options = {}) {
   const state = this
 
   for (const param in obj) {
     state[param] = obj[param]
   }
 
-  return await state.update(obj, options)
+  return state.update(obj, options)
 }
 
-export const quietReplace = async function (obj, options = {}) {
+export const quietReplace = function (obj, options = {}) {
   const state = this
-  return await state.replace(obj, { preventUpdate: true, ...options })
+  return state.replace(obj, { preventUpdate: true, ...options })
 }
 
 export const keys = function (obj, options = {}) {

package/package.json

@@ -1,36 +1,48 @@
 {
   "name": "@domql/state",
-  "version": "3.1.2",
+  "version": "3.2.7",
   "license": "MIT",
   "type": "module",
-  "module": "index.js",
-  "main": "index.js",
-  "unpkg": "dist/iife/index.js",
-  "jsdelivr": "dist/iife/index.js",
+  "module": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.js",
+  "unpkg": "./dist/iife/index.js",
+  "jsdelivr": "./dist/iife/index.js",
   "exports": {
     ".": {
-      "default": "./dist/esm/index.js",
       "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.js",
+      "browser": "./dist/iife/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./*.js": {
+      "import": "./dist/esm/*.js",
+      "require": "./dist/cjs/*.js",
+      "default": "./dist/esm/*.js"
+    },
+    "./*": {
+      "import": "./dist/esm/*.js",
+      "require": "./dist/cjs/*.js",
+      "default": "./dist/esm/*.js"
     }
   },
   "source": "index.js",
   "files": [
-    "*.js",
-    "dist"
+    "dist",
+    "*.js"
   ],
   "scripts": {
     "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
-    "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": "npx rimraf -I dist; npm run build:cjs; npm run build:esm",
-    "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
+    "build:esm": "cross-env NODE_ENV=$NODE_ENV esbuild *.js --target=es2020 --format=esm --outdir=dist/esm --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:cjs": "cross-env NODE_ENV=$NODE_ENV esbuild *.js --target=node18 --format=cjs --outdir=dist/cjs --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:iife": "cross-env NODE_ENV=$NODE_ENV esbuild index.js --bundle --target=es2020 --format=iife --global-name=DomqlState --outfile=dist/iife/index.js --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build": "node ../../build/build.js",
+    "prepublish": "npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^3.1.2",
-    "@domql/report": "^3.1.2",
-    "@domql/utils": "^3.1.2"
+    "@domql/report": "^3.2.3",
+    "@domql/utils": "^3.2.3"
   },
-  "gitHead": "429b36616aa04c8587a26ce3c129815115e35897"
+  "gitHead": "9fc1b79b41cdc725ca6b24aec64920a599634681",
+  "browser": "./dist/iife/index.js",
+  "sideEffects": false
 }

package/updateState.js

@@ -1,7 +1,6 @@
 'use strict'
 
 import { report } from '@domql/report'
-import { triggerEventOnUpdate } from '@domql/event'
 import {
   checkIfInherits,
   createNestedObjectByKeyPath,
@@ -10,7 +9,8 @@ import {
   getRootStateInKey,
   merge,
   overwriteDeep,
-  overwriteState
+  overwriteState,
+  triggerEventOnUpdate
 } from '@domql/utils'
 
 const STATE_UPDATE_OPTIONS = {
@@ -21,10 +21,7 @@ const STATE_UPDATE_OPTIONS = {
   execStateFunction: true
 }
 
-export const updateState = async function (
-  obj,
-  options = STATE_UPDATE_OPTIONS
-) {
+export const updateState = function (obj, options = STATE_UPDATE_OPTIONS) {
   const state = this
   const element = state.__element
 
@@ -38,7 +35,7 @@ export const updateState = async function (
   } else if (options.preventInheritAtCurrentState) return
 
   if (!options.preventBeforeStateUpdateListener) {
-    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+    const beforeStateUpdateReturns = triggerEventOnUpdate(
       'beforeStateUpdate',
       obj,
       element,
@@ -48,21 +45,21 @@ export const updateState = async function (
   }
 
   overwriteState(state, obj, options)
-  const updateIsHoisted = await hoistStateUpdate(state, obj, options)
+  const updateIsHoisted = hoistStateUpdate(state, obj, options)
   if (updateIsHoisted) return state
 
-  await updateDependentState(state, obj, options)
+  updateDependentState(state, obj, options)
 
-  await applyElementUpdate(state, obj, options)
+  applyElementUpdate(state, obj, options)
 
   if (!options.preventStateUpdateListener) {
-    await triggerEventOnUpdate('stateUpdate', obj, element, options)
+    triggerEventOnUpdate('stateUpdate', obj, element, options)
   }
 
   return state
 }
 
-export const hoistStateUpdate = async (state, obj, options) => {
+export const hoistStateUpdate = (state, obj, options) => {
   const element = state.__element
   const { parent, __ref: ref } = element
 
@@ -88,7 +85,7 @@ export const hoistStateUpdate = async (state, obj, options) => {
   const changesValue = createNestedObjectByKeyPath(stateKey, passedValue)
   const targetParent = findRootState || findGrandParentState || parent.state
   if (options.replace) overwriteDeep(targetParent, changesValue || value) // check with createNestedObjectByKeyPath
-  await targetParent.update(changesValue, {
+  targetParent.update(changesValue, {
     execStateFunction: false,
     isHoisted: true,
     preventUpdate: options.preventHoistElementUpdate,
@@ -98,24 +95,24 @@ export const hoistStateUpdate = async (state, obj, options) => {
   const hasNotUpdated =
     options.preventUpdate !== true || !options.preventHoistElementUpdate
   if (!options.preventStateUpdateListener && hasNotUpdated) {
-    await triggerEventOnUpdate('stateUpdate', obj, element, options)
+    triggerEventOnUpdate('stateUpdate', obj, element, options)
   }
   return true
 }
 
-const updateDependentState = async (state, obj, options) => {
+const updateDependentState = (state, obj, options) => {
   if (!state.__depends) return
   for (const el in state.__depends) {
     const dependentState = state.__depends[el]
-    const cleanState = await dependentState.clean()
-    await cleanState.update(state.parse(), options)
+    const cleanState = dependentState.clean()
+    cleanState.update(state.parse(), options)
   }
 }
 
-const applyElementUpdate = async (state, obj, options) => {
+const applyElementUpdate = (state, obj, options) => {
   const element = state.__element
   if (options.preventUpdate !== true) {
-    await element.update(
+    element.update(
       {},
       {
         ...options,
@@ -123,7 +120,7 @@ const applyElementUpdate = async (state, obj, options) => {
       }
     )
   } else if (options.preventUpdate === 'recursive') {
-    await element.update(
+    element.update(
       {},
       {
         ...options,

package/dist/cjs/package.json

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