node-gtk 2.1.0 → 3.0.0

package/tools/generate-types.js

@@ -589,6 +589,35 @@ function emitMethods(info, nFn, getFn, ctx, ownerName, inherited) {
   return lines
 }
 
+// Virtual functions, emitted as the `virtual_*` override surface that
+// registerClass() wires into the GObject vtable (lib/register-class.js). A
+// subclass overrides a vfunc by defining `virtual_<camelCaseVfuncName>` — e.g.
+// the `size_allocate` vfunc is overridden as `virtual_sizeAllocate`. We emit ALL
+// vfuncs (even invoker-backed ones whose public method is also emitted) so the
+// override surface is explicit and `super.virtual_<name>(...)` chain-up resolves.
+//
+// The signature is modelled exactly like a method's (signature(): IN params,
+// OUT/INOUT folded into a return tuple) because node-gtk marshals a vfunc
+// implementation's out-params from its JS return value (src/callback.cc). The
+// `virtual_` prefix keeps these names distinct from the public invoker method of
+// the same vfunc, so the two never collide (issue #457).
+// LIMITATION: non-primitive OUT params of a vfunc are passed in as objects to be
+// mutated rather than returned; they are surfaced in the return tuple here to
+// match the public-method convention, which is the common (all-primitive) case.
+function emitVFuncs(info, nFn, getFn, ctx, ownerName) {
+  const lines = []
+  for (const v of each(info, nFn, getFn)) {
+    try {
+      const rawName = baseName(v)
+      const name = 'virtual_' + camelCase(rawName)
+      const sig = signature(v, ctx, {})
+      const doc = docBlock(ctx, DocKey.fn(ownerName || '', rawName), '  ', { callable: true, deprecated: isDeprecated(v) })
+      lines.push(`${doc}  ${name}(${sig.params}): ${sig.ret}`)
+    } catch (e) { /* skip unrepresentable vfunc */ }
+  }
+  return lines
+}
+
 function emitProperties(info, nFn, getFn, ctx, inherited, containerName) {
   const lines = []
   const writable = []
@@ -723,6 +752,7 @@ function emitObject(info, ctx) {
   const inherited = collectInheritedMethods(info, ctx)
   const props = emitProperties(info, GI.object_info_get_n_properties, GI.object_info_get_property, ctx, inherited, name)
   const methods = emitMethods(info, GI.object_info_get_n_methods, GI.object_info_get_method, ctx, name, inherited)
+  const vfuncs = emitVFuncs(info, GI.object_info_get_n_vfuncs, GI.object_info_get_vfunc, ctx, name)
   // When the class merges interfaces, declare the signal API in the companion
   // interface (unified across the whole hierarchy) instead of the class body.
   const signals = hasIfaces ? [] : renderSignals(collectSignals(info, ctx), ctx)
@@ -746,7 +776,7 @@ function emitObject(info, ctx) {
   }
 
   const dedup = makeMemberDedup()
-  const body = [...constants, ...props.lines, ...methods, ...signals, ...signalApi].filter(dedup)
+  const body = [...constants, ...props.lines, ...methods, ...vfuncs, ...signals, ...signalApi].filter(dedup)
 
   const out = []
   const ext = parentRef ? ` extends ${parentRef}` : ''
@@ -787,6 +817,13 @@ function emitInterface(info, ctx) {
   const inherited = collectInterfaceInheritedMethods(info, ctx)
   const props = emitProperties(info, GI.interface_info_get_n_properties, GI.interface_info_get_property, ctx, inherited, name)
   const methods = emitMethods(info, GI.interface_info_get_n_methods, GI.interface_info_get_method, ctx, name, inherited)
+  // NOTE: interface vfuncs are intentionally NOT emitted. A class implementing
+  // several interfaces declaration-merges them into its companion interface, and
+  // emitting `virtual_*` members on interfaces that collide across that diamond
+  // (e.g. GTK3's Atk Component/TableCell/Action accessibility stack) produces
+  // TS2320. Overriding an interface vfunc is rare; object (class) vfuncs — which
+  // cover the issue-#457 cases (Widget, GObject lifecycle, LayoutManager) — are
+  // emitted in emitObject() and are unaffected.
 
   const ext = prereqs.length ? ` extends ${prereqs.join(', ')}` : ''
   const dedup = makeMemberDedup()
@@ -946,7 +983,6 @@ const SHIM_STATIC_API = `  export function isLoaded(ns: string, version?: string
   export function prependLibraryPath(path: string): void
   export function listAvailableModules(): Promise<{ name: string, version: string }[]>
   export function registerClass(klass: Function): Function
-  export function startLoop(): void
   export function getGType(value: Function | object | bigint): bigint
   export const System: any`
 
@@ -966,6 +1002,25 @@ function writeShim(outdir, nsVersions) {
   lines.push(`  export function require(ns: string, version?: string): any`)
   lines.push(SHIM_STATIC_API)
   lines.push(`}`)
+
+  // Ambient declarations for the `gi:` ESM import scheme, so
+  // `import Gtk from 'gi:Gtk-4.0'` is typed as the namespace object (the same
+  // type `gi.require('Gtk','4.0')` returns). The versionless `gi:Gtk` alias
+  // resolves to the version generated here. The `gi:*` fallback does NOT make
+  // un-generated namespaces `any` — its default export is typed as an
+  // instruction string, so any use of one is a TypeScript error that names the
+  // fix (a more specific `gi:<Ns>-<v>` declaration above always wins over it).
+  lines.push(``)
+  for (const [ns, version] of nsVersions) {
+    const type = `typeof import('./${ns}-${version}.js')`
+    lines.push(`declare module 'gi:${ns}-${version}' { const ns: ${type}; export default ns }`)
+    lines.push(`declare module 'gi:${ns}' { const ns: ${type}; export default ns }`)
+  }
+  lines.push(`declare module 'gi:*' {`)
+  lines.push(`  const ns: 'node-gtk: no generated types for this gi: namespace. Run: node-gtk generate-types <Namespace>-<version>'`)
+  lines.push(`  export default ns`)
+  lines.push(`}`)
+
   fs.writeFileSync(path.join(outdir, 'node-gtk.d.ts'), lines.join('\n') + '\n')
 }
 
@@ -1007,6 +1062,16 @@ const DEFAULT_OUTDIR = ['node_modules', '.node-gtk-types']
 // Doc comments are pulled from .gir XML; toggled off with --no-docs.
 let DOCS_ENABLED = true
 
+const INSTALL_URL = 'https://github.com/romgrk/node-gtk#installing'
+
+// A missing typelib means the native GI libraries (gtk4, libadwaita, …) aren't
+// installed on this machine. g_irepository_require surfaces that as a "Typelib
+// file for namespace … not found" error — recognize it so we can replace the
+// opaque stack trace with actionable install guidance.
+function isMissingTypelibError(err) {
+  return /Typelib file for namespace/i.test((err && err.message) || '')
+}
+
 const USAGE = `Usage: node-gtk generate-types <Namespace-Version> [...] [options]
 
 Generates TypeScript declarations for the given GObject-Introspection
@@ -1036,7 +1101,19 @@ function run(argv) {
     roots.push(argv[i])
   }
   if (roots.length === 0) { console.error(USAGE); process.exit(1) }
-  generate(roots, outdir)
+  try {
+    generate(roots, outdir)
+  } catch (err) {
+    if (isMissingTypelibError(err)) {
+      console.error(
+        `\nnode-gtk generate-types: ${err.message}\n\n` +
+        `The native GTK / GObject-Introspection libraries (e.g. gtk4, libadwaita)\n` +
+        `don't seem to be installed. Install them for your platform, then retry:\n` +
+        `  ${INSTALL_URL}\n`)
+      process.exit(1)
+    }
+    throw err
+  }
 }
 
 module.exports = { generate, run }

