gnim 1.0.0

package/dist/jsx/scope.d.ts

@@ -0,0 +1,99 @@
+export declare class Scope {
+    static current: Scope | null;
+    parent?: Scope | null;
+    context?: any;
+    private cleanups;
+    private mounts;
+    private mounted;
+    constructor(parent: Scope | null);
+    onCleanup(callback: () => void): void;
+    onMount(callback: () => void): void;
+    run<T>(fn: () => T): T;
+    dispose(): void;
+}
+export type Context<T = any> = {
+    use(): T;
+    provide<R>(value: T, fn: () => R): R;
+    (props: {
+        value: T;
+        children: () => JSX.Element;
+    }): JSX.Element;
+};
+/**
+ * Example Usage:
+ * ```tsx
+ * const MyContext = createContext("fallback-value")
+ *
+ * function ConsumerComponent() {
+ *   const value = MyContext.use()
+ *
+ *   return <Gtk.Label label={value} />
+ * }
+ *
+ * function ProviderComponent() {
+ *   return (
+ *     <Gtk.Box>
+ *       <MyContext value="my-value">
+ *         {() => <ConsumerComponent />}
+ *       </MyContext>
+ *     </Gtk.Box>
+ *   )
+ * }
+ * ```
+ */
+export declare function createContext<T>(defaultValue: T): Context<T>;
+/**
+ * Gets the scope that owns the currently running code.
+ *
+ * Example:
+ * ```ts
+ * const scope = getScope()
+ * setTimeout(() => {
+ *   // This callback gets run without an owner scope.
+ *   // Restore owner via scope.run:
+ *   scope.run(() => {
+ *     const foo = FooContext.use()
+ *     onCleanup(() => {
+ *       print("some cleanup")
+ *     })
+ *   })
+ * }, 1000)
+ * ```
+ */
+export declare function getScope(): Scope;
+/**
+ * Attach a cleanup callback to the current {@link Scope}.
+ */
+export declare function onCleanup(cleanup: () => void): void;
+/**
+ * Attach a callback to run when the currently running {@link Scope} returns.
+ */
+export declare function onMount(cleanup: () => void): void;
+/**
+ * Creates a root {@link Scope} that when disposed will remove
+ * any child signal handler or state subscriber.
+ *
+ * Example:
+ * ```tsx
+ * createRoot((dispose) => {
+ *   let root: Gtk.Window
+ *
+ *   const [state] = createState("value")
+ *
+ *   const remove = () => {
+ *     root.destroy()
+ *     dispose()
+ *   }
+ *
+ *   return (
+ *     <Gtk.Window $={(self) => (root = self)}>
+ *       <Gtk.Box>
+ *         <Gtk.Label label={state} />
+ *         <Gtk.Button $clicked={remove} />
+ *       </Gtk.Box>
+ *     </Gtk.Window>
+ *   )
+ * })
+ * ```
+ */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;

package/dist/jsx/scope.js

