@gjsify/cli 0.16.0 → 0.16.2

package/lib/actions/build.d.ts

@@ -37,6 +37,14 @@ export declare class BuildAction {
      * there is no in-bundle plugin, so this hook is the sole injection point.
      */
     private applyShebang;
+    /**
+     * Post-bundle step for a `--app browser` HTML entry: write the processed
+     * `index.html` beside the JS bundle, with the entry `<script>`'s `src`
+     * rewritten to point at the built bundle. Mirrors `applyShebang` — kept in
+     * the CLI (not a Rolldown plugin) because the native rolldown engine
+     * exposes no `emitFile`.
+     */
+    private applyBrowserHtml;
     /**
      * GJS plugin loader — bundle the resolved plugin module to a single
      * self-contained ESM file, then import that. Works around GJS's native

package/lib/actions/build.js

@@ -4,11 +4,12 @@ import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { resolveUserPlugins } from '../utils/resolve-plugin-by-name.js';
 import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, detectNodeGiGlobals, } from '@gjsify/rolldown-plugin-gjsify/globals';
 import { pnpPlugin } from '@gjsify/rolldown-plugin-pnp';
-import { dirname, extname, join } from 'node:path';
+import { dirname, extname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { normalizeBundlerOptions, mergeBundlerOptions } from '../utils/normalize-bundler-options.js';
 import { inputSourceDirs, isOutdirInsideSource, libraryOutputLeakError } from '../utils/library-output.js';
+import { detectHtmlEntry, parseHtmlEntry, emitBrowserHtml, htmlOutPathFor } from '../utils/html-entry.js';
 const DEFAULT_GJS_SHEBANG = '#!/usr/bin/env -S gjs -m';
 /**
  * `true` when `path` points at a location that's unsafe to use as a build
@@ -241,6 +242,28 @@ export class BuildAction {
         if (verbose)
             console.debug(`[gjsify] --shebang: wrote ${line} + chmod 0o755 to ${outfile}`);
     }
+    /**
+     * Post-bundle step for a `--app browser` HTML entry: write the processed
+     * `index.html` beside the JS bundle, with the entry `<script>`'s `src`
+     * rewritten to point at the built bundle. Mirrors `applyShebang` — kept in
+     * the CLI (not a Rolldown plugin) because the native rolldown engine
+     * exposes no `emitFile`.
+     */
+    async applyBrowserHtml(htmlEntry, outfile, verbose) {
+        const jsOutPath = resolve(outfile);
+        const outHtmlPath = htmlOutPathFor(jsOutPath);
+        const html = emitBrowserHtml({
+            htmlSource: htmlEntry.htmlSource,
+            scriptTag: htmlEntry.scriptTag,
+            scriptSrc: htmlEntry.scriptSrc,
+            jsOutPath,
+            outHtmlPath,
+        });
+        await mkdir(dirname(outHtmlPath), { recursive: true });
+        await writeFile(outHtmlPath, html);
+        if (verbose)
+            console.debug(`[gjsify] --app browser: wrote ${outHtmlPath}`);
+    }
     /**
      * GJS plugin loader — bundle the resolved plugin module to a single
      * self-contained ESM file, then import that. Works around GJS's native
@@ -329,6 +352,23 @@ export class BuildAction {
     async buildApp(app = 'gjs', opts = {}) {
         const { verbose, typescript, exclude, library: pkg, aliases, excludeGlobals } = this.configData;
         const userBundler = normalizeBundlerOptions(this.configData);
+        // --- `--app browser` HTML entry (Vite-style) ---
+        // When the entry is an `index.html`, bundle the module its
+        // `<script type="module" src>` references (rewrite `input` to that
+        // module so auto-globals detection + the bundle both see the real
+        // entry, NOT the html) and remember the page so a post-bundle step can
+        // emit a processed `index.html` next to the JS. Guarded on browser +
+        // an html input; every other build path is untouched.
+        let htmlEntry = null;
+        if (app === 'browser') {
+            const htmlPath = detectHtmlEntry(userBundler.input);
+            if (htmlPath) {
+                const htmlSource = await readFile(htmlPath, 'utf-8');
+                const { moduleEntry, scriptTag, scriptSrc } = parseHtmlEntry(htmlPath, htmlSource);
+                userBundler.input = moduleEntry;
+                htmlEntry = { htmlSource, scriptTag, scriptSrc };
+            }
+        }
         const formatRaw = userBundler.output?.format ??
             (userBundler.output?.file?.endsWith('.cjs') ? 'cjs' : 'esm');
         // The orchestrator only handles esm/cjs (iife is not a GJS / Node /
@@ -346,6 +386,12 @@ export class BuildAction {
             }
             outfile = candidate;
         }
+        // An html entry emits its `index.html` next to the JS bundle, so it
+        // needs a concrete outfile to anchor that sibling path.
+        if (htmlEntry && !outfile) {
+            throw new Error('gjsify build: an .html entry needs an explicit --outfile ' +
+                '(e.g. --outfile dist-app/app.js); the emitted index.html is written beside it.');
+        }
         const { consoleShim, globals } = this.configData;
         const userExternal = Array.isArray(userBundler.external) ? userBundler.external : undefined;
         const userBanner = typeof userBundler.output?.banner === 'string' ? userBundler.output.banner : undefined;
@@ -485,6 +531,13 @@ export class BuildAction {
         if ((app === 'gjs' || app === 'node') && this.configData.shebang) {
             await this.applyShebang(app, outfile, verbose);
         }
+        // Browser HTML entry: emit the processed `index.html` beside the bundle
+        // (engine-portable post-step — the native rolldown engine has no
+        // `emitFile`, so this can't live in a plugin). `outfile` is guaranteed
+        // present here (guarded above when `htmlEntry` is set).
+        if (app === 'browser' && htmlEntry && outfile) {
+            await this.applyBrowserHtml(htmlEntry, outfile, verbose);
+        }
         return [writeResult];
     }
     /**

package/lib/commands/pack.js

@@ -172,8 +172,18 @@ export async function packWorkspace(wsDir, opts = {}) {
  * Walk the workspace and return the list of files to include in the tarball,
  * relative to `wsDir`. Mirrors npm pack's selection rules:
  *
- *   - If pkg.files exists: use it as an allowlist (with .npmignore as a
- *     blacklist within those globs)
+ *   - If pkg.files exists: the array is an ALLOWLIST that overrides
+ *     .gitignore / .npmignore entirely. Every file under an allowlisted
+ *     path/dir ships from disk; only the hardcoded implicit-exclusion set
+ *     (node_modules, .git, lockfiles, … — applied by `walkAll` /
+ *     `expandFilesPatterns`) and npm's always-ignore names are dropped.
+ *     This matches `npm pack`: a `files` entry re-includes a path even when
+ *     .gitignore/.npmignore would drop it (verified against `npm pack
+ *     --dry-run`). Trimming `files`-allowlisted content by .gitignore
+ *     silently dropped build-generated-but-allowlisted files like
+ *     adwaita-web's `src/styles.generated.ts` (gitignored, allowlisted via
+ *     `files: ["src"]`) — shipping a broken tarball whose `src/index.ts`
+ *     imported a file the tarball didn't contain.
  *   - Otherwise: walk everything, apply .npmignore + .gitignore, drop the
  *     implicit-exclusion set (node_modules, .git, …)
  *
@@ -185,18 +195,22 @@ function collectFiles(wsDir, pkg) {
     const filesField = Array.isArray(pkg.files)
         ? pkg.files.filter((f) => typeof f === 'string')
         : null;
-    let candidates;
+    const out = new Set();
     if (filesField) {
-        candidates = expandFilesPatterns(wsDir, filesField);
+        // A `files` allowlist overrides .gitignore/.npmignore — ship every
+        // allowlisted path from disk. `expandFilesPatterns` already excludes
+        // the NEVER_INCLUDED_BASENAMES set (node_modules, .git, lockfiles, …)
+        // via `walkAll`, so junk is still kept out.
+        for (const f of expandFilesPatterns(wsDir, filesField))
+            out.add(f);
     }
     else {
-        candidates = walkAll(wsDir);
-    }
-    const ignore = loadIgnore(wsDir);
-    const out = new Set();
-    for (const f of candidates) {
-        if (!ignore(f))
-            out.add(f);
+        // No `files` field — walk everything and apply .npmignore/.gitignore.
+        const ignore = loadIgnore(wsDir);
+        for (const f of walkAll(wsDir)) {
+            if (!ignore(f))
+                out.add(f);
+        }
     }
     for (const f of always) {
         if (existsSync(join(wsDir, f)))

package/lib/utils/html-entry.d.ts

@@ -0,0 +1,46 @@
+import type { RolldownOptions } from 'rolldown';
+export interface ParsedHtmlEntry {
+    /** Absolute path to the module the `<script type="module" src>` references. */
+    moduleEntry: string;
+    /** The full matched `<script …></script>`/`<script … />` tag text. */
+    scriptTag: string;
+    /** The raw `src` attribute value from that tag (as authored in the HTML). */
+    scriptSrc: string;
+}
+/**
+ * Return the `.html` path when `input` is a SINGLE html entry (a literal
+ * `.html` string, a 1-element array of one, or a 1-key record whose value is
+ * one) — else `null`. Multi-entry inputs and non-html entries (incl. globs
+ * like `src/**\/*.ts`) are never treated as html. The path is returned as
+ * authored (relative or absolute); the caller resolves + reads it.
+ */
+export declare function detectHtmlEntry(input: RolldownOptions['input'] | undefined): string | null;
+/**
+ * Find the FIRST `<script type="module" src="…">` whose `src` is a local
+ * (non-`http(s)://`, non-`//`) path and resolve the referenced module against
+ * the HTML file's directory. Throws when no such tag exists.
+ */
+export declare function parseHtmlEntry(htmlPath: string, htmlSource: string): ParsedHtmlEntry;
+export interface EmitBrowserHtmlInput {
+    /** The original HTML source. */
+    htmlSource: string;
+    /** The `<script>` tag matched by {@link parseHtmlEntry}. */
+    scriptTag: string;
+    /** That tag's original `src` value. */
+    scriptSrc: string;
+    /** Absolute path to the built JS bundle the emitted page should load. */
+    jsOutPath: string;
+    /** Absolute path the emitted HTML will be written to. */
+    outHtmlPath: string;
+}
+/**
+ * Produce the emitted HTML: the original source with the entry script's `src`
+ * rewritten to point at the built JS bundle, relative to the output HTML's own
+ * directory (so the page is portable regardless of where `dist/` is served
+ * from). Everything else — `<title>`, meta tags, other markup — is preserved.
+ */
+export declare function emitBrowserHtml(input: EmitBrowserHtmlInput): string;
+/** Convenience: the emitted HTML filename for a given JS outfile (sibling `index.html`). */
+export declare function htmlOutPathFor(jsOutPath: string): string;
+/** Derive a JS outfile from an outdir + the module entry basename (`<outdir>/<name>.js`). */
+export declare function jsOutPathForOutdir(outdir: string, moduleEntry: string): string;