package/tools/list-libraries.js

@@ -0,0 +1,125 @@
+/*
+ * list-libraries.js — list the GObject-Introspection libraries (typelibs)
+ * available on this machine, grouped by namespace with their versions.
+ *
+ * Driven by the CLI: `node-gtk list [filter] [options]`. The names/versions it
+ * prints are exactly what you pass to `require()` / the `gi:` import scheme /
+ * `generate-types` (e.g. `Gtk-4.0`).
+ */
+
+const gi = require('../lib/index.js')
+const GI = gi._GIRepository
+
+// ---------------------------------------------------------------------------
+// data
+// ---------------------------------------------------------------------------
+
+// Compare dotted versions numerically, ascending ("3.0" < "4.0" < "10.0"),
+// falling back to a string compare for non-numeric segments.
+function compareVersions(a, b) {
+  const pa = a.split('.'), pb = b.split('.')
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i] ?? '', y = pb[i] ?? ''
+    const nx = Number(x), ny = Number(y)
+    if (Number.isNaN(nx) || Number.isNaN(ny)) { if (x !== y) return x < y ? -1 : 1 }
+    else if (nx !== ny) return nx - ny
+  }
+  return 0
+}
+
+// Group the flat [{name, version}] from listAvailableModules() into a sorted
+// list of { name, versions } (names A→Z, versions ascending, deduped).
+async function collect(filter) {
+  const modules = await gi.listAvailableModules()
+  const byName = new Map()
+  for (const { name, version } of modules) {
+    if (filter && !name.toLowerCase().includes(filter.toLowerCase())) continue
+    if (!byName.has(name)) byName.set(name, new Set())
+    if (version) byName.get(name).add(version)
+  }
+  return [...byName.entries()]
+    .map(([name, versions]) => ({ name, versions: [...versions].sort(compareVersions) }))
+    .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+// ---------------------------------------------------------------------------
+// output
+// ---------------------------------------------------------------------------
+
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR
+const ansi = (open, close) => (s) => useColor ? `\x1b[${open}m${s}\x1b[${close}m` : s
+const bold = ansi(1, 22)
+const dim = ansi(2, 22)
+const cyan = ansi(36, 39)
+
+function printTable(libs) {
+  if (libs.length === 0) {
+    process.stdout.write(`${dim('No libraries found.')}\n`)
+    return
+  }
+  const width = libs.reduce((w, l) => Math.max(w, l.name.length), 0)
+  for (const { name, versions } of libs)
+    process.stdout.write(`  ${bold(name.padEnd(width))}  ${dim(versions.join(', '))}\n`)
+}
+
+// ---------------------------------------------------------------------------
+// cli — `node-gtk list [filter] [options]`
+// ---------------------------------------------------------------------------
+
+const HELP = `node-gtk list — list the GObject-Introspection libraries available on this machine
+
+Usage:
+  node-gtk list [filter] [options]
+
+Arguments:
+  filter         Only show libraries whose name contains this (case-insensitive)
+
+Options:
+  --json         Output as JSON: [{ "name", "versions": [...] }]
+  -h, --help     Show this help
+
+Examples:
+  node-gtk list
+  node-gtk list gtk
+  node-gtk list --json
+`
+
+function run(argv) {
+  // Don't crash when the output is piped into a reader that closes early
+  // (e.g. `node-gtk list | head`).
+  process.stdout.on('error', (err) => { if (err.code === 'EPIPE') process.exit(0); throw err })
+
+  const opts = { json: false }
+  for (const arg of argv) {
+    if (arg === '-h' || arg === '--help') { process.stdout.write(HELP); return }
+    else if (arg === '--json') opts.json = true
+    else if (arg.startsWith('-')) { process.stderr.write(`node-gtk list: unknown option '${arg}'\n\n${HELP}`); process.exit(1) }
+    else if (opts.filter === undefined) opts.filter = arg
+    else { process.stderr.write(`node-gtk list: unexpected argument '${arg}'\n\n${HELP}`); process.exit(1) }
+  }
+
+  collect(opts.filter).then((libs) => {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(libs, null, 2) + '\n')
+      return
+    }
+
+    const what = opts.filter ? `matching ${JSON.stringify(opts.filter)}` : 'available'
+    process.stdout.write(`\n${bold(`${libs.length}`)} ${libs.length === 1 ? 'library' : 'libraries'} ${what}:\n\n`)
+    printTable(libs)
+
+    if (libs.length) {
+      const first = libs.find(l => l.versions.length) || libs[0]
+      const example = first.versions.length ? `${first.name}-${first.versions[first.versions.length - 1]}` : first.name
+      process.stdout.write(`\n${dim('Use one with, e.g.:')}  ${cyan(`node-gtk generate-types ${example}`)}\n\n`)
+    } else {
+      const paths = (GI.Repository_get_search_path() || [])
+      process.stdout.write(`\n${dim('Searched: ' + paths.join(', '))}\n`)
+    }
+  }).catch((err) => {
+    process.stderr.write(`node-gtk list: ${err.message}\n`)
+    process.exit(1)
+  })
+}
+
+module.exports = { run, collect, compareVersions }

