@zeix/cause-effect 0.15.1 → 0.16.0

package/src/signal.ts

@@ -1,12 +1,12 @@
 import {
 	type Computed,
 	type ComputedCallback,
-	computed,
+	createComputed,
 	isComputed,
 	isComputedCallback,
 } from './computed'
-import { isState, type State, state } from './state'
-import { isStore, type Store, store } from './store'
+import { createState, isState, type State } from './state'
+import { createStore, isStore, type Store } from './store'
 import { isRecord } from './util'
 
 /* === Types === */
@@ -14,7 +14,6 @@ import { isRecord } from './util'
 type Signal<T extends {}> = {
 	get(): T
 }
-type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>
 
 type UnknownSignalRecord = Record<string, Signal<unknown & {}>>
 
@@ -22,15 +21,10 @@ type SignalValues<S extends UnknownSignalRecord> = {
 	[K in keyof S]: S[K] extends Signal<infer T> ? T : never
 }
 
-/* === Constants === */
-
-// biome-ignore lint/suspicious/noExplicitAny: Deliberately using any to be used as a placeholder value in any signal
-const UNSET: any = Symbol()
-
 /* === Functions === */
 
 /**
- * Check whether a value is a Signal or not
+ * Check whether a value is a Signal
  *
  * @since 0.9.0
  * @param {unknown} value - value to check
@@ -40,6 +34,17 @@ const isSignal = /*#__PURE__*/ <T extends {}>(
 	value: unknown,
 ): value is Signal<T> => isState(value) || isComputed(value) || isStore(value)
 
+/**
+ * Check whether a value is a State or Store
+ *
+ * @since 0.15.2
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a State or Store, false otherwise
+ */
+const isMutableSignal = /*#__PURE__*/ <T extends {}>(
+	value: unknown,
+): value is State<T> | Store<T> => isState(value) || isStore(value)
+
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
@@ -47,10 +52,6 @@ const isSignal = /*#__PURE__*/ <T extends {}>(
  * @param {T} value - value to convert
  * @returns {Signal<T>} - Signal instance
  */
-function toSignal<T extends {}>(value: T[]): Store<Record<string, T>>
-function toSignal<T extends {}>(
-	value: (() => T) | ((abort: AbortSignal) => Promise<T>),
-): Computed<T>
 function toSignal<T extends {}>(
 	value: T,
 ): T extends Store<infer U>
@@ -61,50 +62,27 @@ function toSignal<T extends {}>(
 			? Computed<U>
 			: T extends Signal<infer U>
 				? Signal<U>
-				: T extends Record<string, unknown & {}>
-					? Store<{ [K in keyof T]: T[K] }>
-					: State<T>
-function toSignal<T extends {}>(value: MaybeSignal<T>): Signal<T> {
+				: T extends ReadonlyArray<infer U extends {}>
+					? Store<U[]>
+					: T extends Record<string, unknown & {}>
+						? Store<{ [K in keyof T]: T[K] }>
+						: T extends ComputedCallback<infer U extends {}>
+							? Computed<U>
+							: State<T>
+function toSignal<T extends {}>(value: T) {
 	if (isSignal<T>(value)) return value
-	if (isComputedCallback(value)) return computed(value)
-	if (Array.isArray(value)) return store(value as T)
-	if (Array.isArray(value) || isRecord(value)) return store(value)
-	return state(value)
-}
-
-/**
- * Convert a value to a mutable Signal if it's not already a Signal
- *
- * @since 0.15.0
- * @param {T} value - value to convert
- * @returns {State<T> | Store<T>} - Signal instance
- */
-function toMutableSignal<T extends {}>(value: T[]): Store<Record<string, T>>
-function toMutableSignal<T extends {}>(
-	value: T,
-): T extends Store<infer U>
-	? Store<U>
-	: T extends State<infer U>
-		? State<U>
-		: T extends Record<string, unknown & {}>
-			? Store<{ [K in keyof T]: T[K] }>
-			: State<T>
-function toMutableSignal<T extends {}>(value: T): State<T> | Store<T> {
-	if (isState<T>(value) || isStore<T>(value)) return value
-	if (Array.isArray(value)) return store(value as T)
-	if (isRecord(value)) return store(value)
-	return state(value)
+	if (isComputedCallback(value)) return createComputed(value)
+	if (Array.isArray(value) || isRecord(value)) return createStore(value)
+	return createState(value)
 }
 
 /* === Exports === */
 
 export {
 	type Signal,
-	type MaybeSignal,
 	type UnknownSignalRecord,
 	type SignalValues,
-	UNSET,
 	isSignal,
+	isMutableSignal,
 	toSignal,
-	toMutableSignal,
 }

package/src/state.ts

@@ -1,15 +1,15 @@
 import { isEqual } from './diff'
-import { notify, subscribe, type Watcher } from './scheduler'
-import { UNSET } from './signal'
-import { isObjectOfType } 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,18 +25,20 @@ 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> = {
+	const state: State<T> = {
 		[Symbol.toStringTag]: TYPE_STATE,
 
 		/**
 		 * Get the current value of the state
 		 *
 		 * @since 0.9.0
-		 * @returns {T} - current value of the state
+		 * @returns {T} - Current value of the state
 		 */
 		get: (): T => {
 			subscribe(watchers)
@@ -47,12 +49,13 @@ const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
 		 * Set a new value of the state
 		 *
 		 * @since 0.9.0
-		 * @param {T} v
+		 * @param {T} newValue - New value of the state
 		 * @returns {void}
 		 */
-		set: (v: T): void => {
-			if (isEqual(value, v)) return
-			value = v
+		set: (newValue: T): void => {
+			if (newValue == null) throw new NullishSignalValueError('state')
+			if (isEqual(value, newValue)) return
+			value = newValue
 			notify(watchers)
 
 			// Setting to UNSET clears the watchers so the signal can be garbage collected
@@ -63,15 +66,20 @@ const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
 		 * 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
+		 * @param {(v: T) => T} updater - Function to update the state
+		 * @returns {void}
 		 */
-		update: (fn: (v: T) => T): void => {
-			s.set(fn(value))
+		update: (updater: (oldValue: T) => T): void => {
+			if (!isFunction(updater))
+				throw new InvalidCallbackError(
+					'state update',
+					valueString(updater),
+				)
+			state.set(updater(value))
 		},
 	}
 
-	return s
+	return state
 }
 
 /**
@@ -87,4 +95,4 @@ const isState = /*#__PURE__*/ <T extends {}>(
 
 /* === Exports === */
 
-export { TYPE_STATE, isState, state, type State }
+export { TYPE_STATE, isState, createState, type State }