package/lib/utils/html-entry.js

@@ -0,0 +1,89 @@
+// HTML-entry support for `gjsify build --app browser`.
+//
+// Vite treats `index.html` as the build entry: it finds the
+// `<script type="module" src="...">`, bundles that module, and emits a
+// processed HTML with the script pointing at the built asset. `gjsify build`
+// only ever took a `.ts`/`.js` entry + `--outfile`, so browser apps hand-wrote
+// their shell page (the `write-app-html.mjs` pattern). This util brings the
+// Vite behaviour to the production Rolldown build.
+//
+// HTML emission MUST run as a CLI post-bundle step (mirroring `applyShebang`),
+// NOT as a Rolldown plugin `emitFile`: the native `@gjsify/rolldown-native`
+// engine implements no `emitFile`, so a plugin-based emit would work on the
+// npm engine (Node) but throw under the GJS-bundled CLI. Parsing is regex-based
+// and tolerant on purpose — this replaces a ~25-line hand-written script, not a
+// full HTML pipeline; CSS is NOT extracted here (it travels in the JS bundle as
+// a string via css-as-string and is injected by the app — the unified pattern
+// shared with the `--app gjs` target).
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+/**
+ * Return the `.html` path when `input` is a SINGLE html entry (a literal
+ * `.html` string, a 1-element array of one, or a 1-key record whose value is
+ * one) — else `null`. Multi-entry inputs and non-html entries (incl. globs
+ * like `src/**\/*.ts`) are never treated as html. The path is returned as
+ * authored (relative or absolute); the caller resolves + reads it.
+ */
+export function detectHtmlEntry(input) {
+    if (!input)
+        return null;
+    const isHtml = (v) => typeof v === 'string' && /\.html?$/i.test(v);
+    if (typeof input === 'string')
+        return isHtml(input) ? input : null;
+    if (Array.isArray(input)) {
+        return input.length === 1 && isHtml(input[0]) ? input[0] : null;
+    }
+    // Record<name, path> form.
+    if (typeof input === 'object') {
+        const values = Object.values(input);
+        return values.length === 1 && isHtml(values[0]) ? values[0] : null;
+    }
+    return null;
+}
+const SCRIPT_MODULE_RE = /<script\b[^>]*\btype\s*=\s*["']module["'][^>]*>(?:<\/script>)?/gi;
+const SRC_ATTR_RE = /\bsrc\s*=\s*["']([^"']+)["']/i;
+const EXTERNAL_SRC_RE = /^(?:https?:)?\/\//i;
+/**
+ * Find the FIRST `<script type="module" src="…">` whose `src` is a local
+ * (non-`http(s)://`, non-`//`) path and resolve the referenced module against
+ * the HTML file's directory. Throws when no such tag exists.
+ */
+export function parseHtmlEntry(htmlPath, htmlSource) {
+    for (const match of htmlSource.matchAll(SCRIPT_MODULE_RE)) {
+        const scriptTag = match[0];
+        const srcMatch = SRC_ATTR_RE.exec(scriptTag);
+        if (!srcMatch)
+            continue; // inline module script — not an entry
+        const scriptSrc = srcMatch[1];
+        if (EXTERNAL_SRC_RE.test(scriptSrc))
+            continue; // externally hosted — leave alone
+        const moduleEntry = isAbsolute(scriptSrc) ? scriptSrc : resolve(dirname(htmlPath), scriptSrc);
+        return { moduleEntry, scriptTag, scriptSrc };
+    }
+    throw new Error(`gjsify build: ${htmlPath} has no local <script type="module" src="…"> to bundle. ` +
+        `Add one pointing at your app entry (e.g. <script type="module" src="./main.ts">).`);
+}
+/**
+ * Produce the emitted HTML: the original source with the entry script's `src`
+ * rewritten to point at the built JS bundle, relative to the output HTML's own
+ * directory (so the page is portable regardless of where `dist/` is served
+ * from). Everything else — `<title>`, meta tags, other markup — is preserved.
+ */
+export function emitBrowserHtml(input) {
+    const { htmlSource, scriptTag, scriptSrc, jsOutPath, outHtmlPath } = input;
+    let rel = relative(dirname(outHtmlPath), jsOutPath).split(/[\\/]/).join('/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    // Rewrite only the src value WITHIN the matched tag, then swap that tag
+    // back into the source — avoids touching any other `src=` in the document.
+    const newTag = scriptTag.replace(SRC_ATTR_RE, (whole) => whole.replace(scriptSrc, rel));
+    return htmlSource.replace(scriptTag, newTag);
+}
+/** Convenience: the emitted HTML filename for a given JS outfile (sibling `index.html`). */
+export function htmlOutPathFor(jsOutPath) {
+    return resolve(dirname(jsOutPath), 'index.html');
+}
+/** Derive a JS outfile from an outdir + the module entry basename (`<outdir>/<name>.js`). */
+export function jsOutPathForOutdir(outdir, moduleEntry) {
+    const name = basename(moduleEntry).replace(/\.[cm]?[jt]sx?$/i, '');
+    return resolve(outdir, `${name}.js`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.16.0",
+    "version": "0.16.2",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -122,33 +122,33 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.16.0",
-        "@gjsify/create-app": "^0.16.0",
-        "@gjsify/node-globals": "^0.16.0",
-        "@gjsify/node-polyfills": "^0.16.0",
-        "@gjsify/npm-registry": "^0.16.0",
-        "@gjsify/resolve-npm": "^0.16.0",
-        "@gjsify/rolldown-plugin-gjsify": "^0.16.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.16.0",
-        "@gjsify/semver": "^0.16.0",
-        "@gjsify/tar": "^0.16.0",
-        "@gjsify/tsc": "^0.16.0",
-        "@gjsify/web-polyfills": "^0.16.0",
-        "@gjsify/workspace": "^0.16.0",
+        "@gjsify/buffer": "^0.16.2",
+        "@gjsify/create-app": "^0.16.2",
+        "@gjsify/node-globals": "^0.16.2",
+        "@gjsify/node-polyfills": "^0.16.2",
+        "@gjsify/npm-registry": "^0.16.2",
+        "@gjsify/resolve-npm": "^0.16.2",
+        "@gjsify/rolldown-plugin-gjsify": "^0.16.2",
+        "@gjsify/rolldown-plugin-pnp": "^0.16.2",
+        "@gjsify/semver": "^0.16.2",
+        "@gjsify/tar": "^0.16.2",
+        "@gjsify/tsc": "^0.16.2",
+        "@gjsify/web-polyfills": "^0.16.2",
+        "@gjsify/workspace": "^0.16.2",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
-        "rolldown": "^1.1.0",
+        "rolldown": "^1.1.4",
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.16.0",
+        "@gjsify/unit": "^0.16.2",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.16.0",
-        "@gjsify/rolldown-native": "^0.16.0"
+        "@gjsify/oxfmt-native": "^0.16.2",
+        "@gjsify/rolldown-native": "^0.16.2"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {