gnim 1.2.4 → 1.2.6

package/dist/dbus.d.ts

@@ -7,8 +7,9 @@
 import Gio from "gi://Gio";
 import GLib from "gi://GLib";
 import GObject from "gi://GObject";
-import { type InferVariant } from "./variant.js";
 import { register } from "./gobject.js";
+export declare const Variant: typeof GLib.Variant;
+export type Variant<T extends string> = GLib.Variant<T>;
 declare const info: unique symbol;
 declare const internals: unique symbol;
 declare const remoteMethod: unique symbol;
@@ -62,10 +63,11 @@ type DBusType = string | {
     type: string;
     name: string;
 };
+type DeepInfer<T extends string> = ReturnType<GLib.Variant<T>["deepUnpack"]>;
 type InferVariantTypes<T extends Array<DBusType>> = {
-    [K in keyof T]: T[K] extends string ? InferVariant<T[K]> : T[K] extends {
+    [K in keyof T]: T[K] extends string ? DeepInfer<T[K]> : T[K] extends {
         type: infer S;
-    } ? S extends string ? InferVariant<S> : never : unknown;
+    } ? S extends string ? DeepInfer<S> : never : unknown;
 };
 /**
  * Registers a method.
@@ -103,21 +105,21 @@ export declare function methodAsync<const InArgs extends Array<DBusType>>(...inA
  * not emit the notify signal.
  * ```
  */
-export declare function property<T extends string>(type: T): (_: void, ctx: ClassFieldDecoratorContext<Service, InferVariant<T>>) => (this: Service, init: InferVariant<T>) => InferVariant<T>;
+export declare function property<T extends string>(type: T): (_: void, ctx: ClassFieldDecoratorContext<Service, DeepInfer<T>>) => (this: Service, init: DeepInfer<T>) => DeepInfer<T>;
 /**
  * Registers a read-only property. Can be used in conjuction with {@link setter} to define
  * read-write properties as accessors.
  *
  * Note that you will need to explicitly emit the notify signal.
  */
-export declare function getter<T extends string>(type: T): (getter: (this: Service) => InferVariant<T>, ctx: ClassGetterDecoratorContext<Service, InferVariant<T>>) => (this: Service) => InferVariant<T>;
+export declare function getter<T extends string>(type: T): (getter: (this: Service) => DeepInfer<T>, ctx: ClassGetterDecoratorContext<Service, DeepInfer<T>>) => (this: Service) => DeepInfer<T>;
 /**
  * Registers a write-only property. Can be used in conjuction with {@link getter} to define
  * read-write properties as accessors.
  *
  * Note that you will need to explicitly emit the notify signal.
  */
-export declare function setter<T extends string>(type: T): (setter: (this: Service, value: InferVariant<T>) => void, ctx: ClassSetterDecoratorContext<Service, InferVariant<T>>) => (this: Service, value: InferVariant<T>) => void;
+export declare function setter<T extends string>(type: T): (setter: (this: Service, value: DeepInfer<T>) => void, ctx: ClassSetterDecoratorContext<Service, DeepInfer<T>>) => (this: Service, value: DeepInfer<T>) => void;
 /**
  * Registers a signal which when invoked will emit the signal
  * on the local object and the exported object.
@@ -125,15 +127,4 @@ export declare function setter<T extends string>(type: T): (setter: (this: Servi
  * **Note**: its not possible to emit signals on remote objects through proxies.
  */
 export declare function signal<const Params extends Array<DBusType>>(...params: Params): (method: (this: Service, ...params: InferVariantTypes<Params>) => void, ctx: ClassMethodDecoratorContext<Service, typeof method>) => typeof method;
