@bitstillery/mithril 3.9.2 → 3.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bitstillery/mithril",
-    "version": "3.9.2",
+    "version": "3.9.3",
     "description": "Mithril + Signals, Store and SSR",
     "license": "MIT",
     "author": "Bitstillery",

package/signal.ts

@@ -188,7 +188,7 @@ export class ComputedSignal<T> extends Signal<T> {
         this._compute = compute
     }
 
-    get value(): T {
+    override get value(): T {
         // Track access by other computed signals - this enables computed-to-computed dependency chains
         // When computed B accesses computed A, A should notify B when A's dependencies change
         if (currentEffect) {
@@ -259,7 +259,7 @@ export class ComputedSignal<T> extends Signal<T> {
         this._markDirty()
     }
 
-    set value(_newValue: T) {
+    override set value(_newValue: T) {
         throw new Error('Computed signals are read-only')
     }
 }

package/state.ts

@@ -60,12 +60,37 @@ function isState(value: any): boolean {
     return value && typeof value === 'object' && (value as any).__isState === true
 }
 
+/**
+ * Built-ins whose methods need their internal slots. A proxy has none, and the get trap calls a
+ * function-valued property with the proxy as `this`, so a proxied Date or Map throws on every method
+ * call (and a Map's `get`/`set` read as a get/set descriptor). They are held as a signal's value
+ * instead, and replaced wholesale to notify.
+ */
+function isOpaqueObject(value: object): boolean {
+    return (
+        value instanceof Date ||
+        value instanceof Map ||
+        value instanceof Set ||
+        value instanceof WeakMap ||
+        value instanceof WeakSet ||
+        value instanceof RegExp ||
+        value instanceof Promise ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value)
+    )
+}
+
 /**
  * Check if a value is a get/set descriptor object (like JavaScript property descriptors)
  * Used to detect computed properties defined as { get: () => T, set?: (value: T) => void }
  */
 function isGetSetDescriptor(value: any): boolean {
-    return value && typeof value === 'object' && (typeof value.get === 'function' || typeof value.set === 'function')
+    return (
+        value &&
+        typeof value === 'object' &&
+        !isOpaqueObject(value) &&
+        (typeof value.get === 'function' || typeof value.set === 'function')
+    )
 }
 
 /**
@@ -203,7 +228,7 @@ export function state<T extends Record<string, any>>(initial: T, name?: string,
         parentSignalMap?: Map<string, Signal<any> | ComputedSignal<any>>,
         context?: InitContext,
     ): any {
-        if (obj === null || typeof obj !== 'object') {
+        if (obj === null || typeof obj !== 'object' || isOpaqueObject(obj)) {
             return obj
         }
 
@@ -863,6 +888,48 @@ export function state<T extends Record<string, any>>(initial: T, name?: string,
     return wrapped
 }
 
+/** The built-ins `isOpaqueObject` keeps out of the proxy: state holds them as they are. */
+type OpaqueObject =
+    | Date
+    | Map<any, any>
+    | Set<any>
+    | WeakMap<any, any>
+    | WeakSet<any>
+    | RegExp
+    | Promise<any>
+    | ArrayBuffer
+    | ArrayBufferView
+
+/**
+ * A value as state hands it out: a function reads as its computed result, an object (or array) as its
+ * own State. Distributes over a union, so a nullable object (`Foo | null`) is still a State with its
+ * `$` signals once it is set.
+ */
+type StateValue<V> = V extends (...args: any[]) => infer R
+    ? R
+    : V extends OpaqueObject
+      ? V
+      : V extends Record<string, any>
+        ? State<V>
+        : V
+
+/**
+ * A property as state hands it out. Unlike an array element it doesn't distribute over a union, so a
+ * nullable object (`Foo | null`) stays its plain shape and a plain `Foo` can be written to it, as in 3.9.
+ * A `{get, set}` descriptor reads as its computed value.
+ */
+type StateProp<V> = [V] extends [never]
+    ? V
+    : [V] extends [(...args: any[]) => infer R]
+      ? R
+      : [V] extends [{get: () => infer R; set: (value: never) => void}]
+        ? R
+        : [V] extends [OpaqueObject]
+          ? V
+          : [V] extends [Record<string, any>]
+            ? State<V>
+            : V
+
 /**
  * Mapped type that adds $prop for each key, returning the Signal for that property.
  * - Primitives: $prop => Signal<T[K]>
@@ -874,24 +941,19 @@ export type StateSignals<T extends Record<string, any>> = {
     // lookup by a `string` key would read as `Value | Signal<Value>`.
     [K in keyof T as K extends string ? (string extends K ? never : `$${K}`) : never]: T[K] extends (...args: any[]) => infer R
         ? ComputedSignal<R>
-        : T[K] extends object
-          ? Signal<State<T[K]>>
-          : Signal<T[K]>
+        : Signal<StateProp<T[K]>>
 }
-type StateElem<E> = E extends Record<string, any> ? State<E> : E
 
-export type StateArray<Elem> = Omit<Array<StateElem<Elem>>, 'fill' | 'push' | 'splice' | 'unshift'> & {
+export type StateArray<Elem> = Omit<Array<StateValue<Elem>>, 'fill' | 'push' | 'splice' | 'unshift'> & {
     fill(value: Elem, start?: number, end?: number): StateArray<Elem>
     push(...items: Elem[]): number
-    splice(start: number, deleteCount?: number, ...items: Elem[]): StateElem<Elem>[]
+    splice(start: number, deleteCount?: number, ...items: Elem[]): StateValue<Elem>[]
     unshift(...items: Elem[]): number
 }
 
 export type State<T extends Record<string, any>> = T extends (infer Elem)[]
     ? StateArray<Elem>
-    : {
-          [K in keyof T]: T[K] extends (...args: any[]) => infer R ? R : T[K] extends Record<string, any> ? State<T[K]> : T[K]
-      } & StateSignals<T>
+    : {[K in keyof T]: StateProp<T[K]>} & StateSignals<T>
 
 /**
  * A partial of a state shape at every depth, for the persistence tiers of a Store: each tier fills in

package/store.ts

@@ -1,4 +1,5 @@
-import {allowComputed, state, State, updateStateRegistry, type DeepPartial} from './state'
+import {allowComputed, state, updateStateRegistry} from './state'
+import type {State, DeepPartial} from './state'
 import {serializeStore, deserializeStore} from './render/ssrState'
 
 // Helper function to restore computed properties (same as in ssrState.ts)