@gjsify/rolldown-plugin-gjsify 0.4.36 → 0.4.37

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.4.36",
+    "version": "0.4.37",
     "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.37",
+        "@gjsify/resolve-npm": "^0.4.37",
+        "@gjsify/rolldown-plugin-deepkit": "^0.4.37",
+        "@gjsify/rolldown-plugin-pnp": "^0.4.37",
+        "@gjsify/vite-plugin-blueprint": "^0.4.37",
         "@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.37",
         "rolldown": "^1.0.3"
     },
     "peerDependenciesMeta": {