-declare class GLibVariant<T extends string = any> extends GLib.Variant<T> {
-    static new<T extends string>(signature: T, value: InferVariant<T>): GLib.Variant<T>;
-    constructor(signature: T, value: InferVariant<T>);
-    deepUnpack<V = InferVariant<T>>(): V;
-    deep_unpack<V = InferVariant<T>>(): V;
-}
-export declare namespace Variant {
-    type Infer<S extends string> = InferVariant<S>;
-}
-export declare const Variant: typeof GLibVariant;
-export type Variant<T extends string = any> = GLibVariant<T>;
 export {};

package/dist/dbus.js

@@ -22,6 +22,7 @@ import GObject from "gi://GObject";
 import { definePropertyGetter, kebabify, xml } from "./util.js";
 import { register, property as gproperty, signal as gsignal, getter as ggetter, setter as gsetter, } from "./gobject.js";
 const DEFAULT_TIMEOUT = 10000;
+export const Variant = GLib.Variant;
 const info = Symbol("dbus interface info");
 const internals = Symbol("dbus interface internals");
 const remoteMethod = Symbol("proxy remoteMethod");
@@ -549,28 +550,3 @@ export function signal(...params) {
         };
     };
 }
-// HACK: how do I augment it globally?
-class GLibVariant extends GLib.Variant {
-    static new(signature, value) {
-        return GLib.Variant.new(signature, value);
-    }
-    constructor(signature, value) {
-        super(signature, value);
-    }
-    deepUnpack() {
-        return super.deepUnpack();
-    }
-    deep_unpack() {
-        return super.deepUnpack();
-    }
-}
-export const Variant = GLib.Variant;
-// FIXME: should be augmented globally
-// declare module "gi://GLib?version=2.0" {
-//     export namespace GLib {
-//         export interface Variant<T extends string = string> {
-//             deepUnpack<V = InferVariantType<T>>(): V
-//             deep_unpack<V = InferVariantType<T>>(): V
-//         }
-//     }
-// }

package/dist/gobject.d.ts

@@ -22,6 +22,20 @@ export type ParamFlags = GObject.ParamFlags;
 export declare const ParamFlags: typeof GObject.ParamFlags;
 export type GType<T = unknown> = GObject.GType<T>;
 type GObj = GObject.Object;
+type Context = {
+    private: false;
+    static: false;
+    name: string;
+};
+type PropertyContext<T> = ClassFieldDecoratorContext<GObj, T> & Context;
+type GetterContext<T> = ClassGetterDecoratorContext<GObj, T> & Context;
+type SetterContext<T> = ClassSetterDecoratorContext<GObj, T> & Context;
+type SignalContext<T extends () => any> = ClassMethodDecoratorContext<GObj, T> & Context;
+type SignalOptions = {
+    default?: boolean;
+    flags?: SignalFlags;
+    accumulator?: AccumulatorType;
+};
 type PropertyTypeDeclaration<T> = ((name: string, flags: ParamFlags) => ParamSpec<T>) | ParamSpec<T> | {
     $gtype: GType<T>;
 };
@@ -35,7 +49,7 @@ type PropertyTypeDeclaration<T> = ((name: string, flags: ParamFlags) => ParamSpe
  * }
  * ```
  */
-export declare function property<T>(typeDeclaration: PropertyTypeDeclaration<T>): (_: void, ctx: ClassFieldDecoratorContext<GObj, T>, options?: {
+export declare function property<T>(typeDeclaration: PropertyTypeDeclaration<T>): (_: void, ctx: PropertyContext<T>, options?: {
     metaOnly: true;
 }) => (this: GObj, init: T) => T;
 /**
@@ -57,7 +71,7 @@ export declare function property<T>(typeDeclaration: PropertyTypeDeclaration<T>)
  * }
  * ```
  */
