@zeix/cause-effect 0.15.2 → 0.16.1

package/src/state.ts

@@ -1,15 +1,15 @@
 import { isEqual } from './diff'
-import { NullishSignalValueError } from './errors'
-import { notify, subscribe, type Watcher } from './scheduler'
-import { isObjectOfType, UNSET } from './util'
+import { InvalidCallbackError, NullishSignalValueError } from './errors'
+import { notify, subscribe, type Watcher } from './system'
+import { isFunction, isObjectOfType, UNSET, valueString } from './util'
 
 /* === Types === */
 
 type State<T extends {}> = {
-	[Symbol.toStringTag]: 'State'
+	readonly [Symbol.toStringTag]: 'State'
 	get(): T
-	set(v: T): void
-	update(fn: (v: T) => T): void
+	set(newValue: T): void
+	update(updater: (oldValue: T) => T): void
 }
 
 /* === Constants === */
@@ -25,54 +25,50 @@ const TYPE_STATE = 'State'
  * @param {T} initialValue - initial value of the state
  * @returns {State<T>} - new state signal
  */
-const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
+const createState = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
+	if (initialValue == null) throw new NullishSignalValueError('state')
+
 	const watchers: Set<Watcher> = new Set()
 	let value: T = initialValue
 
-	const s: State<T> = {
-		[Symbol.toStringTag]: TYPE_STATE,
-
-		/**
-		 * Get the current value of the state
-		 *
-		 * @since 0.9.0
-		 * @returns {T} - current value of the state
-		 */
-		get: (): T => {
-			subscribe(watchers)
-			return value
-		},
+	const setValue = (newValue: T) => {
+		if (newValue == null) throw new NullishSignalValueError('state')
+		if (isEqual(value, newValue)) return
+		value = newValue
+		notify(watchers)
 
-		/**
-		 * Set a new value of the state
-		 *
-		 * @since 0.9.0
-		 * @param {T} v
-		 * @returns {void}
-		 */
-		set: (v: T): void => {
-			if (v == null) throw new NullishSignalValueError('state')
-			if (isEqual(value, v)) return
-			value = v
-			notify(watchers)
+		// Setting to UNSET clears the watchers so the signal can be garbage collected
+		if (UNSET === value) watchers.clear()
+	}
 
-			// Setting to UNSET clears the watchers so the signal can be garbage collected
-			if (UNSET === value) watchers.clear()
+	const state: Record<PropertyKey, unknown> = {}
+	Object.defineProperties(state, {
+		[Symbol.toStringTag]: {
+			value: TYPE_STATE,
 		},
-
-		/**
-		 * Update the state with a new value using a function
-		 *
-		 * @since 0.10.0
-		 * @param {(v: T) => T} fn - function to update the state
-		 * @returns {void} - updates the state with the result of the function
-		 */
-		update: (fn: (v: T) => T): void => {
-			s.set(fn(value))
+		get: {
+			value: () => {
+				subscribe(watchers)
+				return value
+			},
 		},
-	}
-
-	return s
+		set: {
+			value: (newValue: T) => {
+				setValue(newValue)
+			},
+		},
+		update: {
+			value: (updater: (oldValue: T) => T) => {
+				if (!isFunction(updater))
+					throw new InvalidCallbackError(
+						'state update',
+						valueString(updater),
+					)
+				setValue(updater(value))
+			},
+		},
+	})
+	return state as State<T>
 }
 
 /**
@@ -88,4 +84,4 @@ const isState = /*#__PURE__*/ <T extends {}>(
 
 /* === Exports === */
 
-export { TYPE_STATE, isState, state, type State }
+export { TYPE_STATE, isState, createState, type State }