gnim 1.6.3 → 1.6.5

package/dist/dbus.ts

@@ -8,6 +8,7 @@ import Gio from "gi://Gio"
 import GLib from "gi://GLib"
 import GObject from "gi://GObject"
 import { definePropertyGetter, kebabify, xml } from "./util.js"
+import type { DeepInfer } from "./variant.js"
 import {
     register,
     property as gproperty,
@@ -27,7 +28,6 @@ const remoteMethod = Symbol("proxy remoteMethod")
 const remoteMethodAsync = Symbol("proxy remoteMethodAsync")
 const remotePropertySet = Symbol("proxy remotePropertySet")
 
-type DeepInfer<S extends string> = ReturnType<GLib.Variant<S>["deepUnpack"]>
 type Ctx = { private: false; static: false; name: string }
 
 /**

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

@@ -2,14 +2,12 @@ import GObject from "gi://GObject"
 import Gio from "gi://Gio"
 import GLib from "gi://GLib"
 import { type Pascalify, camelify, kebabify } from "../util.js"
+import type { DeepInfer, RecursiveInfer } from "../variant.js"
 
 type SubscribeCallback = () => void
 type DisposeFunction = () => void
 type SubscribeFunction = (callback: SubscribeCallback) => DisposeFunction
 
-type DeepInfer<S extends string> = ReturnType<GLib.Variant<S>["deepUnpack"]>
-type RecursiveInfer<S extends string> = ReturnType<GLib.Variant<S>["recursiveUnpack"]>
-
 export type Accessed<T> = T extends Accessor<infer V> ? V : never
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
@@ -110,7 +108,7 @@ 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
+    let value: typeof empty | T = empty
     let prevDeps = new Map<Accessor, DisposeFunction>()
 
     const effect = () => {

package/dist/variant.ts

@@ -0,0 +1,348 @@
+// See: https://github.com/gjsify/ts-for-gir/issues/286
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import type GLib from "gi://GLib"
+
+type Variant<S extends string = any> = GLib.Variant<S>
+
+// prettier-ignore
+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.
+ */
+// prettier-ignore
+type $ParseDeepVariantDict<State extends string, Memo extends Record<string, any> = {}> =
+    string extends State
+    ? VariantTypeError<"$ParseDeepVariantDict: 'string' is not a supported type.">
+    // Hitting the first '}' indicates the dictionary type is complete
+    : State extends `}${infer State}`
+    ? [Memo, State]
+    // This separates the key (basic type) from the rest of the remaining expression.
+    : 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.
+ */
+// prettier-ignore
+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.
+ */
+// prettier-ignore
+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
+ */
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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">;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+type $ParseRecursiveVariant<T extends string> =
+    $ParseRecursiveVariantValue<T> extends infer Result
+    ? Result extends [infer Value, string]
+    ? Value
+    : Result extends VariantTypeError<any>
+    ? Result
+    : never
+    : never;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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)`>;
+
+// prettier-ignore
+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 Infer<S extends string> = $ParseVariant<S>
+export type DeepInfer<S extends string> = $ParseDeepVariant<S>
+export type RecursiveInfer<S extends string> = $ParseRecursiveVariant<S>

package/package.json

@@ -1,75 +1,79 @@
 {
-    "name": "gnim",
-    "version": "1.6.3",
-    "type": "module",
-    "author": "Aylur",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Aylur/gnim.git"
-    },
-    "funding": {
-        "type": "kofi",
-        "url": "https://ko-fi.com/aylur"
-    },
-    "scripts": {
-        "build": "./scripts/build.sh",
-        "lint": "eslint . --fix",
-        "docs:dev": "vitepress dev docs",
-        "docs:build": "vitepress build docs",
-        "docs:preview": "vitepress preview docs"
-    },
-    "devDependencies": {
-        "@girs/adw-1": "latest",
-        "@girs/clutter-16": "latest",
-        "@girs/gtk-3.0": "latest",
-        "@girs/soup-3.0": "latest",
-        "@girs/st-16": "latest",
-        "@girs/gnome-shell": "latest",
-        "esbuild": "latest",
-        "eslint": "latest",
-        "typescript": "latest",
-        "typescript-eslint": "latest",
-        "vitepress": "latest"
-    },
-    "exports": {
-        ".": "./dist/index.ts",
-        "./dbus": "./dist/dbus.ts",
-        "./fetch": "./dist/fetch.ts",
-        "./gobject": "./dist/gobject.ts",
-        "./resource": "./dist/resource/resource.ts",
-        "./gnome/jsx-runtime": "./dist/gnome/jsx-runtime.ts",
-        "./gtk3/jsx-runtime": "./dist/gtk3/jsx-runtime.ts",
-        "./gtk4/jsx-runtime": "./dist/gtk4/jsx-runtime.ts"
-    },
-    "files": [
-        "dist"
-    ],
-    "engines": {
-        "gjs": ">=1.79.0"
-    },
-    "keywords": [
-        "GJS",
-        "Gnome",
-        "GTK",
-        "JSX"
-    ],
-    "prettier": {
-        "semi": false,
-        "tabWidth": 4,
-        "quoteProps": "consistent",
-        "trailingComma": "all",
-        "printWidth": 100,
-        "experimentalTernaries": false,
-        "overrides": [
-            {
-                "files": "**/*.md",
-                "options": {
-                    "tabWidth": 2,
-                    "printWidth": 80,
-                    "proseWrap": "always"
-                }
-            }
-        ]
-    }
-}
+  "name": "gnim",
+  "version": "1.6.5",
+  "type": "module",
+  "author": "Aylur",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Aylur/gnim.git"
+  },
+  "funding": {
+    "type": "kofi",
+    "url": "https://ko-fi.com/aylur"
+  },
+  "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",
+    "typescript-eslint": "latest",
+    "vitepress": "latest"
+  },
+  "exports": {
+    ".": "./dist/index.ts",
+    "./dbus": "./dist/dbus.ts",
+    "./fetch": "./dist/fetch.ts",
+    "./gobject": "./dist/gobject.ts",
+    "./resource": "./dist/resource/resource.ts",
+    "./gnome/jsx-runtime": "./dist/gnome/jsx-runtime.ts",
+    "./gtk3/jsx-runtime": "./dist/gtk3/jsx-runtime.ts",
+    "./gtk4/jsx-runtime": "./dist/gtk4/jsx-runtime.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "gjs": ">=1.79.0"
+  },
+  "keywords": [
+    "GJS",
+    "Gnome",
+    "GTK",
+    "JSX"
+  ],
+  "prettier": {
+    "semi": false,
+    "tabWidth": 4,
+    "quoteProps": "consistent",
+    "trailingComma": "all",
+    "printWidth": 100,
+    "experimentalTernaries": false,
+    "overrides": [
+      {
+        "files": "**/*.md",
+        "options": {
+          "tabWidth": 2,
+          "printWidth": 80,
+          "proseWrap": "always"
+        }
+      }
+    ]
+  },
+  "scripts": {
+    "build": "./scripts/build.sh",
+    "lint": "eslint . --fix",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  }
+}