-export declare function getter<T>(typeDeclaration: PropertyTypeDeclaration<T>): (getter: (this: GObj) => T, ctx: ClassGetterDecoratorContext<GObj, T>) => (this: GObj) => T;
+export declare function getter<T>(typeDeclaration: PropertyTypeDeclaration<T>): (getter: (this: GObj) => T, ctx: GetterContext<T>) => (this: GObj) => T;
 /**
  * Defines a write-only property to be registered when using the {@link register} decorator.
  * If the setter has a getter pair decorated with the {@link getter} decorator the property will be writeable *and* readable.
@@ -77,7 +91,7 @@ export declare function getter<T>(typeDeclaration: PropertyTypeDeclaration<T>):
  * }
  * ```
  */
-export declare function setter<T>(typeDeclaration: PropertyTypeDeclaration<T>): (setter: (this: GObj, value: T) => void, ctx: ClassSetterDecoratorContext<GObj, T>) => (this: GObj, value: T) => void;
+export declare function setter<T>(typeDeclaration: PropertyTypeDeclaration<T>): (setter: (this: GObj, value: T) => void, ctx: SetterContext<T>) => (this: GObj, value: T) => void;
 type ParamType<P> = P extends {
     $gtype: GType<infer T>;
 } ? T : P extends GType<infer T> ? T : never;
@@ -104,10 +118,7 @@ export declare function signal<const Params extends Array<{
     $gtype: GType;
 } | GType>, Return extends {
     $gtype: GType;
-} | GType>(params: Params, returnType?: Return, options?: {
-    flags?: SignalFlags;
-    accumulator?: AccumulatorType;
-}): (method: (this: GObj, ...args: ParamTypes<Params>) => ParamType<Return>, ctx: ClassMethodDecoratorContext<GObj, typeof method>) => typeof method;
+} | GType>(params: Params, returnType?: Return, options?: SignalOptions): (method: (this: GObj, ...args: ParamTypes<Params>) => ParamType<Return>, ctx: SignalContext<typeof method>) => typeof method;
 /**
  * Defines a signal to be registered when using the {@link register} decorator.
  *
@@ -123,7 +134,7 @@ export declare function signal<const Params extends Array<{
  */
 export declare function signal<Params extends Array<{
     $gtype: GType;
-} | GType>>(...params: Params): (method: (this: GObject.Object, ...args: ParamTypes<Params>) => void, ctx: ClassMethodDecoratorContext<GObj, typeof method>) => typeof method;
+} | GType>>(...params: Params): (method: (this: GObject.Object, ...args: ParamTypes<Params>) => void, ctx: SignalContext<typeof method>) => typeof method;
 type MetaInfo = GObject.MetaInfo<never, Array<{
     $gtype: GType<unknown>;
 }>, never>;
