gnim 1.2.0 → 1.2.2

package/README.md

@@ -33,12 +33,7 @@ function Counter() {
 }
 ```
 
-## Example apps using Gnim
+## Templates
 
-- [icon-theme-browser](https://github.com/Aylur/icon-theme-browser)
-
-## Credits
-
-- [JU12000](https://github.com/JU12000) for suggesting the name Gnim
-- [Azazel-Woodwind](https://github.com/Azazel-Woodwind) for a lot of early
-  testing
+- [gnome-extension](https://github.com/Aylur/gnome-shell-extension-template/)
+- [gtk4](https://github.com/Aylur/gnim-gtk4-template/)

package/dist/dbus.d.ts

@@ -7,6 +7,8 @@
 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";
 declare const info: unique symbol;
 declare const internals: unique symbol;
 declare const remoteMethod: unique symbol;
@@ -51,26 +53,19 @@ export declare class Service extends GObject.Object {
  * Registers a {@link Service} as a dbus interface.
  *
  * @param name Interface name of the object. For example "org.gnome.Shell.SearchProvider2"
- * @param gobjectMetaInfo optional properties to pass to {@link GObject.registerClass}
+ * @param options optional properties to pass to {@link register}
  */
-export declare function iface(name: string, gobjectMetaInfo?: GObject.MetaInfo<never, Array<{
-    $gtype: GObject.GType;
-}>, never>): (cls: {
+export declare function iface(name: string, options?: Parameters<typeof register>[0]): (cls: {
     new (...args: any[]): Service;
 }, ctx: ClassDecoratorContext) => void;
 type DBusType = string | {
     type: string;
     name: string;
 };
-type InferVariantTuple<NestedVariant extends string> = NestedVariant extends string ? Array<any> : never;
-/**
- * Infer the runtime JavaScript type of a Variant type
- */
-export type InferVariantType<T extends string> = T extends "v" ? Variant<any> : T extends "b" ? boolean : T extends "y" | "n" | "q" | "i" | "u" | "x" | "t" | "h" | "d" ? number : T extends "s" | "g" ? string : T extends "o" ? `/${string}` : T extends `a{${infer K}${infer S}}` ? S extends string ? K extends string ? Record<Extract<InferVariantType<K>, string | number>, InferVariantType<S>> : never : never : T extends `a${infer S}` ? S extends string ? Array<InferVariantType<S>> : never : T extends `(${infer S})` ? S extends string ? InferVariantTuple<S> : never : never;
 type InferVariantTypes<T extends Array<DBusType>> = {
-    [K in keyof T]: T[K] extends string ? InferVariantType<T[K]> : T[K] extends {
+    [K in keyof T]: T[K] extends string ? InferVariant<T[K]> : T[K] extends {
         type: infer S;
-    } ? S extends string ? InferVariantType<S> : never : unknown;
+    } ? S extends string ? InferVariant<S> : never : unknown;
 };
 /**
  * Registers a method.
@@ -108,33 +103,36 @@ 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, InferVariantType<T>>) => (this: Service, init: InferVariantType<T>) => InferVariantType<T>;
+export declare function property<T extends string>(type: T): (_: void, ctx: ClassFieldDecoratorContext<Service, InferVariant<T>>) => (this: Service, init: InferVariant<T>) => InferVariant<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) => InferVariantType<T>, ctx: ClassGetterDecoratorContext<Service, InferVariantType<T>>) => (this: Service) => InferVariantType<T>;
+export declare function getter<T extends string>(type: T): (getter: (this: Service) => InferVariant<T>, ctx: ClassGetterDecoratorContext<Service, InferVariant<T>>) => (this: Service) => InferVariant<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: InferVariantType<T>) => void, ctx: ClassSetterDecoratorContext<Service, InferVariantType<T>>) => (this: Service, value: InferVariantType<T>) => void;
+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;
 /**
  * Registers a signal which when invoked will emit the signal
  * on the local object and the exported object.
  *
- * Note that its not possible to emit signals on remote objects through proxies.
+ * **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: InferVariantType<T>): GLib.Variant<T>;
-    constructor(signature: T, value: InferVariantType<T>);
-    deepUnpack<V = InferVariantType<T>>(): V;
-    deep_unpack<V = InferVariantType<T>>(): V;
+    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>;

package/dist/dbus.js

@@ -19,7 +19,8 @@ var _Service_instances, _a, _Service_info, _Service_handlePropertyGet, _Service_
 import Gio from "gi://Gio";
 import GLib from "gi://GLib";
 import GObject from "gi://GObject";
-import { getterWorkaround, kebabify, xml } from "./util.js";
+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;
 const info = Symbol("dbus interface info");
 const internals = Symbol("dbus interface internals");
@@ -275,79 +276,18 @@ _a = Service;
 (() => {
     GObject.registerClass(_a);
 })();
-function paramSpecFromVariant(type, name, { read, write }) {
-    let flags = 0;
-    if (read)
-        flags |= GObject.ParamFlags.READABLE;
-    if (write)
-        flags |= GObject.ParamFlags.WRITABLE;
-    if (type.startsWith("a") || type.startsWith("(") || type === "v") {
-        return GObject.ParamSpec.jsobject(name, name, name, flags);
-    }
-    switch (type) {
-        case "b":
-            return GObject.ParamSpec.boolean(name, name, name, flags, false);
-        case "y":
-        case "n":
-        case "q":
-        case "i":
-        case "u":
-        case "x":
-        case "t":
-        case "h":
-        case "d":
-            // TODO: be more specific about number types
-            return GObject.ParamSpec.double(name, name, name, flags, Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, 0);
-        case "s":
-        case "g":
-        case "o":
-            return GObject.ParamSpec.string(name, name, name, flags, "");
-        default:
-            break;
-    }
-    throw Error(`cannot infer ParamSpec from variant "${type}"`);
-}
-function inferGTypeFromVariant(type) {
-    if (type.startsWith("a") || type.startsWith("(")) {
-        return GObject.TYPE_JSOBJECT;
-    }
-    switch (type) {
-        case "v":
-            return GObject.TYPE_VARIANT;
-        case "b":
-            return GObject.TYPE_BOOLEAN;
-        case "y":
-        case "n":
-        case "q":
-        case "i":
-        case "u":
-        case "x":
-        case "t":
-        case "h":
-        case "d":
-            // TODO: be more specific about number types
-            return GObject.TYPE_DOUBLE;
-        case "s":
-        case "g":
-        case "o":
-            return GObject.TYPE_STRING;
-        default:
-            break;
-    }
-    throw Error(`cannot infer GType from variant "${type}"`);
-}
 /**
  * Registers a {@link Service} as a dbus interface.
  *
  * @param name Interface name of the object. For example "org.gnome.Shell.SearchProvider2"
- * @param gobjectMetaInfo optional properties to pass to {@link GObject.registerClass}
+ * @param options optional properties to pass to {@link register}
  */
-export function iface(name, gobjectMetaInfo) {
+export function iface(name, options) {
     return function (cls, ctx) {
         const meta = ctx.metadata;
         if (!meta)
             throw Error(`${cls.name} is not an interface`);
-        const { methods = {}, signals = {}, properties = {} } = meta;
+        const { dbusMethods = {}, dbusSignals = {}, dbusProperties = {} } = meta;
         const infoXml = xml({
             name: "node",
             children: [
@@ -355,17 +295,17 @@ export function iface(name, gobjectMetaInfo) {
                     name: "interface",
                     attributes: { name },
                     children: [
-                        ...Object.entries(methods).map(([name, args]) => ({
+                        ...Object.entries(dbusMethods).map(([name, args]) => ({
                             name: "method",
                             attributes: { name },
                             children: args.map((arg) => ({ name: "arg", attributes: arg })),
                         })),
-                        ...Object.entries(signals).map(([name, args]) => ({
+                        ...Object.entries(dbusSignals).map(([name, args]) => ({
                             name: "signal",
                             attributes: { name },
                             children: args.map((arg) => ({ name: "arg", attributes: arg })),
                         })),
-                        ...Object.values(properties).map(({ name, type, read, write }) => ({
+                        ...Object.values(dbusProperties).map(({ name, type, read, write }) => ({
                             name: "property",
                             attributes: {
                                 ...(name && { name }),
@@ -378,27 +318,13 @@ export function iface(name, gobjectMetaInfo) {
             ],
         });
         Object.assign(cls, { [info]: Gio.DBusInterfaceInfo.new_for_xml(infoXml) });
-        GObject.registerClass({
-            Properties: Object.fromEntries(Object.values(properties).map(({ type, name, read, write }) => {
-                const key = kebabify(name);
-                return [key, paramSpecFromVariant(type, key, { read, write })];
-            })),
-            Signals: Object.fromEntries(Object.entries(signals).map(([name, args]) => {
-                return [
-                    kebabify(name),
-                    {
-                        param_types: args.map((a) => inferGTypeFromVariant(typeof a === "string" ? a : a.type)),
-                    },
-                ];
-            })),
-            ...(gobjectMetaInfo ?? {}),
-        }, cls);
+        register(options)(cls, ctx);
     };
 }
 function installMethod(args, method, ctx) {
     const name = ctx.name;
     const meta = ctx.metadata;
-    const methods = (meta.methods ?? (meta.methods = {}));
+    const methods = (meta.dbusMethods ?? (meta.dbusMethods = {}));
     if (typeof name !== "string") {
         throw Error("only string named methods are allowed");
     }
@@ -419,7 +345,7 @@ function installProperty(type, ctx) {
     const kind = ctx.kind;
     const name = ctx.name;
     const meta = ctx.metadata;
-    const properties = (meta.properties ?? (meta.properties = {}));
+    const properties = (meta.dbusProperties ?? (meta.dbusProperties = {}));
     if (typeof name !== "string") {
         throw Error("only string named properties are allowed");
     }
@@ -444,13 +370,51 @@ function installProperty(type, ctx) {
 function installSignal(params, ctx) {
     const name = ctx.name;
     const meta = ctx.metadata;
-    const signals = (meta.signals ?? (meta.signals = {}));
+    const signals = (meta.dbusSignals ?? (meta.dbusSignals = {}));
     if (typeof name === "symbol") {
         throw Error("symbols are not valid signals");
     }
     signals[name] = params.map((arg) => (typeof arg === "string" ? { type: arg } : arg));
     return name;
 }
+function inferGTypeFromVariant(type) {
+    if (typeof type !== "string")
+        return inferGTypeFromVariant(type.type);
+    if (type.startsWith("a") || type.startsWith("(")) {
+        return GObject.TYPE_JSOBJECT;
+    }
+    switch (type) {
+        case "v":
+            return GObject.TYPE_VARIANT;
+        case "b":
+            return GObject.TYPE_BOOLEAN;
+        case "y":
+            return GObject.TYPE_UINT;
+        case "n":
+            return GObject.TYPE_INT;
+        case "q":
+            return GObject.TYPE_UINT;
+        case "i":
+            return GObject.TYPE_INT;
+        case "u":
+            return GObject.TYPE_UINT;
+        case "x":
+            return GObject.TYPE_INT64;
+        case "t":
+            return GObject.TYPE_UINT64;
+        case "h":
+            return GObject.TYPE_INT;
+        case "d":
+            return GObject.TYPE_DOUBLE;
+        case "s":
+        case "g":
+        case "o":
+            return GObject.TYPE_STRING;
+        default:
+            break;
+    }
+    throw Error(`cannot infer GType from variant "${type}"`);
+}
 export function method(...args) {
     return function (method, ctx) {
         const name = installMethod(args, method, ctx);
@@ -490,8 +454,8 @@ export function methodAsync(...args) {
 export function property(type) {
     return function (_, ctx) {
         const name = installProperty(type, ctx);
+        void gproperty({ $gtype: inferGTypeFromVariant(type) })(_, ctx, { metaOnly: true });
         ctx.addInitializer(function () {
-            getterWorkaround(this, name);
             Object.defineProperty(this, name, {
                 configurable: false,
                 enumerable: true,
@@ -532,8 +496,9 @@ export function getter(type) {
     return function (getter, ctx) {
         const name = installProperty(type, ctx);
         ctx.addInitializer(function () {
-            getterWorkaround(this, name);
+            definePropertyGetter(this, name);
         });
+        void ggetter({ $gtype: inferGTypeFromVariant(type) })(() => { }, ctx);
         return function () {
             const { proxy } = this[internals];
             return proxy
@@ -551,6 +516,7 @@ export function getter(type) {
 export function setter(type) {
     return function (setter, ctx) {
         const name = installProperty(type, ctx);
+        void gsetter({ $gtype: inferGTypeFromVariant(type) })(() => { }, ctx);
         return function (value) {
             const { proxy } = this[internals];
             if (proxy) {
@@ -566,11 +532,12 @@ export function setter(type) {
  * Registers a signal which when invoked will emit the signal
  * on the local object and the exported object.
  *
- * Note that its not possible to emit signals on remote objects through proxies.
+ * **Note**: its not possible to emit signals on remote objects through proxies.
  */
 export function signal(...params) {
     return function (method, ctx) {
         const name = installSignal(params, ctx);
+        void gsignal(...params.map(inferGTypeFromVariant))(() => { }, ctx);
         return function (...params) {
             if (this[internals].proxy) {
                 console.warn(`cannot emit signal "${name}" on remote object`);

package/dist/gobject.d.ts

@@ -35,7 +35,9 @@ type PropertyTypeDeclaration<T> = ((name: string, flags: ParamFlags) => ParamSpe
  * }
  * ```
  */
