@gjsify/rolldown-plugin-gjsify 0.4.36 → 0.4.38

package/lib/app/nativescript.js

@@ -28,11 +28,16 @@ import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
 import { ALIASES_NODE_FOR_NATIVESCRIPT, getDerivedAliasesSync } from '@gjsify/resolve-npm';
 import { globToEntryPoints } from '../utils/entry-points.js';
 import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
+import { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from '../plugins/platform-resolve.js';
 export const setupForNativescript = async (input) => {
     const userExternal = input.userExternal ?? [];
     const external = [...userExternal];
     const exclude = input.pluginOptions.exclude ?? [];
     const entryPoints = await globToEntryPoints(input.input, exclude);
+    // Target platform — discovered from the env NS' CLI sets when it spawns a
+    // bundler (else `undefined` → `.native`-only resolution + neutral defines).
+    // `gjsify build` is a production bundler, so `__DEV__` is `false` here.
+    const platform = detectNativescriptPlatform();
     // Bare Node-builtin + `node:*` prefix aliases — both forms route to the
     // same `@gjsify/<X>` target. Generated deterministically from
     // `ALIASES_NODE_FOR_NATIVESCRIPT` so a single source-of-truth in
@@ -80,6 +85,13 @@ export const setupForNativescript = async (input) => {
                 // NO `window` define — NativeScript apps don't have a DOM
                 // and rely on the canonical absence of `window` to gate
                 // their cross-platform branches.
+                //
+                // Standard NS compile-time platform flags (`__ANDROID__` /
+                // `__IOS__` / `__APPLE__` / `__VISIONOS__` / `__DEV__`) so app
+                // code branching on them is statically resolved + dead-code
+                // eliminated per target — matching the globals
+                // `@nativescript/vite` seeds in its main entry.
+                ...nativescriptPlatformDefines(platform, { dev: false }),
             },
         },
         output: {
@@ -95,6 +107,10 @@ export const setupForNativescript = async (input) => {
     };
     const plugins = [
         gjsImportsEmptyPlugin(),
+        // Platform-specific source variants (`*.android` / `*.ios` /
+        // `*.native`) win over the base file — resolved BEFORE the Node-builtin
+        // alias routing so a platform fork of a portable module is honored.
+        platformResolvePlugin({ platform }),
         aliasPlugin({ entries: flattenAliases(aliasMap) }),
         // NO blueprintPlugin — Blueprint is a GTK-specific UI DSL
         // NO cssAsStringPlugin — NS ships its own CSS pipeline via

package/lib/index.d.ts

@@ -12,6 +12,8 @@ export type { TextLoaderPluginOptions, LoaderKind } from './plugins/text-loader.
 export { shebangPlugin, GJS_SHEBANG, NODE_SHEBANG, expandEnvTemplate, resolveShebangLine } from './plugins/shebang.js';
 export type { ShebangPluginOptions } from './plugins/shebang.js';
 export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
+export type { PlatformResolvePluginOptions, NativescriptPlatform } from './plugins/platform-resolve.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/index.js

@@ -9,6 +9,7 @@ export { cssAsStringPlugin } from './plugins/css-as-string.js';
 export { textLoaderPlugin } from './plugins/text-loader.js';
 export { shebangPlugin, GJS_SHEBANG, NODE_SHEBANG, expandEnvTemplate, resolveShebangLine } from './plugins/shebang.js';
 export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/plugins/platform-resolve.d.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from 'rolldown';
+export type NativescriptPlatform = 'android' | 'ios' | 'visionos';
+export interface PlatformResolvePluginOptions {
+    /**
+     * Target platform. When omitted, only `.native.*` variants are tried
+     * (the platform-specific `.android.*` / `.ios.*` lookups are skipped).
+     */
+    platform?: NativescriptPlatform;
+}
+/**
+ * Resolve platform-specific source-file variants (`*.android` / `*.ios` /
+ * `*.native`) ahead of the base file. Relative imports only — bare/package
+ * specifiers are left to the normal resolver chain (package platform-`main`
+ * fields are a separate, rarer concern handled by the alias layer).
+ */
+export declare function platformResolvePlugin(options?: PlatformResolvePluginOptions): Plugin;
+/**
+ * Best-effort detection of the NativeScript target platform from the
+ * environment NS' CLI sets when it spawns a bundler (`NATIVESCRIPT_BUNDLER_ENV`
+ * / `NATIVESCRIPT_WEBPACK_ENV` carry the platform; `NATIVESCRIPT_PLATFORM` is
+ * an explicit override). Returns `undefined` when no platform is discernible —
+ * callers then fall back to `.native`-only resolution + neutral defines.
+ */
+export declare function detectNativescriptPlatform(env?: Record<string, string | undefined>): NativescriptPlatform | undefined;
+/**
+ * The standard NativeScript compile-time platform flags, matching the globals
+ * `@nativescript/vite` seeds in its main entry (`__ANDROID__` / `__IOS__` /
+ * `__APPLE__` / `__VISIONOS__` / `__DEV__`). Fed into the bundler's
+ * `transform.define` (Rolldown) / `define` (Vite) so NS app code branching on
+ * these constants is statically resolved + dead-code-eliminated per target.
+ */
+export declare function nativescriptPlatformDefines(platform: NativescriptPlatform | undefined, opts?: {
+    dev?: boolean;
+}): Record<string, string>;

package/lib/plugins/platform-resolve.js

@@ -0,0 +1,135 @@
+// NativeScript / React-Native-style platform file resolution.
+//
+// Lets a shared codebase fork a single module per target platform by file
+// name — `foo.android.ts` / `foo.ios.ts` (platform-specific) or `foo.native.ts`
+// (any native platform, as opposed to the browser's `foo.ts`). An
+// `import './foo'` (or `import './foo.js'`) resolves to the most specific
+// variant that exists, in priority order:
+//
+//   ./foo.<platform>.<ext>   (e.g. ./foo.android.ts) — when a platform is known
+//   ./foo.native.<ext>       — native-but-not-browser
+//   ./foo.<ext>              — the base file (default resolver fallthrough)
+//
+// WHY THIS LIVES IN GJSIFY (not just a dependency on @nativescript/vite):
+// `@nativescript/vite` implements the same lookup as a Vite `resolve.alias`
+// whose `replacement` is a FUNCTION. Vite 8 / Rolldown rejects function
+// replacements on the native alias path (`Failed to convert builtin plugin
+// 'ViteAlias' … function replacement into rust type String`), which breaks the
+// NS production build under Vite 8. Implemented here as a proper `resolveId`
+// plugin HOOK (not a `resolve.alias`), it works identically under Rolldown
+// (the `gjsify build --app nativescript` CLI) AND under Vite 7/8 (the
+// `gjsifyNativescript()` preset) — the function-alias limitation only affects
+// the `resolve.alias` config shorthand, not plugin `resolveId` hooks.
+//
+// Reference: @nativescript/vite `helpers/package-platform-aliases.js`. Original
+// Copyright (c) NativeScript contributors, Apache-2.0. Reimplemented for the
+// gjsify Rolldown/Vite plugin pipeline.
+const PLATFORMS = ['android', 'ios', 'visionos'];
+// JS/TS extensions a source specifier may carry. Stripped so the platform
+// suffix lands BEFORE the extension (`./foo.js` → `./foo.android`).
+const KNOWN_EXT_RE = /\.(tsx?|jsx?|mts|cts|mjs|cjs)$/;
+function isPlatform(value) {
+    return PLATFORMS.includes(value);
+}
+/**
+ * Resolve platform-specific source-file variants (`*.android` / `*.ios` /
+ * `*.native`) ahead of the base file. Relative imports only — bare/package
+ * specifiers are left to the normal resolver chain (package platform-`main`
+ * fields are a separate, rarer concern handled by the alias layer).
+ */
+export function platformResolvePlugin(options = {}) {
+    const platform = options.platform;
+    // Priority: platform-specific suffix first, then the platform-agnostic
+    // `native` suffix. Without a known platform, only `native` applies.
+    const suffixes = platform ? [platform, 'native'] : ['native'];
+    return {
+        name: 'gjsify-nativescript-platform-resolve',
+        resolveId: {
+            order: 'pre',
+            async handler(source, importer, extraOptions) {
+                // Only relative source imports get platform variants.
+                if (!importer)
+                    return null;
+                if (!source.startsWith('./') && !source.startsWith('../'))
+                    return null;
+                const extMatch = KNOWN_EXT_RE.exec(source);
+                const origExt = extMatch ? extMatch[0] : '';
+                const base = origExt ? source.slice(0, -origExt.length) : source;
+                for (const suffix of suffixes) {
+                    // Try the bare form first (the resolver extension-probes,
+                    // so `./foo.android` finds `./foo.android.ts`), then the
+                    // extension-preserving form as a fallback.
+                    const candidates = origExt && `${base}.${suffix}` !== `${base}.${suffix}${origExt}`
+                        ? [`${base}.${suffix}`, `${base}.${suffix}${origExt}`]
+                        : [`${base}.${suffix}`];
+                    for (const candidate of candidates) {
+                        if (candidate === source)
+                            continue;
+                        // `skipSelf: true` re-runs the resolver chain WITHOUT
+                        // this plugin → no recursion on the nested resolve.
+                        const resolved = await this.resolve(candidate, importer, {
+                            skipSelf: true,
+                            ...(extraOptions?.kind ? { kind: extraOptions.kind } : {}),
+                        });
+                        if (resolved && !resolved.external)
+                            return resolved;
+                    }
+                }
+                // No variant on disk → let the default chain resolve the base.
+                return null;
+            },
+        },
+    };
+}
+/**
+ * Best-effort detection of the NativeScript target platform from the
+ * environment NS' CLI sets when it spawns a bundler (`NATIVESCRIPT_BUNDLER_ENV`
+ * / `NATIVESCRIPT_WEBPACK_ENV` carry the platform; `NATIVESCRIPT_PLATFORM` is
+ * an explicit override). Returns `undefined` when no platform is discernible —
+ * callers then fall back to `.native`-only resolution + neutral defines.
+ */
+export function detectNativescriptPlatform(env = process.env) {
+    const direct = env.NATIVESCRIPT_PLATFORM ?? env.NS_PLATFORM;
+    if (direct && isPlatform(direct))
+        return direct;
+    const raw = env.NATIVESCRIPT_BUNDLER_ENV ?? env.NATIVESCRIPT_WEBPACK_ENV;
+    if (raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            // NS' webpack/vite env historically uses `{ android: true }` /
+            // `{ ios: true }` booleans; newer paths may pass `platform`.
+            if (parsed.android === true)
+                return 'android';
+            if (parsed.ios === true)
+                return 'ios';
+            if (parsed.visionos === true)
+                return 'visionos';
+            if (typeof parsed.platform === 'string' && isPlatform(parsed.platform)) {
+                return parsed.platform;
+            }
+        }
+        catch {
+            // Malformed env JSON → undefined (native-only fallback).
+        }
+    }
+    return undefined;
+}
+/**
+ * The standard NativeScript compile-time platform flags, matching the globals
+ * `@nativescript/vite` seeds in its main entry (`__ANDROID__` / `__IOS__` /
+ * `__APPLE__` / `__VISIONOS__` / `__DEV__`). Fed into the bundler's
+ * `transform.define` (Rolldown) / `define` (Vite) so NS app code branching on
+ * these constants is statically resolved + dead-code-eliminated per target.
+ */
+export function nativescriptPlatformDefines(platform, opts = {}) {
+    const isAndroid = platform === 'android';
+    const isIos = platform === 'ios';
+    const isVisionOs = platform === 'visionos';
+    return {
+        __ANDROID__: String(isAndroid),
+        __IOS__: String(isIos),
+        __VISIONOS__: String(isVisionOs),
+        __APPLE__: String(isIos || isVisionOs),
+        __DEV__: String(opts.dev ?? false),
+    };
+}

package/lib/plugins/rewrite-node-modules-paths.js

@@ -28,15 +28,36 @@
 //        bundle's own URL and `__dirname`/`__filename` derive from it.
 //
 //   4. CJS (`__dirname`/`__filename` only, no `import.meta.url`)
-//      → declare them from the file's absolute build path. NOTE: still
-//        build-location-coupled and shares the "breaks when published" class of
-//        bug case (1) fixes; injecting an ESM import into a CJS module is unsafe,
-//        so a CJS-safe runtime-resolve is tracked as a follow-up. ESM deps (the
-//        common data-reader shape, e.g. typedoc) take path (1).
+//      → case 4a (runtime-resolve) when `runtimeResolve` is on (ESM output +
+//        bundle-URL banner present) AND the file is a genuinely resolvable
+//        installed package (`isRuntimeResolvable`). Declares `__dirname`/
+//        `__filename` from the RUNTIME module-resolve shim — the same
+//        location-independent strategy as case (1), so the bundle works after
+//        being published/relocated. This is what lets `@gjsify/tsc` find its
+//        `lib.*.d.ts` files relative to the INSTALLED bundle (via
+//        `getExecutingFilePath()` → `__filename`) instead of the build
+//        machine's `node_modules` path. The shim functions are pulled in with a
+//        CJS `require(...)`, NOT an ESM `import` header: Rolldown classifies a
+//        node_modules file by its own heuristics, and a genuine CommonJS file
+//        (a `.cjs`, or a `.js` with `module.exports` like `typescript/lib/
+//        _tsc.js`) is parsed as a CJS script — a prepended ESM `import` there
+//        throws `Cannot use import statement outside a module`. `require(...)`
+//        is the native CJS idiom Rolldown resolves + links to the bundled shim.
+//      → case 4b (legacy baked absolute path) otherwise: when `runtimeResolve`
+//        is OFF (the rare `--format iife|cjs` build that can't host the
+//        bundle-URL banner) OR the file is NOT a resolvable installed package
+//        (a relative-imported module under a `node_modules`-named dir that the
+//        package manager — Yarn PnP especially — does not resolve). Runtime
+//        resolution of such a file would collapse `__filename` to the bundle's
+//        own location, so the build-time absolute path is the correct value for
+//        an in-place run. Build-location-coupled — shares the "breaks when
+//        published" class of bug, but a non-installed file can't be published
+//        as a package anyway.
 //
 // Hosting: a Rolldown `transform(code, id)` hook with `order: 'post'` — runs
 // after deepkit/blueprint/css pre-transforms but still during module loading,
 // before chunking.
+import { createRequire } from 'node:module';
 import { dirname, join, relative, resolve } from 'node:path';
 import { inlineStaticReads } from '../utils/inline-static-reads.js';
 export const REWRITE_FILTER = /\.(m?js|cjs|[cm]?tsx?)$/;
@@ -89,6 +110,58 @@ export function extractPackageSpec(path) {
     const idx = path.lastIndexOf(marker);
     return idx < 0 ? path : path.slice(idx + marker.length);
 }
+/**
+ * The bare package name of a node_modules file spec (scoped names kept whole):
+ *   "typedoc/dist/lib/app.js"  → "typedoc"
+ *   "@scope/name/sub/file.js"  → "@scope/name"
+ */
+function packageNameOf(spec) {
+    const parts = spec.split('/');
+    const segments = spec.startsWith('@') ? 2 : 1;
+    return parts.slice(0, segments).join('/');
+}
+/**
+ * Whether the runtime module-resolve shim can actually resolve this file's
+ * package at runtime — i.e. it is a genuinely *installed*, resolvable package
+ * rather than a file that merely lives under a `node_modules`-named directory.
+ *
+ * The CJS runtime-resolve (case 4a) resolves `__dirname`/`__filename` by
+ * resolving the dep's package root from the bundle's location. That only works
+ * for a real installed package (`typescript`, `@gjsify/tsc`, a normal npm dep).
+ * A file reached via a RELATIVE import into a `node_modules`-named folder that
+ * is NOT a resolvable package (e.g. a test fixture at
+ * `fixtures/node_modules/fake-cjs/index.cjs`, or any dir not in the
+ * package manager's resolution graph — Yarn PnP especially rejects these)
+ * would resolve to the bundle's own location at runtime → wrong `__filename`.
+ * For those we fall back to the legacy baked-absolute-path rewrite (case 4b),
+ * which is build-location-coupled but correct for an in-place run.
+ *
+ * Probed at BUILD time with `createRequire(<file>).resolve("<pkg>/package.json")`
+ * anchored at the file itself — succeeds iff the package is installed and
+ * reachable (honours node_modules walking AND Yarn PnP, since the build runs
+ * under the consumer's loader). Best-effort: any throw → treat as not
+ * resolvable (fall back to the absolute rewrite, never crash the build).
+ */
+function isRuntimeResolvable(path) {
+    const pkg = packageNameOf(extractPackageSpec(path));
+    if (!pkg)
+        return false;
+    try {
+        createRequire(path).resolve(`${pkg}/package.json`);
+        return true;
+    }
+    catch {
+        try {
+            // Some strict `exports` maps block `<pkg>/package.json` — fall back
+            // to resolving the package's main entry, which is always exported.
+            createRequire(path).resolve(pkg);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
 /** Whether the file needs a `var __dirname`/`__filename` declaration injected. */
 function needsDirnameDecl(src, flags) {
     return flags.hasDirname && !DIRNAME_DECL_RE.test(src);
@@ -157,8 +230,46 @@ function rewriteZipResident(src, path, flags) {
     return { code: withPreamble(src, preamble), moduleType: moduleTypeForPath(path) };
 }
 /**
- * Case 4 — CJS (no `import.meta.url`). Declare `__dirname`/`__filename` from the
- * absolute build path. Build-location-coupled — see file header note.
+ * Case 4a — CJS, runtime-resolve. Declare `__dirname`/`__filename` from the
+ * module-resolve shim so they point at the file's location relative to the
+ * INSTALLED bundle, not the build machine. Location-independent — the fix for
+ * the "works in the workspace, crashes once published" class of bug for CJS
+ * deps (e.g. `@gjsify/tsc`'s `typescript/lib/_tsc.js` resolving its sibling
+ * `lib.*.d.ts` files). Mirrors `rewriteOnDiskEsm` minus the `import.meta.url`
+ * rewrite (a CJS file has none).
+ *
+ * Unlike the ESM case we pull the shim functions in via a CJS `require(...)`,
+ * NOT an ESM `import { … } from …` header. Rolldown classifies a `node_modules`
+ * file by its own heuristics (extension + `module.exports`/`require` content),
+ * and a genuine CommonJS file — a `.cjs`, or a `.js` with `module.exports` like
+ * `typescript/lib/_tsc.js` — is parsed as a CJS script. Prepending an ESM
+ * `import` statement there makes Rolldown's parser throw
+ * `[PARSE_ERROR] Cannot use import statement outside a module`. `require(...)`
+ * is the native CJS idiom Rolldown resolves + links to the bundled shim, so the
+ * preamble parses in either classification.
+ */
+function rewriteCjsRuntime(src, path, flags) {
+    const spec = JSON.stringify(extractPackageSpec(path));
+    const used = [];
+    const preamble = [];
+    if (needsDirnameDecl(src, flags)) {
+        preamble.push(`var __dirname = __gjsifyModuleDir(${spec});`);
+        used.push('__gjsifyModuleDir');
+    }
+    if (needsFilenameDecl(src, flags)) {
+        preamble.push(`var __filename = __gjsifyModuleFile(${spec});`);
+        used.push('__gjsifyModuleFile');
+    }
+    // Nothing to declare (both tokens already locally bound) — leave untouched.
+    if (used.length === 0)
+        return { code: src, moduleType: moduleTypeForPath(path) };
+    const header = `var { ${used.join(', ')} } = require(${JSON.stringify(MODULE_RESOLVE_SHIM)});`;
+    return { code: withPreamble(src, preamble, header), moduleType: moduleTypeForPath(path) };
+}
+/**
+ * Case 4b — CJS, legacy. Declare `__dirname`/`__filename` from the absolute
+ * build path. Build-location-coupled — see file header note. Used only for the
+ * non-ESM output formats that can't host the bundle-URL anchor banner.
  */
 function rewriteCjsAbsolute(src, path, flags) {
     const preamble = [];
@@ -202,7 +313,15 @@ export function rewriteContents(args, srcInput, bundleDir, runtimeResolve) {
             ? rewriteOnDiskEsm(src, args.path, flags)
             : rewriteOnDiskEsmLegacy(src, args.path, bundleDir, flags);
     }
-    return rewriteCjsAbsolute(src, args.path, flags);
+    // CJS (no `import.meta.url`). Runtime-resolve only when the output can host
+    // the bundle-URL banner (ESM output) AND the file is a genuinely resolvable
+    // installed package — otherwise the shim would resolve `__filename` to the
+    // bundle's own location at runtime. A file under a `node_modules`-named dir
+    // that is not actually installed (a relative-imported fixture, a non-PnP
+    // path) keeps the legacy baked-absolute-path rewrite.
+    return runtimeResolve && isRuntimeResolvable(args.path)
+        ? rewriteCjsRuntime(src, args.path, flags)
+        : rewriteCjsAbsolute(src, args.path, flags);
 }
 /**
  * Build a Rolldown plugin that runs the path rewriter as a `transform(code, id)`

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.4.36",
+    "version": "0.4.38",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -48,11 +48,11 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/console": "^0.4.36",
-        "@gjsify/resolve-npm": "^0.4.36",
-        "@gjsify/rolldown-plugin-deepkit": "^0.4.36",
-        "@gjsify/rolldown-plugin-pnp": "^0.4.36",
-        "@gjsify/vite-plugin-blueprint": "^0.4.36",
+        "@gjsify/console": "^0.4.38",
+        "@gjsify/resolve-npm": "^0.4.38",
+        "@gjsify/rolldown-plugin-deepkit": "^0.4.38",
+        "@gjsify/rolldown-plugin-pnp": "^0.4.38",
+        "@gjsify/vite-plugin-blueprint": "^0.4.38",
         "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.16.0",
         "acorn-walk": "^8.3.5",
@@ -60,7 +60,7 @@
         "lightningcss": "^1.32.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.4.36",
+        "@gjsify/lightningcss-native": "^0.4.38",
         "rolldown": "^1.0.3"
     },
     "peerDependenciesMeta": {
@@ -74,6 +74,6 @@
     "devDependencies": {
         "@types/node": "^25.9.1",
         "rolldown": "^1.0.3",
-        "typescript": "^5.9.3"
+        "typescript": "^6.0.3"
     }
 }