gnim 1.6.4 → 1.7.0

package/dist/gtk4/jsx-runtime.ts

@@ -3,6 +3,9 @@ import Gio from "gi://Gio?version=2.0"
 import { configue } from "../jsx/env.js"
 import { getType, onCleanup, Accessor, Fragment } from "../index.js"
 
+import type Adw from "gi://Adw"
+const adw = await import("gi://Adw").then((m) => m.default).catch(() => null)
+
 const dummyBuilder = new Gtk.Builder()
 
 const { intrinsicElements } = configue({
@@ -14,6 +17,14 @@ const { intrinsicElements } = configue({
             ]
             return keys
         }
+        if (adw && ctor === adw.ToggleGroup) {
+            const keys: Array<Extract<keyof Adw.ToggleGroup, string>> = [
+                "active",
+                "activeName",
+                "active_name",
+            ]
+            return keys
+        }
     },
     setCss(object, css) {
         if (!(object instanceof Gtk.Widget)) {

package/dist/jsx/jsx.ts

@@ -167,11 +167,6 @@ export function append(parent: GObject.Object, child: GObject.Object) {
         return
     }
 
-    if (appendChild in parent && typeof parent[appendChild] === "function") {
-        parent[appendChild](child, getType(child))
-        return
-    }
-
     if (child instanceof Fragment) {
         for (const ch of child) {
             append(parent, ch)
@@ -199,12 +194,12 @@ export function append(parent: GObject.Object, child: GObject.Object) {
         return
     }
 
-    if (child) {
-        if (!(child instanceof GObject.Object)) {
-            child = env.textNode(child)
-        }
-        env.appendChild(parent, child)
+    if (appendChild in parent && typeof parent[appendChild] === "function") {
+        parent[appendChild](child, getType(child))
+        return
     }
+
+    env.appendChild(parent, child)
 }
 
 /** @internal */

package/dist/jsx/state.ts

@@ -10,6 +10,8 @@ type SubscribeFunction = (callback: SubscribeCallback) => DisposeFunction
 
 export type Accessed<T> = T extends Accessor<infer V> ? V : never
 
+const empty = Symbol("empty computed value")
+
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Accessor<T = unknown> extends Function {
     static $gtype = GObject.TYPE_JSOBJECT as unknown as GObject.GType<Accessor>
@@ -29,7 +31,6 @@ export class Accessor<T = unknown> extends Function {
      * @returns Unsubscribe function.
      */
     subscribe(callback: SubscribeCallback): DisposeFunction {
-        // TODO: auto unsub when a scope is available?
         return this.#subscribe(callback)
     }
 
@@ -49,7 +50,38 @@ export class Accessor<T = unknown> extends Function {
     }
 
     protected _call<R = T>(transform: (value: T) => R): Accessor<R> {
-        return this.as(transform)
+        let value: typeof empty | R = empty
+        let unsub: DisposeFunction
+
+        const subscribers = new Set<SubscribeCallback>()
+
+        const subscribe: SubscribeFunction = (callback) => {
+            if (subscribers.size === 0) {
+                unsub = this.subscribe(() => {
+                    const newValue = transform(this.get())
+                    if (value !== newValue) {
+                        value = newValue
+                        Array.from(subscribers).forEach((cb) => cb())
+                    }
+                })
+            }
+
+            subscribers.add(callback)
+
+            return () => {
+                subscribers.delete(callback)
+                if (subscribers.size === 0) {
+                    value = empty
+                    unsub()
+                }
+            }
+        }
+
+        const get = (): R => {
+            return value !== empty ? value : transform(this.get())
+        }
+
+        return new Accessor(get, subscribe)
     }
 
     toString(): string {
@@ -64,8 +96,9 @@ export class Accessor<T = unknown> extends Function {
 
 export interface Accessor<T> {
     /**
-     * Create a new `Accessor` that applies a transformation on its value.
+     * Create a computed `Accessor` that caches its transformed value.
      * @param transform The transformation to apply. Should be a pure function.
+     * see {@link createComputed} and {@link createComputedProducer}
      */
     <R = T>(transform: (value: T) => R): Accessor<R>
 }
@@ -104,16 +137,22 @@ export function createState<T>(init: T): State<T> {
     return [new Accessor(() => currentValue, subscribe), set as Setter<T>]
 }
 
-const empty = Symbol("empty computed value")
-
 function createComputedProducer<T>(fn: (track: <V>(signal: Accessor<V>) => V) => T): Accessor<T> {
-    const subscribers = new Set<SubscribeCallback>()
     let value: typeof empty | T = empty
     let prevDeps = new Map<Accessor, DisposeFunction>()
 
+    const subscribers = new Set<SubscribeCallback>()
+    const cache = new Map<Accessor, unknown>()
+
     const effect = () => {
         const deps = new Set<Accessor>()
-        value = fn((v) => (deps.add(v), v.get()))
+        const newValue = fn((v) => {
+            deps.add(v)
+            return (cache.get(v) as any) || v.get()
+        })
+
+        const didChange = value !== newValue
+        value = newValue
 
         const newDeps = new Map<Accessor, DisposeFunction>()
 
@@ -127,12 +166,21 @@ function createComputedProducer<T>(fn: (track: <V>(signal: Accessor<V>) => V) =>
 
         for (const dep of deps) {
             if (!newDeps.has(dep)) {
-                newDeps.set(dep, dep.subscribe(effect))
+                const dispose = dep.subscribe(() => {
+                    const value = dep.get()
+                    if (cache.get(dep) !== value) {
+                        cache.set(dep, value)
+                        effect()
+                    }
+                })
+                newDeps.set(dep, dispose)
             }
         }
 
         prevDeps = newDeps
-        Array.from(subscribers).forEach((cb) => cb())
+        if (didChange) {
+            Array.from(subscribers).forEach((cb) => cb())
+        }
     }
 
     const subscribe: SubscribeFunction = (callback) => {
@@ -154,7 +202,7 @@ function createComputedProducer<T>(fn: (track: <V>(signal: Accessor<V>) => V) =>
     }
 
     const get = (): T => {
-        return value === empty ? fn((v) => v.get()) : value
+        return value !== empty ? value : fn((v) => v.get())
     }
 
     return new Accessor(get, subscribe)
@@ -166,17 +214,36 @@ function createComputedArgs<
     V = Args,
 >(deps: Deps, transform?: (...args: Args) => V): Accessor<V> {
     let dispose: Array<DisposeFunction>
+    let value: typeof empty | V = empty
+
     const subscribers = new Set<SubscribeCallback>()
     const cache = new Array<unknown>(deps.length)
 
+    const compute = (): V => {
+        const args = deps.map((dep, i) => {
+            if (!cache[i]) {
+                cache[i] = dep.get()
+            }
+
+            return cache[i]
+        })
+
+        return transform ? transform(...(args as Args)) : (args as V)
+    }
+
     const subscribe: SubscribeFunction = (callback) => {
         if (subscribers.size === 0) {
             dispose = deps.map((dep, i) =>
                 dep.subscribe(() => {
-                    const value = dep.get()
-                    if (cache[i] !== value) {
+                    const newValue = dep.get()
+                    if (cache[i] !== newValue) {
                         cache[i] = dep.get()
-                        Array.from(subscribers).forEach((cb) => cb())
+
+                        const newValue = compute()
+                        if (value !== newValue) {
+                            value = newValue
+                            Array.from(subscribers).forEach((cb) => cb())
+                        }
                     }
                 }),
             )
@@ -187,6 +254,7 @@ function createComputedArgs<
         return () => {
             subscribers.delete(callback)
             if (subscribers.size === 0) {
+                value = empty
                 dispose.map((cb) => cb())
                 dispose.length = 0
                 cache.length = 0
@@ -195,15 +263,7 @@ function createComputedArgs<
     }
 
     const get = (): V => {
-        const args = deps.map((dep, i) => {
-            if (!cache[i]) {
-                cache[i] = dep.get()
-            }
-
-            return cache[i]
-        })
-
-        return transform ? transform(...(args as Args)) : (args as V)
+        return value !== empty ? value : compute()
     }
 
     return new Accessor(get, subscribe)
@@ -303,7 +363,9 @@ export function createBinding<T>(object: GObject.Object | Gio.Settings, key: str
     const get = (): T => {
         if (object instanceof Gio.Settings) {
             return object.get_value(key).recursiveUnpack() as T
-        } else {
+        }
+
+        if (object instanceof GObject.Object) {
             const getter = `get_${prop.replaceAll("-", "_")}` as keyof typeof object
 
             if (getter in object && typeof object[getter] === "function") {
@@ -312,9 +374,9 @@ export function createBinding<T>(object: GObject.Object | Gio.Settings, key: str
 
             if (prop in object) return object[prop] as T
             if (key in object) return object[key as keyof typeof object] as T
-
-            throw Error(`cannot get property ${key}`)
         }
+
+        throw Error(`cannot get property "${key}" on "${object}"`)
     }
 
     return new Accessor(get, subscribe)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gnim",
-    "version": "1.6.4",
+    "version": "1.7.0",
     "type": "module",
     "author": "Aylur",
     "license": "MIT",
@@ -20,12 +20,16 @@
         "docs:preview": "vitepress preview docs"
     },
     "devDependencies": {
+        "@eslint/js": "latest",
         "@girs/adw-1": "latest",
         "@girs/clutter-16": "latest",
         "@girs/gtk-3.0": "latest",
+        "@girs/gtk-4.0": "latest",
         "@girs/soup-3.0": "latest",
+        "@girs/shell-16": "latest",
         "@girs/st-16": "latest",
         "@girs/gnome-shell": "latest",
+        "@girs/gjs": "latest",
         "esbuild": "latest",
         "eslint": "latest",
         "typescript": "latest",