@@ -0,0 +1,159 @@
+export class Scope {
+    constructor(parent) {
+        this.cleanups = new Set();
+        this.mounts = new Set();
+        this.mounted = false;
+        this.parent = parent;
+    }
+    onCleanup(callback) {
+        this.cleanups?.add(callback);
+    }
+    onMount(callback) {
+        if (this.parent && !this.parent.mounted) {
+            this.parent.onMount(callback);
+        }
+        else {
+            this.mounts.add(callback);
+        }
+    }
+    run(fn) {
+        const prev = Scope.current;
+        Scope.current = this;
+        try {
+            return fn();
+        }
+        finally {
+            this.mounts.forEach((cb) => cb());
+            this.mounts.clear();
+            this.mounted = true;
+            Scope.current = prev;
+        }
+    }
+    dispose() {
+        this.cleanups.forEach((cb) => cb());
+        this.cleanups.clear();
+        delete this.parent;
+        delete this.context;
+    }
+}
+/**
+ * Example Usage:
+ * ```tsx
+ * const MyContext = createContext("fallback-value")
+ *
+ * function ConsumerComponent() {
+ *   const value = MyContext.use()
+ *
+ *   return <Gtk.Label label={value} />
+ * }
+ *
+ * function ProviderComponent() {
+ *   return (
+ *     <Gtk.Box>
+ *       <MyContext value="my-value">
+ *         {() => <ConsumerComponent />}
+ *       </MyContext>
+ *     </Gtk.Box>
+ *   )
+ * }
+ * ```
+ */
+export function createContext(defaultValue) {
+    function provide(value, fn) {
+        const scope = new Scope(Scope.current);
+        onCleanup(() => scope.dispose());
+        scope.context = value;
+        return scope.run(fn);
+    }
+    function use() {
+        let scope = Scope.current;
+        while (scope) {
+            const value = scope.context;
+            if (value)
+                return value;
+            scope = scope.parent ?? null;
+        }
+        return defaultValue;
+    }
+    function context({ value, children }) {
+        return provide(value, children);
+    }
+    return Object.assign(context, {
+        provide,
+        use,
+    });
+}
+/**
+ * Gets the scope that owns the currently running code.
+ *
+ * Example:
+ * ```ts
+ * const scope = getScope()
+ * setTimeout(() => {
+ *   // This callback gets run without an owner scope.
+ *   // Restore owner via scope.run:
+ *   scope.run(() => {
+ *     const foo = FooContext.use()
+ *     onCleanup(() => {
+ *       print("some cleanup")
+ *     })
+ *   })
+ * }, 1000)
+ * ```
+ */
+export function getScope() {
+    const scope = Scope.current;
+    if (!scope) {
+        throw Error("cannot get scope: out of tracking context");
+    }
+    return scope;
+}
+/**
+ * Attach a cleanup callback to the current {@link Scope}.
+ */
+export function onCleanup(cleanup) {
+    if (!Scope.current) {
+        console.error(Error("out of tracking context: will not be able to cleanup"));
+    }
+    Scope.current?.onCleanup(cleanup);
+}
+/**
+ * Attach a callback to run when the currently running {@link Scope} returns.
+ */
+export function onMount(cleanup) {
+    if (!Scope.current) {
+        console.error(Error("cannot attach onMount: out of tracking context"));
+    }
+    Scope.current?.onMount(cleanup);
+}
+/**
+ * Creates a root {@link Scope} that when disposed will remove
+ * any child signal handler or state subscriber.
+ *
+ * Example:
+ * ```tsx
+ * createRoot((dispose) => {
+ *   let root: Gtk.Window
+ *
+ *   const [state] = createState("value")
+ *
+ *   const remove = () => {
+ *     root.destroy()
+ *     dispose()
+ *   }
+ *
+ *   return (
+ *     <Gtk.Window $={(self) => (root = self)}>
+ *       <Gtk.Box>
+ *         <Gtk.Label label={state} />
+ *         <Gtk.Button $clicked={remove} />
+ *       </Gtk.Box>
+ *     </Gtk.Window>
+ *   )
+ * })
+ * ```
+ */
+export function createRoot(fn) {
+    const scope = new Scope(null);
+    return scope.run(() => fn(() => scope.dispose()));
+}

package/dist/jsx/state.d.ts

