@gjsify/cli 0.3.12 → 0.3.14

package/src/config.ts

@@ -92,7 +92,7 @@ export class Config {
             merge(merged, fileResult.config);
         }
 
-        merged.esbuild ||= {};
+        merged.bundler ||= {};
         merged.library ||= {};
         merged.typescript ||= {};
 
@@ -168,16 +168,52 @@ export class Config {
             configData.aliases = { ...(configData.aliases ?? {}), ...aliasMap };
         }
 
-        merge(configData.esbuild ??= {}, {
-            format: cliArgs.format,
-            minify: cliArgs.minify,
-            entryPoints: cliArgs.entryPoints,
-            outfile: cliArgs.outfile,
-            outdir: cliArgs.outdir,
-            logLevel: cliArgs.logLevel || 'warning',
-            ...(cliArgs.external?.length ? { external: cliArgs.external } : {}),
-            ...(Object.keys(defineMap).length ? { define: defineMap } : {}),
-        });
+        // Merge CLI flags into the Rolldown-shape `bundler` field. Mappings:
+        //   --entry-points  → bundler.input
+        //   --outfile       → bundler.output.file
+        //   --outdir        → bundler.output.dir
+        //   --format        → bundler.output.format
+        //   --minify        → bundler.output.minify
+        //   --log-level     → bundler.logLevel
+        //   --external      → bundler.external
+        //   --define        → bundler.transform.define
+        const bundler = (configData.bundler ??= {});
+        const output = (bundler.output ??= {});
+        const transform = (bundler.transform ??= {});
+
+        if (cliArgs.entryPoints?.length) bundler.input = cliArgs.entryPoints;
+        if (cliArgs.outfile !== undefined) output.file = cliArgs.outfile;
+        if (cliArgs.outdir !== undefined) output.dir = cliArgs.outdir;
+        if (cliArgs.format !== undefined) output.format = cliArgs.format as 'esm' | 'cjs' | 'iife';
+        if (cliArgs.minify !== undefined) output.minify = cliArgs.minify;
+        if (cliArgs.logLevel) {
+            // Map esbuild log levels to Rolldown's narrower set:
+            //   esbuild   → rolldown
+            //   silent    → silent
+            //   error     → warn   (rolldown has no error-only)
+            //   warning   → warn
+            //   info      → info
+            //   debug     → debug
+            //   verbose   → debug  (rolldown has no verbose)
+            const map: Record<string, 'silent' | 'warn' | 'info' | 'debug'> = {
+                silent: 'silent',
+                error: 'warn',
+                warning: 'warn',
+                warn: 'warn',
+                info: 'info',
+                debug: 'debug',
+                verbose: 'debug',
+            };
+            const level = map[cliArgs.logLevel] ?? 'warn';
+            bundler.logLevel = level;
+        }
+        if (cliArgs.external?.length) {
+            const userExternal = Array.isArray(bundler.external) ? bundler.external : [];
+            bundler.external = [...userExternal, ...cliArgs.external];
+        }
+        if (Object.keys(defineMap).length) {
+            transform.define = { ...(transform.define ?? {}), ...defineMap };
+        }
 
         if(configData.verbose) console.debug("configData", configData);
 

package/src/types/cli-build-options.ts