-export declare function property<T>(typeDeclaration: PropertyTypeDeclaration<T>): (_: void, ctx: ClassFieldDecoratorContext<GObj, T>) => (this: GObj, init: T) => T;
+export declare function property<T>(typeDeclaration: PropertyTypeDeclaration<T>): (_: void, ctx: ClassFieldDecoratorContext<GObj, T>, options?: {
+    metaOnly: true;
+}) => (this: GObj, init: T) => T;
 /**
  * Defines a read-only property to be registered when using the {@link register} decorator.
  * If the getter has a setter pair decorated with the {@link setter} decorator the property will be readable *and* writeable.
@@ -121,7 +123,7 @@ export declare function signal<const Params extends Array<{
  */
 export declare function signal<Params extends Array<{
     $gtype: GType;
-} | GType>>(...params: Params): (method: (this: GObj, ...args: ParamTypes<Params>) => void, ctx: ClassMethodDecoratorContext<GObj, typeof method>) => typeof method;
+} | GType>>(...params: Params): (method: (this: GObject.Object, ...args: ParamTypes<Params>) => void, ctx: ClassMethodDecoratorContext<GObj, typeof method>) => typeof method;
 type MetaInfo = GObject.MetaInfo<never, Array<{
     $gtype: GType<unknown>;
 }>, never>;