package/tools/templates/app/README.md.tmpl

@@ -0,0 +1,97 @@
+# __APP_NAME__
+
+An [Adwaita](https://gnome.pages.gitlab.gnome.org/libadwaita/) application built
+with [node-gtk](https://github.com/romgrk/node-gtk) and TypeScript.
+
+## Prerequisites
+
+You need GTK 4 and libadwaita — plus their GObject-Introspection data — installed
+on your system. node-gtk talks to the libraries you actually have installed.
+
+- **Fedora:** `sudo dnf install gtk4-devel libadwaita-devel gobject-introspection-devel`
+- **Debian/Ubuntu:** `sudo apt install libgtk-4-dev libadwaita-1-dev gobject-introspection`
+- **Arch:** `sudo pacman -S gtk4 libadwaita gobject-introspection`
+- **macOS (Homebrew):** `brew install gtk4 libadwaita gobject-introspection`
+
+The `-dev`/`-devel` packages also ship the `.gir` files used to embed GNOME's API
+documentation into the generated TypeScript types (shown on hover in your editor).
+
+You also need **Node.js ≥ 20.6** (for the `gi:` import hooks).
+
+## Getting started
+
+```sh
+npm install        # installs deps and generates TypeScript types (postinstall)
+npm run dev        # run the app with live reload
+```
+
+That's it — a window should appear. Edit `style.css` while it runs and the
+window restyles instantly, no restart. To also restart the app when you edit
+`src/`, run `npm run dev:app-reload` instead (it adds `node --watch`).
+
+## How it works
+
+Namespaces are imported with the `gi:` scheme, and their default export is the
+namespace object:
+
+```ts
+import Gtk from 'gi:Gtk-4.0'
+import Adw from 'gi:Adw-1'
+```
+
+For those imports to resolve, node-gtk's loader hooks must be installed, which is
+why the app is run with `node --import node-gtk/register`. The `dev`/`start`
+scripts already include this (along with `tsx`, which runs the TypeScript without
+a separate build step). node-gtk integrates the GTK main loop with Node's event
+loop automatically.
+
+## Scripts
+
+| command                  | what it does                                                       |
+| ------------------------ | ----------------------------------------------------------------- |
+| `npm run dev`            | Run with live CSS reload — edit `style.css`, the window restyles, no restart. |
+| `npm run dev:app-reload` | Like `dev`, but also restarts the app when you edit `src/` (`node --watch`). |
+| `npm start`              | Run once without building.                                        |
+| `npm run build`     | Type-check and compile `src/` to `dist/` with `tsc`.             |
+| `npm run typecheck` | Type-check only, no output.                                      |
+| `npm run generate-types` | (Re)generate TypeScript types for the GI namespaces you use. |
+
+## TypeScript types
+
+Types are generated **on your machine** from the GObject-Introspection typelibs
+you have installed, so they match your actual library versions and node-gtk's
+runtime shape (camelCase methods, typed signals, nullability, …). They live in
+`node_modules/.node-gtk-types/` (git-ignored) and `tsconfig.json` points at them.
+
+The `postinstall` script regenerates them automatically. If you start using
+another library, add it to the `generate-types` script in `package.json` and
+re-run it:
+
+```jsonc
+// package.json
+"generate-types": "node-gtk generate-types Gtk-4.0 Adw-1 GtkSource-5"
+```
+
+```sh
+npm run generate-types
+```
+
+## Project structure
+
+```
+.
+├── src/
+│   ├── main.ts        # the application entry point
+│   └── welcome.ts     # a component with its own inline, hot-reloadable styles
+├── style.css          # custom CSS (hot-reloads live under `npm run dev`)
+├── tsconfig.json
+└── package.json
+```
+
+## Learn more
+
+- [node-gtk](https://github.com/romgrk/node-gtk) — the bindings
+- [Importing libraries](https://github.com/romgrk/node-gtk/blob/master/doc/importing.md) — the `gi:` scheme and ESM details
+- [GTK 4 API reference](https://docs.gtk.org/gtk4/)
+- [libadwaita API reference](https://gnome.pages.gitlab.gnome.org/libadwaita/doc/)
+- [Adwaita style classes](https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html)

package/tools/templates/app/gitignore.tmpl

@@ -0,0 +1,10 @@
+# dependencies (also holds the generated .node-gtk-types/ TypeScript types,
+# which are regenerated on install — never commit them)
+node_modules/
+
+# build output
+dist/
+
+# misc
+*.log
+.DS_Store

package/tools/templates/app/package.json.tmpl

@@ -0,0 +1,26 @@
+{
+  "name": "__PKG_NAME__",
+  "version": "0.1.0",
+  "description": "An Adwaita application built with node-gtk.",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "npm run dev:css-reload",
+    "dev:css-reload": "cross-env NODE_ENV=development node --import tsx --import node-gtk/register src/main.ts",
+    "dev:app-reload": "cross-env NODE_ENV=development node --import tsx --import node-gtk/register --watch src/main.ts",
+    "start": "node --import tsx --import node-gtk/register src/main.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "generate-types": "node-gtk generate-types Gtk-4.0 Adw-1",
+    "postinstall": "npm run generate-types"
+  },
+  "dependencies": {
+    "node-gtk": "__NODE_GTK_VERSION__"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "cross-env": "^7.0.3",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}

package/tools/templates/app/src/main.ts.tmpl

@@ -0,0 +1,110 @@
+/*
+ * __APP_NAME__ — an Adwaita application built with node-gtk.
+ *
+ * Namespaces are imported with the `gi:` scheme (`import Gtk from 'gi:Gtk-4.0'`);
+ * the app is run with `node --import node-gtk/register …` (see the package.json
+ * scripts). node-gtk integrates the GTK main loop with Node's event loop
+ * automatically — there's nothing to call to enable it.
+ *
+ * One ESM caveat: the blocking run call (`loop.run()` / `app.run()`) RETURNS
+ * IMMEDIATELY instead of blocking. So `app.run()` is the last statement and we
+ * tear everything down from the window's close handler / quit action.
+ * See: https://github.com/romgrk/node-gtk/blob/master/doc/importing.md
+ */
+import GLib from 'gi:GLib-2.0'
+import Gio from 'gi:Gio-2.0'
+import Gtk from 'gi:Gtk-4.0'
+import Adw from 'gi:Adw-1'
+
+import { styles } from 'node-gtk/styles'
+
+// A component in its own module (note the `.js` specifier — TypeScript's NodeNext
+// resolution wants the compiled extension even though the file is welcome.ts).
+import { createWelcome } from './welcome.js'
+
+const APP_ID = '__APP_ID__'
+
+const loop = GLib.MainLoop.new(null, false)
+const app = new Adw.Application({ applicationId: APP_ID, flags: Gio.ApplicationFlags.FLAGS_NONE })
+
+app.on('activate', () => {
+  // Apply style.css, layered on top of Adwaita. Under `npm run dev` the file is
+  // re-read live as you edit it — no restart, no flash. style.css sits at the
+  // project root, one level up from both src/ (dev, via tsx) and dist/ (built,
+  // via node), so this URL resolves in either case.
+  styles.addFile(new URL('../style.css', import.meta.url))
+
+  const window = new Adw.ApplicationWindow({ application: app })
+  window.setTitle('__APP_NAME__')
+  window.setDefaultSize(640, 520)
+
+  // ---- header bar with a primary menu ----------------------------------
+  const header = new Adw.HeaderBar()
+
+  const menu = new Gio.Menu()
+  menu.append('About __APP_NAME__', 'app.about')
+  menu.append('Quit', 'app.quit')
+
+  const menuButton = new Gtk.MenuButton({
+    iconName: 'open-menu-symbolic',
+    menuModel: menu,
+    primary: true,
+  })
+  header.packEnd(menuButton)
+
+  // ---- content: a welcome screen ---------------------------------------
+  // Adw.ToastOverlay lets us pop transient "toast" notifications.
+  const toasts = new Adw.ToastOverlay({ vexpand: true })
+
+  // The welcome screen lives in its own module (src/welcome.ts) so its inline
+  // styles.add() CSS hot-reloads on its own — see that file.
+  toasts.setChild(createWelcome(() => {
+    toasts.addToast(new Adw.Toast({ title: 'Hello from __APP_NAME__ 👋' }))
+  }))
+
+  // Adw.ApplicationWindow has no built-in title bar, so we stack our own
+  // header above the content inside a vertical box.
+  const content = new Gtk.Box({ orientation: Gtk.Orientation.VERTICAL })
+  content.append(header)
+  content.append(toasts)
+  window.setContent(content)
+
+  // ---- app actions (wired to the menu above) ---------------------------
+  const showAbout = () => {
+    // Adw.AboutWindow works on libadwaita 1.2+. On 1.5+ you can switch to
+    // Adw.AboutDialog (a Gtk.Window-free dialog) if you prefer.
+    const about = new Adw.AboutWindow({
+      transientFor: window,
+      applicationName: '__APP_NAME__',
+      applicationIcon: APP_ID,
+      developerName: 'Your Name',
+      version: '0.1.0',
+      comments: 'An Adwaita application built with node-gtk.',
+      developers: ['Your Name <you@example.com>'],
+      copyright: '© 2026 Your Name',
+      licenseType: Gtk.License.MIT_X11,
+    })
+    about.present()
+  }
+
+  const aboutAction = Gio.SimpleAction.new('about', null)
+  aboutAction.on('activate', () => showAbout())
+  app.addAction(aboutAction)
+
+  const quitAction = Gio.SimpleAction.new('quit', null)
+  quitAction.on('activate', () => { loop.quit(); app.quit() })
+  app.addAction(quitAction)
+  app.setAccelsForAction('app.quit', ['<Control>q'])
+
+  window.on('close-request', () => (loop.quit(), app.quit(), false))
+
+  styles.install() // flush queued styles and start the dev hot-reload watcher
+  window.present()
+
+  // The loop integration is already running; under ESM this returns immediately.
+  // The app keeps running until the close handler (or quit action) stops it.
+  loop.run()
+})
+
+// Must be the last statement — returns immediately under ESM (see top of file).
+app.run([])

package/tools/templates/app/src/welcome.ts.tmpl

@@ -0,0 +1,41 @@
+/*
+ * welcome.ts — the welcome screen, in its own component module.
+ *
+ * The inline CSS below is registered with styles.add(). Because this module's
+ * top level only registers styles and defines an export — it builds no widgets
+ * until createWelcome() is called — node-gtk/styles can safely re-execute it on
+ * every edit: tweak the CSS and the running window restyles live, no restart.
+ * (Editing the widget code instead needs a restart — use `npm run dev:app-reload`.)
+ */
+import Gtk from 'gi:Gtk-4.0'
+import Adw from 'gi:Adw-1'
+
+import { styles } from 'node-gtk/styles'
+
+// Inline, hot-reloadable styles for this component. Edit a value and save to
+// see it apply live under `npm run dev`.
+styles.add(`
+  .welcome-button {
+    font-weight: bold;
+  }
+`)
+
+// Build the welcome screen. `onSayHello` runs when the button is clicked.
+export function createWelcome(onSayHello: () => void) {
+  // Adw.StatusPage is the idiomatic "empty state" / welcome widget.
+  const welcome = new Adw.StatusPage({
+    iconName: 'face-smile-symbolic',
+    title: 'Welcome to __APP_NAME__',
+    description: 'Edit src/welcome.ts (its styles hot-reload) or src/main.ts.',
+  })
+
+  const button = new Gtk.Button({
+    label: 'Say hello',
+    halign: Gtk.Align.CENTER,
+    cssClasses: ['pill', 'suggested-action', 'welcome-button'],
+  })
+  button.on('clicked', onSayHello)
+  welcome.setChild(button)
+
+  return welcome
+}

package/tools/templates/app/style.css.tmpl

@@ -0,0 +1,19 @@
+/*
+ * Custom styles for __APP_NAME__.
+ *
+ * Loaded by src/main.ts (via node-gtk/styles), layered on top of the Adwaita
+ * stylesheet. Under `npm run dev` it hot-reloads — edit and save to see changes
+ * live, with no restart. See the GTK4 CSS reference:
+ *   https://docs.gtk.org/gtk4/css-overview.html
+ *   https://docs.gtk.org/gtk4/css-properties.html
+ *
+ * Adwaita ships many ready-made style classes (`.pill`, `.suggested-action`,
+ * `.title-1`, `.dim-label`, …) — prefer those before writing custom CSS:
+ *   https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html
+ */
+
+/* Example: nudge the welcome button. Delete or edit freely. */
+button.suggested-action.pill {
+  padding-left: 24px;
+  padding-right: 24px;
+}

package/tools/templates/app/tsconfig.json.tmpl

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"],
+    "paths": {
+      "node-gtk": ["./node_modules/.node-gtk-types/node-gtk.d.ts"]
+    }
+  },
+  "include": ["src/**/*.ts"],
+  "files": ["node_modules/.node-gtk-types/node-gtk.d.ts"]
+}