@@ -147,6 +158,16 @@ export declare function register<Cls extends {
 /**
  * @experimental
  * Asserts a gtype in cases where the type is too loose/strict.
+ *
+ * Example:
+ * ```ts
+ * type Tuple = [number, number]
+ * const Tuple = gtype<Tuple>(Array)
+ *
+ * class {
+ *   \@property(Tuple) value = [1, 2] as Tuple
+ * }
+ * ```
  */
 export declare function gtype<Assert>(type: GType<any> | {
     $gtype: GType<any>;

package/dist/gobject.js

@@ -157,6 +157,7 @@ export function signal(...args) {
             const [params, returnType, options] = args;
             signals[signalName] = {
                 method,
+                default: options?.default ?? true,
                 param_types: params.map((i) => ("$gtype" in i ? i.$gtype : i)),
                 ...(returnType && {
                     return_type: "$gtype" in returnType ? returnType.$gtype : returnType,
@@ -202,7 +203,7 @@ function pspecFromGType(type, name, flags) {
             return ParamSpec.int64(name, "", "", flags, MININT64, MAXINT64, 0);
         case GObject.TYPE_UINT64:
             return ParamSpec.uint64(name, "", "", flags, 0, Number.MAX_SAFE_INTEGER, 0);
-        case GObject.type_from_name("gfloat"):
+        case GObject.TYPE_FLOAT:
             return ParamSpec.float(name, "", "", flags, MINFLOAT, MAXFLOAT, 0);
         case GObject.TYPE_DOUBLE:
             return ParamSpec.double(name, "", "", flags, Number.MIN_VALUE, Number.MIN_VALUE, 0);
@@ -271,20 +272,34 @@ export function register(options = {}) {
             const spec = pspec(key, flags, type);
             return [key, spec];
         }));
-        const signals = fromEntries(entries(meta.signals ?? {}).map(([signalName, { method, ...signal }]) => {
-            defineProperty(cls.prototype, `on_${signalName.replaceAll("-", "_")}`, {
-                enumerable: false,
-                configurable: false,
-                value: method,
-            });
+        const signals = fromEntries(entries(meta.signals ?? {}).map(([signalName, { default: def, method, ...signal }]) => {
+            if (def) {
+                defineProperty(cls.prototype, `on_${signalName.replaceAll("-", "_")}`, {
+                    enumerable: false,
+                    configurable: false,
+                    value: method,
+                });
+            }
             return [signalName, signal];
         }));
+        delete meta.properties;
+        delete meta.signals;
         registerClass({ ...options, Properties: props, Signals: signals }, cls);
     };
 }
 /**
  * @experimental
  * Asserts a gtype in cases where the type is too loose/strict.
+ *
+ * Example:
+ * ```ts
+ * type Tuple = [number, number]
+ * const Tuple = gtype<Tuple>(Array)
+ *
+ * class {
+ *   \@property(Tuple) value = [1, 2] as Tuple
+ * }
+ * ```
  */
 export function gtype(type) {
     return "$gtype" in type ? type : { $gtype: type };

package/dist/jsx/For.js

@@ -1,9 +1,10 @@
 import { Fragment } from "./Fragment.js";
 import { createState } from "./state.js";
 import { env } from "./env.js";
-import { onCleanup, Scope } from "./scope.js";
+import { getScope, onCleanup, Scope } from "./scope.js";
 // TODO: support Gio.ListModel
 export function For({ each, children: mkChild, cleanup, id = (item) => item, }) {
+    const currentScope = getScope();
     const map = new Map();
     const fragment = new Fragment();
     function remove({ item, child, index: [index], scope }) {
@@ -44,17 +45,17 @@ export function For({ each, children: mkChild, cleanup, id = (item) => item, })
             }
             else {
                 const [index, setIndex] = createState(i);
-                const scope = new Scope(Scope.current);
+                const scope = new Scope(currentScope);
                 const child = scope.run(() => mkChild(item, index));
                 map.set(key, { item, child, index: [index, setIndex], scope });
                 fragment.addChild(child);
             }
         });
     }
-    callback(each.get());
     const dispose = each.subscribe(() => {
         callback(each.get());
     });
+    callback(each.get());
     onCleanup(() => {
         dispose();
         for (const value of map.values()) {

package/dist/jsx/With.js

@@ -1,7 +1,8 @@
 import { Fragment } from "./Fragment.js";
 import { env } from "./env.js";
-import { onCleanup, Scope } from "./scope.js";
+import { getScope, onCleanup, Scope } from "./scope.js";
 export function With({ value, children: mkChild, cleanup, }) {
+    const currentScope = getScope();
     const fragment = new Fragment();
     let scope;
     function callback(v) {
@@ -16,7 +17,7 @@ export function With({ value, children: mkChild, cleanup, }) {
             if (scope)
                 scope.dispose();
         }
-        scope = new Scope(Scope.current);
+        scope = new Scope(currentScope);
         const ch = scope.run(() => mkChild(v));
         if (ch !== "" && ch !== false && ch !== null && ch !== undefined) {
             fragment.addChild(ch);

package/dist/jsx/jsx.d.ts

@@ -3,7 +3,10 @@ import { Fragment } from "./Fragment.js";
 import { Accessor } from "./state.js";
 import { CC, FC } from "./env.js";
 import { Pascalify } from "../util.js";
-type Node = Array<GObject.Object> | GObject.Object | number | string | boolean | null | undefined;
+/**
+ * Represents all of the things that can be passed as a child to class components.
+ */
+export type Node = Array<GObject.Object> | GObject.Object | number | string | boolean | null | undefined;
 export declare const gtkType: unique symbol;
 /**
  * Get the type of the object specified through the `$type` property

package/dist/jsx/state.d.ts

@@ -1,7 +1,7 @@
 import GObject from "gi://GObject";
 import Gio from "gi://Gio";
+import GLib from "gi://GLib";
 import { type Pascalify } from "../util.js";
-import { type InferVariantRec, type InferVariant } from "../variant.js";
 type SubscribeCallback = () => void;
 type DisposeFunction = () => void;
 type SubscribeFunction = (callback: SubscribeCallback) => DisposeFunction;
@@ -82,7 +82,7 @@ export declare function createBinding<T extends GObject.Object, P extends keyof
  * @param key The settings key
  */
 export declare function createBinding<T>(settings: Gio.Settings, key: string): Accessor<T>;
-type ConnectionHandler<O extends GObject.Object, S extends keyof O["$signals"], Return> = O["$signals"][S] extends (...args: any[]) => infer R ? void extends R ? (...args: Parameters<O["$signals"][S]>) => Return : never : never;
+type ConnectionHandler<O extends GObject.Object, S extends keyof O["$signals"], T> = O["$signals"][S] extends (...args: any[]) => infer R ? void extends R ? (...args: [...Parameters<O["$signals"][S]>, currentValue: T]) => T : never : never;
 /**
  * Create an `Accessor` which sets up a list of `GObject.Object` signal connections.
  *
@@ -116,11 +116,13 @@ export declare function createConnection<T, O1 extends GObject.Object, S1 extend
  * @param producer The producer function which should return a cleanup function
  */
 export declare function createExternal<T>(init: T, producer: (set: Setter<T>) => DisposeFunction): Accessor<T>;
+type DeepInfer<T extends string> = ReturnType<GLib.Variant<T>["deepUnpack"]>;
+type RecursiveInfer<T extends string> = ReturnType<GLib.Variant<T>["recursiveUnpack"]>;
 /** @experimental */
 type Settings<T extends Record<string, string>> = {
-    [K in keyof T as Uncapitalize<Pascalify<K>>]: Accessor<InferVariantRec<T[K]>>;
+    [K in keyof T as Uncapitalize<Pascalify<K>>]: Accessor<RecursiveInfer<T[K]>>;
 } & {
-    [K in keyof T as `set${Pascalify<K>}`]: Setter<InferVariant<T[K]>>;
+    [K in keyof T as `set${Pascalify<K>}`]: Setter<DeepInfer<T[K]>>;
 };
 /**
  * @experimental

package/dist/jsx/state.js

@@ -29,6 +29,7 @@ export class Accessor extends Function {
      * @returns Unsubscribe function.
      */
     subscribe(callback) {
+        // TODO: auto unsub when a scope is available?
         return __classPrivateFieldGet(this, _Accessor_subscribe, "f").call(this, callback);
     }
     /**
@@ -176,7 +177,7 @@ export function createConnection(init, h1, h2, h3, h4, h5, h6, h7, h8, h9) {
         if (subscribers.size === 0) {
             dispose = signals.map(([object, signal, callback]) => {
                 const id = GObject.Object.prototype.connect.call(object, signal, (_, ...args) => {
-                    const newValue = callback(...args);
+                    const newValue = callback(...args, value);
                     if (value !== newValue) {
                         value = newValue;
                         subscribers.forEach((cb) => cb());

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gnim",
-    "version": "1.2.4",
+    "version": "1.2.6",
     "type": "module",
     "author": "Aylur",
     "license": "MIT",