@@ -1,4 +1,4 @@
-import type { App } from '@gjsify/esbuild-plugin-gjsify';
+import type { App } from '@gjsify/rolldown-plugin-gjsify';
 
 export interface CliBuildOptions {
   /**

package/src/types/config-data.ts

@@ -1,10 +1,59 @@
-import type { BuildOptions as EsbuildOptions} from 'esbuild';
+import type { RolldownOptions, OutputOptions } from 'rolldown';
 import type { ConfigDataLibrary, ConfigDataTypescript } from './index.js';
 
+/**
+ * Subset of `RolldownOptions` accepted in `.gjsifyrc.js`. Mirrors the legacy
+ * `esbuild?: BuildOptions` field — a thin pass-through. The orchestrator
+ * applies platform defaults on top of these, so most projects only need
+ * `output.file` / `output.dir` here.
+ *
+ * `output` is constrained to a single `OutputOptions` object (Rolldown also
+ * accepts an array for multi-output builds, but the CLI surface targets the
+ * single-output use case).
+ */
+export type BundlerOptions = Omit<RolldownOptions, 'output'> & {
+    output?: OutputOptions;
+};
+
+/**
+ * Legacy `esbuild?: BuildOptions` shape — kept as a compatibility shim for
+ * one minor release. Setting it logs a deprecation warning; the supported
+ * subset of fields is mapped into `bundler` at config-load time.
+ *
+ * Drop in 0.5.0.
+ */
+export interface LegacyEsbuildOptions {
+    outfile?: string;
+    outdir?: string;
+    format?: 'esm' | 'cjs' | 'iife';
+    external?: string[];
+    define?: Record<string, string>;
+    inject?: string[];
+    banner?: { js?: string };
+    target?: string | string[];
+    minify?: boolean;
+    sourcemap?: boolean | 'inline' | 'external' | 'both';
+    mainFields?: string[];
+    conditions?: string[];
+    platform?: 'browser' | 'node' | 'neutral';
+    loader?: Record<string, string>;
+}
+
 export interface ConfigData {
     /** Switch on the verbose mode */
     verbose?: boolean;
-    esbuild?: EsbuildOptions;
+    /**
+     * Bundler-level options forwarded to Rolldown. Replaces the legacy
+     * `esbuild` field. The orchestrator applies platform-specific defaults
+     * on top — most projects only need to set `output.file` / `output.dir`.
+     */
+    bundler?: BundlerOptions;
+    /**
+     * @deprecated Use `bundler` instead. Will be removed in 0.5.0. The shim
+     * maps the supported subset of esbuild fields into the equivalent
+     * Rolldown shape and logs a deprecation warning.
+     */
+    esbuild?: LegacyEsbuildOptions;
     library?: ConfigDataLibrary;
     typescript?: ConfigDataTypescript;
     /** An array of glob patterns to exclude matches and aliases */

package/src/utils/normalize-bundler-options.ts

@@ -0,0 +1,129 @@
+// One-release deprecation shim: maps the legacy `esbuild?: BuildOptions`
+// field on `.gjsifyrc.js` / `package.json#gjsify` into the equivalent
+// `bundler?: RolldownOptions` shape. Logs a single warning per build.
+//
+// Drop in 0.5.0.
+
+import type { OutputOptions } from 'rolldown';
+import type { ConfigData, BundlerOptions, LegacyEsbuildOptions } from '../types/config-data.js';
+
+let warnedOnce = false;
+
+export function normalizeBundlerOptions(configData: ConfigData): BundlerOptions {
+    const fromBundler: BundlerOptions = (configData.bundler ?? {}) as BundlerOptions;
+    if (!configData.esbuild) return fromBundler;
+
+    if (!warnedOnce) {
+        warnedOnce = true;
+        // eslint-disable-next-line no-console
+        console.warn(
+            "[gjsify] DEPRECATION: the 'esbuild' config key is deprecated and will be removed in 0.5.0. " +
+                "Rename it to 'bundler' (typed as RolldownOptions). See the migration notes in the gjsify CHANGELOG.",
+        );
+    }
+
+    const fromEsbuild = legacyEsbuildToRolldown(configData.esbuild);
+    // Plain user-config merge — we deliberately do NOT call
+    // `mergeBundlerOptions` here, because that function strips `input` and
+    // `external` from its overrides arg (it assumes the *orchestrator* is
+    // the override source and the user the base). Here both inputs are
+    // user-provided config and `input` must survive the merge.
+    const out: BundlerOptions = { ...fromEsbuild, ...fromBundler };
+    if (fromEsbuild.output || fromBundler.output) {
+        out.output = { ...(fromEsbuild.output ?? {}), ...(fromBundler.output ?? {}) };
+    }
+    if (fromEsbuild.transform || fromBundler.transform) {
+        out.transform = { ...(fromEsbuild.transform ?? {}), ...(fromBundler.transform ?? {}) };
+        if (fromEsbuild.transform?.define || fromBundler.transform?.define) {
+            out.transform.define = {
+                ...(fromEsbuild.transform?.define ?? {}),
+                ...(fromBundler.transform?.define ?? {}),
+            };
+        }
+    }
+    if (fromEsbuild.resolve || fromBundler.resolve) {
+        out.resolve = { ...(fromEsbuild.resolve ?? {}), ...(fromBundler.resolve ?? {}) };
+    }
+    return out;
+}
+
+/** Map the supported subset of esbuild BuildOptions into RolldownOptions. */
+function legacyEsbuildToRolldown(esb: LegacyEsbuildOptions): BundlerOptions {
+    const out: BundlerOptions = {};
+    const output: OutputOptions = {};
+    const transform: NonNullable<BundlerOptions['transform']> = {};
+    const resolve: NonNullable<BundlerOptions['resolve']> = {};
+
+    if (esb.outfile !== undefined) output.file = esb.outfile;
+    if (esb.outdir !== undefined) output.dir = esb.outdir;
+    if (esb.format !== undefined) output.format = esb.format;
+    if (esb.minify !== undefined) output.minify = esb.minify;
+    if (esb.sourcemap !== undefined) {
+        // esbuild has 'external' / 'both' which Rolldown doesn't — coerce to boolean.
+        output.sourcemap =
+            esb.sourcemap === 'inline'
+                ? 'inline'
+                : Boolean(esb.sourcemap);
+    }
+    if (esb.banner?.js !== undefined) output.banner = esb.banner.js;
+
+    if (esb.target !== undefined) {
+        transform.target = Array.isArray(esb.target) ? esb.target.join(',') : esb.target;
+    }
+    if (esb.define !== undefined) transform.define = esb.define;
+
+    if (esb.mainFields !== undefined) resolve.mainFields = esb.mainFields;
+    if (esb.conditions !== undefined) resolve.conditionNames = esb.conditions;
+
+    if (esb.external !== undefined) out.external = esb.external;
+    if (esb.platform !== undefined) out.platform = esb.platform;
+
+    if (Object.keys(output).length > 0) out.output = output;
+    if (Object.keys(transform).length > 0) out.transform = transform;
+    if (Object.keys(resolve).length > 0) out.resolve = resolve;
+
+    // Discarded silently:
+    //   esb.inject  — esbuild's array-of-side-effect-files; surfaced at the
+    //                 CLI layer instead, via input expansion.
+    //   esb.loader  — Rolldown infers module types from extensions natively.
+    return out;
+}
+
+/**
+ * Shallow merge with deep-merge of `output`, `transform`, and `resolve`. The
+ * second argument wins on conflicts, matching `merge(target, ...sources)`
+ * semantics from `@gjsify/rolldown-plugin-gjsify/utils/merge`.
+ *
+ * `base` is typically the Rolldown-generic shape returned by the orchestrator;
+ * `overrides` is the user's `BundlerOptions` from `.gjsifyrc.js` plus CLI
+ * flag merges. Single-output assumption matches `BundlerOptions['output']`.
+ *
+ * The orchestrator-side `input` is authoritative — it's the post-glob-expansion
+ * value. Overriding it with the user's raw glob string would re-introduce
+ * unresolved glob patterns into the final Rolldown call. Same for `external`,
+ * which the orchestrator concatenates with platform defaults already.
+ */
+export function mergeBundlerOptions(
+    base: BundlerOptions,
+    overrides: BundlerOptions,
+): BundlerOptions {
+    // Strip fields the orchestrator owns authoritatively — the user has
+    // already had their say via the orchestrator's `userExternal` / input
+    // expansion; merging the raw values back on top would clobber the
+    // post-processing.
+    const { input: _ignoredInput, external: _ignoredExternal, ...overridesRest } = overrides;
+    const out: BundlerOptions = { ...base, ...overridesRest };
+    if (base.output || overrides.output) {
+        out.output = { ...(base.output ?? {}), ...(overrides.output ?? {}) };
+    }
+    if (base.transform || overrides.transform) {
+        out.transform = { ...(base.transform ?? {}), ...(overrides.transform ?? {}) };
+        if (base.transform?.define || overrides.transform?.define) {
+            out.transform.define = { ...(base.transform?.define ?? {}), ...(overrides.transform?.define ?? {}) };
+        }
+    }
+    if (base.resolve || overrides.resolve) {
+        out.resolve = { ...(base.resolve ?? {}), ...(overrides.resolve ?? {}) };
+    }
+    return out;
+}