package/dist/gobject.js

@@ -9,7 +9,8 @@
  * so I'm waiting for a better alternative.
  */
 import GObject from "gi://GObject";
-import { getterWorkaround, kebabify } from "./util.js";
+import GLib from "gi://GLib";
+import { definePropertyGetter, kebabify } from "./util.js";
 const priv = Symbol("gobject private");
 const { defineProperty, fromEntries, entries } = Object;
 const { Object: GObj, registerClass } = GObject;
@@ -40,14 +41,16 @@ function assertField(ctx) {
  * ```
  */
 export function property(typeDeclaration) {
-    return function (_, ctx) {
+    return function (_, ctx, options) {
         const fieldName = assertField(ctx);
         const key = kebabify(fieldName);
         const meta = ctx.metadata;
         meta.properties ?? (meta.properties = {});
         meta.properties[fieldName] = { flags: ParamFlags.READWRITE, type: typeDeclaration };
         ctx.addInitializer(function () {
-            getterWorkaround(this, fieldName);
+            definePropertyGetter(this, fieldName);
+            if (options && options.metaOnly)
+                return;
             defineProperty(this, fieldName, {
                 enumerable: true,
                 configurable: false,
@@ -178,10 +181,48 @@ export function signal(...args) {
         };
     };
 }
-function pspec(name, flags, declaration) {
-    if (declaration === undefined) {
-        throw Error(`undefined ${name}`);
+const MAXINT = 2 ** 31 - 1;
+const MININT = -(2 ** 31);
+const MAXUINT = 2 ** 32 - 1;
+const MAXFLOAT = 3.4028235e38;
+const MINFLOAT = -3.4028235e38;
+const MININT64 = Number.MIN_SAFE_INTEGER;
+const MAXINT64 = Number.MAX_SAFE_INTEGER;
+function pspecFromGType(type, name, flags) {
+    switch (type) {
+        case GObject.TYPE_BOOLEAN:
+            return ParamSpec.boolean(name, "", "", flags, false);
+        case GObject.TYPE_STRING:
+            return ParamSpec.string(name, "", "", flags, "");
+        case GObject.TYPE_INT:
+            return ParamSpec.int(name, "", "", flags, MININT, MAXINT, 0);
+        case GObject.TYPE_UINT:
+            return ParamSpec.uint(name, "", "", flags, 0, MAXUINT, 0);
+        case GObject.TYPE_INT64:
+            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"):
+            return ParamSpec.float(name, "", "", flags, MINFLOAT, MAXFLOAT, 0);
+        case GObject.TYPE_DOUBLE:
+            return ParamSpec.double(name, "", "", flags, Number.MIN_VALUE, Number.MIN_VALUE, 0);
+        case GObject.TYPE_JSOBJECT:
+            return ParamSpec.jsobject(name, "", "", flags);
+        case GObject.TYPE_VARIANT:
+            return ParamSpec.object(name, "", "", flags, GLib.Variant);
+        case GObject.TYPE_ENUM:
+        case GObject.TYPE_INTERFACE:
+        case GObject.TYPE_BOXED:
+        case GObject.TYPE_POINTER:
+        case GObject.TYPE_PARAM:
+        case GObject.type_from_name("GType"):
+            throw Error(`cannot guess ParamSpec from GType "${type}"`);
+        case GObject.TYPE_OBJECT:
+        default:
+            return ParamSpec.object(name, "", "", flags, type);
     }
+}
+function pspec(name, flags, declaration) {
     if (declaration instanceof ParamSpec)
         return declaration;
     if (declaration === Object || declaration === Function || declaration === Array) {
@@ -197,7 +238,7 @@ function pspec(name, flags, declaration) {
         return ParamSpec.boolean(name, "", "", flags, false);
     }
     if ("$gtype" in declaration) {
-        return ParamSpec.object(name, "", "", flags, declaration.$gtype);
+        return pspecFromGType(declaration.$gtype, name, flags);
     }
     if (typeof declaration === "function") {
         return declaration(name, flags);

package/dist/jsx/index.d.ts

@@ -4,4 +4,4 @@ export { For } from "./For.js";
 export { With } from "./With.js";
 export { This } from "./This.js";
 export { createRoot, getScope, onCleanup, onMount, createContext } from "./scope.js";
-export { type Accessed, type State, type Setter, Accessor, createState, createComputed, createBinding, createConnection, createExternal, } from "./state.js";
+export { type Accessed, type State, type Setter, Accessor, createState, createComputed, createBinding, createConnection, createExternal, createSettings, } from "./state.js";

package/dist/jsx/index.js

@@ -4,4 +4,4 @@ export { For } from "./For.js";
 export { With } from "./With.js";
 export { This } from "./This.js";
 export { createRoot, getScope, onCleanup, onMount, createContext } from "./scope.js";
-export { Accessor, createState, createComputed, createBinding, createConnection, createExternal, } from "./state.js";
+export { Accessor, createState, createComputed, createBinding, createConnection, createExternal, createSettings, } from "./state.js";

package/dist/jsx/jsx.d.ts

@@ -57,7 +57,7 @@ export type CCProps<Self extends GObject.Object, Props> = {
      */
     css?: string | Accessor<string>;
 } & {
-    [K in keyof Props]?: Accessor<NonNullable<Props[K]>> | Props[K];
+    [K in keyof Props]: Accessor<NonNullable<Props[K]>> | Props[K];
 } & {
     [S in keyof Self["$signals"] as S extends `notify::${infer P}` ? `onNotify${Pascalify<P>}` : S extends string ? `on${Pascalify<S>}` : never]?: GObject.SignalCallback<Self, Self["$signals"][S]>;
 };

package/dist/jsx/state.d.ts

@@ -1,15 +1,17 @@
 import GObject from "gi://GObject";
 import Gio from "gi://Gio";
+import { type Pascalify } from "../util.js";
+import { type InferVariantRec, type InferVariant } from "../variant.js";
 type SubscribeCallback = () => void;
 type DisposeFunction = () => void;
-type SubscrubeFunction = (callback: SubscribeCallback) => DisposeFunction;
+type SubscribeFunction = (callback: SubscribeCallback) => DisposeFunction;
 export type Accessed<T> = T extends Accessor<infer V> ? V : never;
 export declare class Accessor<T = unknown> extends Function {
     #private;
     static $gtype: GObject.GType<Accessor>;
     /** @experimental */
     static evaluating?: Set<Accessor<unknown>>;
-    constructor(get: () => T, subscribe?: SubscrubeFunction);
+    constructor(get: () => T, subscribe?: SubscribeFunction);
     /**
      * Subscribe for value changes.
      * @param callback The function to run when the current value changes.
@@ -49,16 +51,15 @@ export type State<T> = [Accessor<T>, Setter<T>];
  */
 export declare function createState<T>(init: T): State<T>;
 /**
+ * Create an `Accessor` which is computed from a list of `Accessor`s.
+ *
  * ```ts Example
  * let a: Accessor<number>
  * let b: Accessor<string>
- *
  * const c: Accessor<[number, string]> = createComputed([a, b])
- *
  * const d: Accessor<string> = createComputed([a, b], (a: number, b: string) => `${a} ${b}`)
  * ```
  *
- * Create an `Accessor` which is computed from a list of `Accessor`s.
  * @param deps List of `Accessors`.
  * @param transform An optional transform function.
  * @returns The computed `Accessor`.
@@ -83,6 +84,8 @@ export declare function createBinding<T extends GObject.Object, P extends keyof
 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;
 /**
+ * Create an `Accessor` which sets up a list of `GObject.Object` signal connections.
+ *
  * ```ts Example
  * const value: Accessor<string> = createConnection(
  *   "initial value",
@@ -91,7 +94,6 @@ type ConnectionHandler<O extends GObject.Object, S extends keyof O["$signals"],
  * )
  * ```
  *
- * Create an `Accessor` which sets up a list of `GObject.Object` signal connections.
  * @param init The initial value
  * @param signals A list of `GObject.Object`, signal name and callback pairs to connect.
  */
@@ -114,4 +116,34 @@ 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>;
+/** @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 `set${Pascalify<K>}`]: Setter<InferVariant<T[K]>>;
+};
+/**
+ * @experimental
+ *
+ * Wrap a {@link Gio.Settings} into a collection of setters and accessors.
+ *
+ * Example:
+ *
+ * ```ts
+ * const s = createSettings(settings, {
+ *   "complex-key": "a{sa{ss}}",
+ *   "simple-key": "s",
+ * })
+ *
+ * s.complexKey.subscribe(() => {
+ *   print(s.complexKey.get())
+ * })
+ *
+ * s.setComplexKey((prev) => ({
+ *   ...prev,
+ *   key: { nested: "" },
+ * }))
+ * ```
+ */
+export declare function createSettings<const T extends Record<string, string>>(settings: Gio.Settings, keys: T): Settings<T>;
 export {};

package/dist/jsx/state.js

@@ -12,7 +12,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Accessor_get, _Accessor_subscribe;
 import GObject from "gi://GObject";
 import Gio from "gi://Gio";
-import { kebabify } from "../util";
+import GLib from "gi://GLib";
+import { camelify, kebabify } from "../util.js";
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Accessor extends Function {
     constructor(get, subscribe) {
@@ -79,16 +80,15 @@ export function createState(init) {
     return [new Accessor(() => currentValue, subscribe), set];
 }
 /**
+ * Create an `Accessor` which is computed from a list of `Accessor`s.
+ *
  * ```ts Example
  * let a: Accessor<number>
  * let b: Accessor<string>
- *
  * const c: Accessor<[number, string]> = createComputed([a, b])
- *
  * const d: Accessor<string> = createComputed([a, b], (a: number, b: string) => `${a} ${b}`)
  * ```
  *
- * Create an `Accessor` which is computed from a list of `Accessor`s.
  * @param deps List of `Accessors`.
  * @param transform An optional transform function.
  * @returns The computed `Accessor`.
@@ -154,6 +154,8 @@ export function createBinding(object, key) {
     return new Accessor(get, subscribe);
 }
 /**
+ * Create an `Accessor` which sets up a list of `GObject.Object` signal connections.
+ *
  * ```ts Example
  * const value: Accessor<string> = createConnection(
  *   "initial value",
@@ -162,7 +164,6 @@ export function createBinding(object, key) {
  * )
  * ```
  *
- * Create an `Accessor` which sets up a list of `GObject.Object` signal connections.
  * @param init The initial value
  * @param signals A list of `GObject.Object`, signal name and callback pairs to connect.
  */
@@ -236,3 +237,46 @@ export function createExternal(init, producer) {
     };
     return new Accessor(() => currentValue, subscribe);
 }
+/**
+ * @experimental
+ *
+ * Wrap a {@link Gio.Settings} into a collection of setters and accessors.
+ *
+ * Example:
+ *
+ * ```ts
+ * const s = createSettings(settings, {
+ *   "complex-key": "a{sa{ss}}",
+ *   "simple-key": "s",
+ * })
+ *
+ * s.complexKey.subscribe(() => {
+ *   print(s.complexKey.get())
+ * })
+ *
+ * s.setComplexKey((prev) => ({
+ *   ...prev,
+ *   key: { nested: "" },
+ * }))
+ * ```
+ */
+// TODO: come up with an API
+// - to manually annotate Variant typed setters/getters
+// - to set recursive vs deep unpack per key
+export function createSettings(settings, keys) {
+    return Object.fromEntries(Object.entries(keys).flatMap(([key, type]) => [
+        [
+            camelify(key),
+            new Accessor(() => settings.get_value(key).recursiveUnpack(), (callback) => {
+                const id = settings.connect(`changed::${key}`, callback);
+                return () => settings.disconnect(id);
+            }),
+        ],
+        [
+            `set${key[0].toUpperCase() + camelify(key).slice(1)}`,
+            (v) => {
+                settings.set_value(key, new GLib.Variant(type, typeof v === "function" ? v(settings.get_value(key).deepUnpack()) : v));
+            },
+        ],
+    ]));
+}

package/dist/util.d.ts

@@ -1,12 +1,13 @@
 import type GObject from "gi://GObject";
 export declare function kebabify(str: string): string;
-export type Pascalify<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Capitalize<Head>}${Pascalify<Tail>}` : Capitalize<S>;
 export declare function snakeify(str: string): string;
+export declare function camelify(str: string): string;
+export type Pascalify<S> = S extends `${infer Head}${"-" | "_"}${infer Tail}` ? `${Capitalize<Head>}${Pascalify<Tail>}` : S extends string ? Capitalize<S> : never;
 export type XmlNode = {
     name: string;
     attributes?: Record<string, string>;
     children?: Array<XmlNode>;
 };
 export declare function xml({ name, attributes, children }: XmlNode): string;
-export declare function getterWorkaround<T extends object>(object: T, prop: Extract<keyof T, string>): void;
+export declare function definePropertyGetter<T extends object>(object: T, prop: Extract<keyof T, string>): void;
 export declare function set(obj: GObject.Object, prop: string, value: any): void;

package/dist/util.js

@@ -10,6 +10,9 @@ export function snakeify(str) {
         .replaceAll("-", "_")
         .toLowerCase();
 }
+export function camelify(str) {
+    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
+}
 export function xml({ name, attributes, children }) {
     let builder = `<${name}`;
     const attrs = Object.entries(attributes ?? []);
@@ -33,8 +36,8 @@ export function xml({ name, attributes, children }) {
 // Bindings work over properties in kebab-case because thats the convention of gobject
 // however in js its either snake_case or camelCase
 // also on DBus interfaces its PascalCase by convention
-// so as a workaround we use get_property_name as a workaround
-export function getterWorkaround(object, prop) {
+// so as a workaround we use get_property_name and only use the property field as a fallback
+export function definePropertyGetter(object, prop) {
     Object.defineProperty(object, `get_${kebabify(prop).replaceAll("-", "_")}`, {
         configurable: false,
         enumerable: true,

package/dist/variant.d.ts

@@ -0,0 +1,77 @@
+import type GLib from "gi://GLib";
+type Variant<S extends string = any> = GLib.Variant<S>;
+type CreateIndexType<Key extends string, Value> = Key extends `s` | `o` | `g` ? {
+    [key: string]: Value;
+} : Key extends `n` | `q` | `t` | `d` | `u` | `i` | `x` | `y` ? {
+    [key: number]: Value;
+} : never;
+type VariantTypeError<T extends string> = {
+    error: true;
+} & T;
+/**
+ * Handles the {kv} of a{kv} where k is a basic type and v is any possible variant type string.
+ */
+type $ParseDeepVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseDeepVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Value>, State] : VariantTypeError<`$ParseDeepVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseDeepVariantDict encountered an invalid variant string: ${State} (2)`>;
+/**
+ * Handles parsing values within a tuple (e.g. (vvv)) where v is any possible variant type string.
+ */
+type $ParseDeepVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseDeepVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseDeepVariantArray<State, [...Memo, Value]> : State extends `)${infer State}` ? [[...Memo, Value], State] : VariantTypeError<`1: $ParseDeepVariantArray encountered an invalid variant string: ${State}`> : VariantTypeError<`2: $ParseDeepVariantValue returned unexpected value for: ${State}`>;
+/**
+ * Handles parsing {kv} without an 'a' prefix (key-value pair) where k is a basic type
+ * and v is any possible variant type string.
+ */
+type $ParseDeepVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseDeepVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, $ParseVariant<Key>, Value], State] : VariantTypeError<`$ParseDeepVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseDeepVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
+/**
+ * Handles parsing any variant 'value' or base unit.
+ *
+ * - ay - Array of bytes (Uint8Array)
+ * - a* - Array of type *
+ * - a{k*} - Dictionary
+ * - {k*} - KeyValue
+ * - (**) - tuple
+ * - s | o | g - string types
+ * - n | q | t | d | u | i | x | y - number types
+ * - b - boolean type
+ * - v - unknown Variant type
+ * - h | ? - unknown types
+ */
+type $ParseDeepVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [Variant, State] : State extends `${'h' | '?'}${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseDeepVariantArray<State> : State extends `a{${infer State}` ? $ParseDeepVariantDict<State> : State extends `{${infer State}` ? $ParseDeepVariantKeyValue<State> : State extends `ay${infer State}` ? [
+    Uint8Array,
+    State
+] : State extends `m${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? [
+    Value[],
+    State
+] : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (2)`>;
+type $ParseDeepVariant<T extends string> = $ParseDeepVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : VariantTypeError<"$ParseDeepVariantValue returned unexpected Result"> : VariantTypeError<"$ParseDeepVariantValue returned uninferrable Result">;
+type $ParseRecursiveVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseRecursiveVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Value>, State] : VariantTypeError<`$ParseRecursiveVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseRecursiveVariantDict encountered an invalid variant string: ${State} (2)`>;
+type $ParseRecursiveVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseRecursiveVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseRecursiveVariantArray<State, [...Memo, Value]> : State extends `)${infer State}` ? [[...Memo, Value], State] : VariantTypeError<`$ParseRecursiveVariantArray encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue returned unexpected value for: ${State} (2)`>;
+type $ParseRecursiveVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseRecursiveVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, Key, Value], State] : VariantTypeError<`$ParseRecursiveVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseRecursiveVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
+type $ParseRecursiveVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [unknown, State] : State extends `${'h' | '?'}${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseRecursiveVariantArray<State> : State extends `a{${infer State}` ? $ParseRecursiveVariantDict<State> : State extends `{${infer State}` ? $ParseRecursiveVariantKeyValue<State> : State extends `ay${infer State}` ? [
+    Uint8Array,
+    State
+] : State extends `m${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? [
+    Value[],
+    State
+] : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (2)`>;
+type $ParseRecursiveVariant<T extends string> = $ParseRecursiveVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : never : never;
+type $ParseVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Variant<Value extends string ? Value : any>>, State] : VariantTypeError<`$ParseVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseVariantDict encountered an invalid variant string: ${State} (2)`>;
+type $ParseVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseVariantArray<State, [...Memo, Variant<Value extends string ? Value : any>]> : State extends `)${infer State}` ? [[...Memo, Variant<Value extends string ? Value : any>], State] : VariantTypeError<`$ParseVariantArray encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue returned unexpected value for: ${State} (2)`>;
+type $ParseVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, Variant<Key>, Variant<Value extends string ? Value : any>], State] : VariantTypeError<`$ParseVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
+type $ParseShallowRootVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [Variant, State] : State extends `h${infer State}` ? [unknown, State] : State extends `?${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseVariantArray<State> : State extends `a{${infer State}` ? $ParseVariantDict<State> : State extends `{${infer State}` ? $ParseVariantKeyValue<State> : State extends `ay${infer State}` ? [
+    Uint8Array,
+    State
+] : State extends `m${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseShallowRootVariantValue encountered an invalid variant string: ${State} (2)`> : State extends `a${infer State}` ? [
+    Variant<State>[],
+    State
+] : VariantTypeError<`$ParseShallowRootVariantValue encountered an invalid variant string: ${State} (1)`>;
+type $ParseVariantValue<State extends string> = string extends State ? unknown : State extends `s${infer State}` ? ['s', State] : State extends `o${infer State}` ? ['o', State] : State extends `g${infer State}` ? ['g', State] : State extends `n${infer State}` ? ["n", State] : State extends `q${infer State}` ? ["q", State] : State extends `t${infer State}` ? ["t", State] : State extends `d${infer State}` ? ["d", State] : State extends `u${infer State}` ? ["u", State] : State extends `i${infer State}` ? ["i", State] : State extends `x${infer State}` ? ["x", State] : State extends `y${infer State}` ? ["y", State] : State extends `b${infer State}` ? ['b', State] : State extends `v${infer State}` ? ['v', State] : State extends `h${infer State}` ? ['h', State] : State extends `?${infer State}` ? ['?', State] : State extends `(${infer State}` ? $ParseVariantArray<State> : State extends `a{${infer State}` ? $ParseVariantDict<State> : State extends `{${infer State}` ? $ParseVariantKeyValue<State> : State extends `ay${infer State}` ? [
+    Uint8Array,
+    State
+] : State extends `m${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [
+    Value[],
+    State
+] : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (2)`>;
+type $ParseVariant<T extends string> = $ParseShallowRootVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : never : never;
+export type InferVariant<S extends string> = $ParseDeepVariant<S>;
+export type InferVariantRec<S extends string> = $ParseRecursiveVariant<S>;
+export {};

package/dist/variant.js

@@ -0,0 +1,4 @@
+// See: https://github.com/gjsify/ts-for-gir/issues/270
+//
+// Source: https://github.com/gjsify/ts-for-gir/blob/e1bfc49d233b4f13d4a3b342d5fc636532c4f352/packages/lib/src/generators/dts/glib.ts
+export {};

package/package.json

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