@@ -0,0 +1,117 @@
+import GObject from "gi://GObject";
+import Gio from "gi://Gio";
+type SubscribeCallback = () => void;
+type DisposeFunction = () => void;
+type SubscrubeFunction = (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);
+    /**
+     * Subscribe for value changes.
+     * @param callback The function to run when the current value changes.
+     * @returns Unsubscribe function.
+     */
+    subscribe(callback: SubscribeCallback): DisposeFunction;
+    /**
+     * @returns The current value.
+     */
+    get(): T;
+    /**
+     * Create a new `Accessor` that applies a transformation on its value.
+     * @param transform The transformation to apply. Should be a pure function.
+     */
+    as<R = T>(transform: (value: T) => R): Accessor<R>;
+    protected _call<R = T>(transform: (value: T) => R): Accessor<R>;
+    toString(): string;
+    [Symbol.toPrimitive](): string;
+}
+export interface Accessor<T> {
+    /**
+     * Create a new `Accessor` that applies a transformation on its value.
+     * @param transform The transformation to apply. Should be a pure function.
+     */
+    <R = T>(transform: (value: T) => R): Accessor<R>;
+}
+export type Setter<T> = {
+    (value: T): void;
+    (value: (prev: T) => T): void;
+};
+export type State<T> = [Accessor<T>, Setter<T>];
+/**
+ * Create a writable signal.
+ *
+ * @param init The intial value of the signal
+ * @returns An `Accessor` and a setter function
+ */
+export declare function createState<T>(init: T): State<T>;
+/**
+ * ```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`.
+ */
+export declare function createComputed<const Deps extends Array<Accessor<any>>, Args extends {
+    [K in keyof Deps]: Accessed<Deps[K]>;
+}, V = Args>(deps: Deps, transform?: (...args: Args) => V): Accessor<V>;
+/**
+ * Create an `Accessor` on a `GObject.Object`'s `property`.
+ *
+ * @param object The `GObject.Object` to create the `Accessor` on.
+ * @param property One of its registered properties.
+ */
+export declare function createBinding<T extends GObject.Object, P extends keyof T>(object: T, property: Extract<P, string>): Accessor<T[P]>;
+/**
+ * Create an `Accessor` on a `Gio.Settings`'s `key`.
+ * Values are recursively unpacked.
+ *
+ * @param object The `Gio.Settings` to create the `Accessor` on.
+ * @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;
+/**
+ * ```ts Example
+ * const value: Accessor<string> = createConnection(
+ *   "initial value",
+ *   [obj1, "sig-name", (...args) => "str"],
+ *   [obj2, "sig-name", (...args) => "str"]
+ * )
+ * ```
+ *
+ * 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.
+ */
+export declare function createConnection<T, O1 extends GObject.Object, S1 extends keyof O1["$signals"], O2 extends GObject.Object, S2 extends keyof O2["$signals"], O3 extends GObject.Object, S3 extends keyof O3["$signals"], O4 extends GObject.Object, S4 extends keyof O4["$signals"], O5 extends GObject.Object, S5 extends keyof O5["$signals"], O6 extends GObject.Object, S6 extends keyof O6["$signals"], O7 extends GObject.Object, S7 extends keyof O7["$signals"], O8 extends GObject.Object, S8 extends keyof O8["$signals"], O9 extends GObject.Object, S9 extends keyof O9["$signals"]>(init: T, h1: [O1, S1, ConnectionHandler<O1, S1, T>], h2?: [O2, S2, ConnectionHandler<O2, S2, T>], h3?: [O3, S3, ConnectionHandler<O3, S3, T>], h4?: [O4, S4, ConnectionHandler<O4, S4, T>], h5?: [O5, S5, ConnectionHandler<O5, S5, T>], h6?: [O6, S6, ConnectionHandler<O6, S6, T>], h7?: [O7, S7, ConnectionHandler<O7, S7, T>], h8?: [O8, S8, ConnectionHandler<O8, S8, T>], h9?: [O9, S9, ConnectionHandler<O9, S9, T>]): Accessor<T>;
+/**
+ * Create a signal from a provier function.
+ * The provider is called when the first subscriber appears and the returned dispose
+ * function from the provider will be called when the number of subscribers drop to zero.
+ *
+ * Example:
+ *
+ * ```ts
+ * const value = createExternal(0, (set) => {
+ *   const interval = setInterval(() => set((v) => v + 1))
+ *   return () => clearInterval(interval)
+ * })
+ * ```
+ *
+ * @param init The initial value
+ * @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>;
+export {};

package/dist/jsx/state.js

@@ -0,0 +1,238 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Accessor_get, _Accessor_subscribe;
+import GObject from "gi://GObject";
+import Gio from "gi://Gio";
+import { kebabify } from "../util";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export class Accessor extends Function {
+    constructor(get, subscribe) {
+        super("return arguments.callee._call.apply(arguments.callee, arguments)");
+        _Accessor_get.set(this, void 0);
+        _Accessor_subscribe.set(this, void 0);
+        __classPrivateFieldSet(this, _Accessor_subscribe, subscribe ?? (() => () => void 0), "f");
+        __classPrivateFieldSet(this, _Accessor_get, get, "f");
+    }
+    /**
+     * Subscribe for value changes.
+     * @param callback The function to run when the current value changes.
+     * @returns Unsubscribe function.
+     */
+    subscribe(callback) {
+        return __classPrivateFieldGet(this, _Accessor_subscribe, "f").call(this, callback);
+    }
+    /**
+     * @returns The current value.
+     */
+    get() {
+        Accessor.evaluating?.add(this);
+        return __classPrivateFieldGet(this, _Accessor_get, "f").call(this);
+    }
+    /**
+     * Create a new `Accessor` that applies a transformation on its value.
+     * @param transform The transformation to apply. Should be a pure function.
+     */
+    as(transform) {
+        return new Accessor(() => transform(__classPrivateFieldGet(this, _Accessor_get, "f").call(this)), __classPrivateFieldGet(this, _Accessor_subscribe, "f"));
+    }
+    _call(transform) {
+        return this.as(transform);
+    }
+    toString() {
+        return `Accessor<${this.get()}>`;
+    }
+    [(_Accessor_get = new WeakMap(), _Accessor_subscribe = new WeakMap(), Symbol.toPrimitive)]() {
+        console.warn("Accessor implicitly converted to a primitive value.");
+        return this.toString();
+    }
+}
+Accessor.$gtype = GObject.TYPE_JSOBJECT;
+/**
+ * Create a writable signal.
+ *
+ * @param init The intial value of the signal
+ * @returns An `Accessor` and a setter function
+ */
+export function createState(init) {
+    let currentValue = init;
+    const subscribers = new Set();
+    const subscribe = (callback) => {
+        subscribers.add(callback);
+        return () => subscribers.delete(callback);
+    };
+    const set = (newValue) => {
+        const value = typeof newValue === "function" ? newValue(currentValue) : newValue;
+        if (currentValue !== value) {
+            currentValue = value;
+            subscribers.forEach((cb) => cb());
+        }
+    };
+    return [new Accessor(() => currentValue, subscribe), set];
+}
+/**
+ * ```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`.
+ */
+export function createComputed(deps, transform) {
+    let dispose;
+    const subscribers = new Set();
+    const cache = new Array(deps.length);
+    const subscribe = (callback) => {
+        if (subscribers.size === 0) {
+            dispose = deps.map((dep, i) => dep.subscribe(() => {
+                const value = dep.get();
+                if (cache[i] !== value) {
+                    cache[i] = dep.get();
+                    subscribers.forEach((cb) => cb());
+                }
+            }));
+        }
+        subscribers.add(callback);
+        return () => {
+            subscribers.delete(callback);
+            if (subscribers.size === 0) {
+                dispose.map((cb) => cb());
+                dispose.length = 0;
+                cache.length = 0;
+            }
+        };
+    };
+    const get = () => {
+        const args = deps.map((dep, i) => {
+            if (!cache[i]) {
+                cache[i] = dep.get();
+            }
+            return cache[i];
+        });
+        return transform ? transform(...args) : args;
+    };
+    return new Accessor(get, subscribe);
+}
+export function createBinding(object, key) {
+    const prop = kebabify(key);
+    const subscribe = (callback) => {
+        const sig = object instanceof Gio.Settings ? "changed" : "notify";
+        const id = object.connect(`${sig}::${prop}`, () => callback());
+        return () => object.disconnect(id);
+    };
+    const get = () => {
+        if (object instanceof Gio.Settings) {
+            return object.get_value(key).recursiveUnpack();
+        }
+        else {
+            const getter = `get_${prop.replaceAll("-", "_")}`;
+            if (getter in object && typeof object[getter] === "function") {
+                return object[getter]();
+            }
+            if (prop in object)
+                return object[prop];
+            if (key in object)
+                return object[key];
+            throw Error(`cannot get property ${key}`);
+        }
+    };
+    return new Accessor(get, subscribe);
+}
+/**
+ * ```ts Example
+ * const value: Accessor<string> = createConnection(
+ *   "initial value",
+ *   [obj1, "sig-name", (...args) => "str"],
+ *   [obj2, "sig-name", (...args) => "str"]
+ * )
+ * ```
+ *
+ * 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.
+ */
+export function createConnection(init, h1, h2, h3, h4, h5, h6, h7, h8, h9) {
+    let value = init;
+    let dispose;
+    const subscribers = new Set();
+    const signals = [h1, h2, h3, h4, h5, h6, h7, h8, h9].filter((h) => h !== undefined);
+    const subscribe = (callback) => {
+        if (subscribers.size === 0) {
+            dispose = signals.map(([object, signal, callback]) => {
+                const id = object.connect(signal, (_, ...args) => {
+                    const newValue = callback(...args);
+                    if (value !== newValue) {
+                        value = newValue;
+                        subscribers.forEach((cb) => cb());
+                    }
+                });
+                return () => object.disconnect(id);
+            });
+        }
+        subscribers.add(callback);
+        return () => {
+            subscribers.delete(callback);
+            if (subscribers.size === 0) {
+                dispose.map((cb) => cb());
+                dispose.length = 0;
+            }
+        };
+    };
+    return new Accessor(() => value, subscribe);
+}
+/**
+ * Create a signal from a provier function.
+ * The provider is called when the first subscriber appears and the returned dispose
+ * function from the provider will be called when the number of subscribers drop to zero.
+ *
+ * Example:
+ *
+ * ```ts
+ * const value = createExternal(0, (set) => {
+ *   const interval = setInterval(() => set((v) => v + 1))
+ *   return () => clearInterval(interval)
+ * })
+ * ```
+ *
+ * @param init The initial value
+ * @param producer The producer function which should return a cleanup function
+ */
+export function createExternal(init, producer) {
+    let currentValue = init;
+    let dispose;
+    const subscribers = new Set();
+    const subscribe = (callback) => {
+        if (subscribers.size === 0) {
+            dispose = producer((v) => {
+                const newValue = typeof v === "function" ? v(currentValue) : v;
+                if (newValue !== currentValue) {
+                    currentValue = newValue;
+                    subscribers.forEach((cb) => cb());
+                }
+            });
+        }
+        subscribers.add(callback);
+        return () => {
+            subscribers.delete(callback);
+            if (subscribers.size === 0) {
+                dispose();
+            }
+        };
+    };
+    return new Accessor(() => currentValue, subscribe);
+}

