@bitstillery/mithril 3.9.1 → 3.9.3

package/api/router.ts

@@ -167,7 +167,7 @@ export default function router($window: any, mountRedraw: MountRedraw) {
     function getRedirectPath(redirectObj: RedirectObject): string {
         // First try our REDIRECT symbol
         if (REDIRECT in redirectObj) {
-            return redirectObj[REDIRECT]
+            return redirectObj[REDIRECT]!
         }
         // Otherwise, check all symbol keys
         const symbolKeys = Object.getOwnPropertySymbols(redirectObj)
@@ -215,9 +215,9 @@ export default function router($window: any, mountRedraw: MountRedraw) {
         function loop(i: number) {
             if (!compiled) return
             for (; i < compiled.length; i++) {
-                if (compiled[i].check(data)) {
-                    let payload = compiled[i].component
-                    const matchedRoute = compiled[i].route
+                if (compiled[i]!.check(data)) {
+                    let payload = compiled[i]!.component
+                    const matchedRoute = compiled[i]!.route
                     const localComp = payload
                     // Store the RouteResolver if payload has both onmatch and render
                     // This allows us to preserve the resolver even after onmatch returns a component
@@ -237,7 +237,7 @@ export default function router($window: any, mountRedraw: MountRedraw) {
                         // Handle redirect objects: explicit redirect signal
                         if (isRedirect(comp)) {
                             // Extract redirect target path
-                            const redirectPath = comp[REDIRECT]
+                            const redirectPath = getRedirectPath(comp)
                             const resolve = routeSetResolve
                             routeSetResolve = null
                             // Trigger navigation to redirect target; resolve original Promise when redirect completes

package/package.json

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

package/pathname/compileTemplate.ts

@@ -38,14 +38,15 @@ export default function compileTemplate(template: string): CompiledTemplate {
         // First, check the params. Usually, there isn't any, and it's just
         // checking a static set.
         for (let i = 0; i < templateKeys.length; i++) {
-            if (templateData.params[templateKeys[i]] !== data.params[templateKeys[i]]) return false
+            if (templateData.params[templateKeys[i]!] !== data.params[templateKeys[i]!]) return false
         }
         // If no interpolations exist, let's skip all the ceremony
         if (!keys.length) return regexp.test(data.path)
         const values = regexp.exec(data.path)
         if (values == null) return false
         for (let i = 0; i < keys.length; i++) {
-            data.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1])
+            // Every key is a non-optional capture group, so a match fills all of them.
+            data.params[keys[i]!.k] = keys[i]!.r ? values[i + 1] : decodeURIComponent(values[i + 1]!)
         }
         return true
     }

package/querystring/parse.ts

@@ -8,9 +8,9 @@ export default function parseQueryString(string: string | null | undefined): Rec
     const counters: Record<string, number> = {}
     const data: Record<string, any> = {}
     for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i].split('=')
-        const key = decodeURIComponentSafe(entry[0])
-        let value: any = entry.length === 2 ? decodeURIComponentSafe(entry[1]) : ''
+        const entry = entries[i]!.split('=')
+        const key = decodeURIComponentSafe(entry[0]!)
+        let value: any = entry.length === 2 ? decodeURIComponentSafe(entry[1]!) : ''
 
         if (value === 'true') value = true
         else if (value === 'false') value = false
@@ -19,9 +19,10 @@ export default function parseQueryString(string: string | null | undefined): Rec
         let cursor: any = data
         if (key.indexOf('[') > -1) levels.pop()
         for (let j = 0; j < levels.length; j++) {
-            const level = levels[j]
+            const level = levels[j]!
             const nextLevel = levels[j + 1]
-            const isNumber = nextLevel == '' || !isNaN(parseInt(nextLevel, 10))
+            // Past the last level nextLevel is undefined, which parseInt reads as NaN.
+            const isNumber = nextLevel == '' || !isNaN(parseInt(nextLevel as string, 10))
             let finalLevel: string | number
             if (level === '') {
                 const key = levels.slice(0, j).join()

package/render/hyperscript.ts

@@ -31,25 +31,27 @@ function isFormAttributeKey(key: string): boolean {
     return key === 'value' || key === 'checked' || key === 'selectedIndex' || key === 'selected'
 }
 
+// A match fills groups 1-2 (tag/#id/.class) or groups 3-4 ([attr]), never both; group 6
+// is absent for a bare `[attr]`, so a bare `[class]` joins in as an empty class.
 function compileSelector(selector: string): {tag: string; attrs: Record<string, any>; is?: string} {
     let match: RegExpExecArray | null
     let tag = 'div'
-    const classes: string[] = []
+    const classes: (string | undefined)[] = []
     let attrs: Record<string, any> = {}
     let isStatic = true
     while ((match = selectorParser.exec(selector)) !== null) {
         const type = match[1]
         const value = match[2]
-        if (type === '' && value !== '') tag = value
+        if (type === '' && value !== '') tag = value!
         else if (type === '#') attrs.id = value
         else if (type === '.') classes.push(value)
-        else if (match[3][0] === '[') {
+        else if (match[3]![0] === '[') {
             let attrValue = match[6]
             if (attrValue) attrValue = attrValue.replace(/\\(["'])/g, '$1').replace(/\\\\/g, '\\')
             if (match[4] === 'class') classes.push(attrValue)
             else {
-                attrs[match[4]] = attrValue === '' ? attrValue : attrValue || true
-                if (isFormAttributeKey(match[4])) isStatic = false
+                attrs[match[4]!] = attrValue === '' ? attrValue : attrValue || true
+                if (isFormAttributeKey(match[4]!)) isStatic = false
             }
         }
     }

package/render/render.ts

@@ -895,16 +895,18 @@ export default function renderFactory() {
     // of the items that are part of the longest increasing
     // subsequence
     const lisTemp: number[] = []
+    // Every index read below is in range: i < a.length, `result` is never empty and holds
+    // indices into `a`, and `lisTemp` mirrors `a`'s length.
     function makeLisIndices(a: number[]): number[] {
         const result = [0]
         let u = 0,
             v = 0
         const il = (lisTemp.length = a.length)
-        for (let i = 0; i < il; i++) lisTemp[i] = a[i]
+        for (let i = 0; i < il; i++) lisTemp[i] = a[i]!
         for (let i = 0; i < il; ++i) {
             if (a[i] === -1) continue
-            const j = result[result.length - 1]
-            if (a[j] < a[i]) {
+            const j = result[result.length - 1]!
+            if (a[j]! < a[i]!) {
                 lisTemp[i] = j
                 result.push(i)
                 continue
@@ -915,22 +917,22 @@ export default function renderFactory() {
                 // Fast integer average without overflow.
 
                 const c = (u >>> 1) + (v >>> 1) + (u & v & 1)
-                if (a[result[c]] < a[i]) {
+                if (a[result[c]!]! < a[i]!) {
                     u = c + 1
                 } else {
                     v = c
                 }
             }
-            if (a[i] < a[result[u]]) {
-                if (u > 0) lisTemp[i] = result[u - 1]
+            if (a[i]! < a[result[u]!]!) {
+                if (u > 0) lisTemp[i] = result[u - 1]!
                 result[u] = i
             }
         }
         u = result.length
-        v = result[u - 1]
+        v = result[u - 1]!
         while (u-- > 0) {
             result[u] = v
-            v = lisTemp[v]
+            v = lisTemp[v]!
         }
         lisTemp.length = 0
         return result
@@ -1453,14 +1455,14 @@ export default function renderFactory() {
                     false,
                 )
                 // Execute hooks from override render
-                for (let i = 0; i < overrideHooks.length; i++) overrideHooks[i]()
+                for (let i = 0; i < overrideHooks.length; i++) overrideHooks[i]!()
             }
 
             ;(dom as any).vnodes = normalized
             // `document.activeElement` can return null: https://html.spec.whatwg.org/multipage/interaction.html#dom-document-activeelement
             if (active != null && activeElement(dom) !== active && typeof (active as any).focus === 'function')
                 (active as any).focus()
-            for (let i = 0; i < hooks.length; i++) hooks[i]()
+            for (let i = 0; i < hooks.length; i++) hooks[i]!()
         } finally {
             currentRedraw = prevRedraw
             currentDOM = prevDOM

package/render/ssrState.ts

@@ -306,11 +306,11 @@ function restoreComputedProperties(state: State<any>, initial: any): void {
                     const keys = prefix ? prefix.split('.').filter((k) => k) : []
                     let targetState = target
                     for (let i = 0; i < keys.length; i++) {
-                        if (!targetState[keys[i]]) {
+                        if (!targetState[keys[i]!]) {
                             // Nested state doesn't exist yet, skip
                             return
                         }
-                        targetState = targetState[keys[i]]
+                        targetState = targetState[keys[i]!]
                     }
                     // Clear any existing signal in signalMap so function is re-initialized as ComputedSignal
                     if (targetState && typeof targetState === 'object' && (targetState as any).__isState) {

package/server/logger.ts

@@ -96,7 +96,7 @@ function getColorByHash(text: string): string {
         colors.cyan,
     ]
     const hash = hashString(text)
-    return colorOptions[hash % colorOptions.length]
+    return colorOptions[hash % colorOptions.length]!
 }
 
 const textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null

package/server/session.ts

@@ -83,5 +83,5 @@ export class MemorySessionStore implements SessionStore {
 export function extractSessionId(req: Request): string | null {
     const cookies = req.headers.get('cookie') || ''
     const sessionIdMatch = cookies.match(/sessionId=([^;]+)/)
-    return sessionIdMatch ? sessionIdMatch[1] : null
+    return sessionIdMatch ? sessionIdMatch[1]! : null
 }

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)
@@ -21,11 +22,11 @@ function restoreComputedProperties(state: State<any>, initial: any): void {
                     const keys = prefix ? prefix.split('.').filter((k) => k) : []
                     let targetState = target
                     for (let i = 0; i < keys.length; i++) {
-                        if (!targetState || !targetState[keys[i]]) {
+                        if (!targetState || !targetState[keys[i]!]) {
                             // Nested state doesn't exist yet, skip
                             return
                         }
-                        targetState = targetState[keys[i]]
+                        targetState = targetState[keys[i]!]
                     }
                     if (targetState) {
                         // Clear any existing signal in signalMap so function is re-initialized as ComputedSignal
@@ -536,7 +537,7 @@ export class Store<T extends Record<string, any> = Record<string, any>> {
         try {
             const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${key}=([^;]*)`))
             if (!match) return {}
-            const parsed = JSON.parse(decodeURIComponent(match[1]))
+            const parsed = JSON.parse(decodeURIComponent(match[1]!))
             return parsed && typeof parsed === 'object' ? parsed : {}
         } catch {
             return {}

package/util/ssr.ts

@@ -198,7 +198,7 @@ function formatCombinedStructure(parent: Element | Node | null, vnode: any, maxP
 
     // Closing tags for DOM parents (in reverse order)
     for (let i = domElements.length - 1; i >= 0; i--) {
-        lines.push('  '.repeat(i) + domElements[i].closeTag)
+        lines.push('  '.repeat(i) + domElements[i]!.closeTag)
     }
 
     return lines.join('\n')