package/dist/util.d.ts

@@ -0,0 +1,12 @@
+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 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 set(obj: GObject.Object, prop: string, value: any): void;

package/dist/util.js

@@ -0,0 +1,65 @@
+export function kebabify(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replaceAll("_", "-")
+        .toLowerCase();
+}
+export function snakeify(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replaceAll("-", "_")
+        .toLowerCase();
+}
+export function xml({ name, attributes, children }) {
+    let builder = `<${name}`;
+    const attrs = Object.entries(attributes ?? []);
+    if (attrs.length > 0) {
+        for (const [key, value] of attrs) {
+            builder += ` ${key}="${value}"`;
+        }
+    }
+    if (children && children.length > 0) {
+        builder += ">";
+        for (const node of children) {
+            builder += xml(node);
+        }
+        builder += `</${name}>`;
+    }
+    else {
+        builder += " />";
+    }
+    return builder;
+}
+// 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) {
+    Object.defineProperty(object, `get_${kebabify(prop).replaceAll("-", "_")}`, {
+        configurable: false,
+        enumerable: true,
+        value: () => object[prop],
+    });
+}
+// attempt setting a property of GObject.Object
+export function set(obj, prop, value) {
+    const key = snakeify(prop);
+    const getter = `get_${key}`;
+    const setter = `set_${key}`;
+    let current;
+    if (getter in obj && typeof obj[getter] === "function") {
+        current = obj[getter]();
+    }
+    else {
+        current = obj[prop];
+    }
+    if (current !== value) {
+        if (setter in obj && typeof obj[setter] === "function") {
+            ;
+            obj[setter](value);
+        }
+        else {
+            Object.assign(obj, { [prop]: value });
+        }
+    }
+}