@gjsify/nativescript-vite 0.4.36

package/README.md

@@ -0,0 +1,84 @@
+# @gjsify/nativescript-vite
+
+Vite 8 / Rolldown compatibility + gjsify transforms for building [NativeScript](https://nativescript.org/) apps.
+
+It is a **thin composer** around the upstream `@nativescript/vite` integration. It takes the Vite config that `@nativescript/vite` produces, fixes the two pieces Vite 8 / Rolldown reject, and layers gjsify's NativeScript transforms on top — so a NativeScript app builds under Vite 8 with `gjsify`'s stack.
+
+## Why
+
+`@nativescript/vite` targets Vite ≤ 7 (Rollup). Under **Vite 8 / Rolldown** its config uses two constructs the Rust bundler rejects, so a pristine NativeScript app fails to build. This package patches exactly those two pieces on the returned config object — no fork of `@nativescript/vite`, no patched `node_modules` — then adds the same gjsify NativeScript transforms that `gjsify build --app nativescript` applies.
+
+**Empirically validated:** with pristine `@nativescript/vite` 2.0.3 + this composer, a real NativeScript app (a `@nativescript/canvas` three.js teapot) builds on **Vite 8.0.16** → 612 modules → `bundle.mjs` (~450 kB), `ns prepare android` succeeds, and the bundle has zero `@nativescript/vite` / `gi://` / `@girs/*` leakage.
+
+## What it fixes
+
+1. **Function-replacement `resolve.alias` entries are dropped.** `@nativescript/vite` registers aliases whose `replacement` is a *function* (platform-`main`, the tsconfig wildcard, `@nativescript/core/.../index` canonicalization). Vite 8's native alias (Rolldown) only accepts string replacements and otherwise fails with `Failed to convert builtin plugin 'ViteAlias' … function replacement into rust type String`. The upstream `nativescript-package-resolver` plugin (a `resolveId` hook, kept) and the string `~/` / `@` aliases (kept) already cover the same resolution, so dropping the function entries is safe.
+2. **The explicit `@rollup/plugin-commonjs` plugin is removed.** It crashes Rolldown with `Cannot read properties of undefined (reading 'currentLoadingModule')`. Rolldown handles CommonJS (`@nativescript/core`'s modules) natively, so the plugin is not needed.
+
+On top of the fixes, it spreads `@gjsify/vite-plugin-gjsify`'s `gjsifyNativescript()` preset: `gi://` → empty module, platform file resolution (`*.android` / `*.ios` / `*.native`), platform defines (`__ANDROID__` / `__IOS__` / `__APPLE__` / `__VISIONOS__` / `__DEV__`), and the node-builtin alias routing (incl. `module` → `@gjsify/module`).
+
+## Install
+
+The package's only hard dependency is `@gjsify/vite-plugin-gjsify`. Everything from the NativeScript side is an **optional peer** — install it in your NativeScript app alongside the rest of your NS toolchain:
+
+```bash
+npm install -D @gjsify/nativescript-vite @nativescript/vite vite
+# plus whatever your app already uses, e.g.:
+npm install @nativescript/core @nativescript/canvas @nativescript/canvas-polyfill
+```
+
+Optional peers: `@nativescript/vite`, `@nativescript/core`, `nativescript`, `@nativescript/canvas`, `@nativescript/canvas-polyfill`, and `vite` (`^8.0.14`). They are not installed by this package — your NativeScript app provides them. If `@nativescript/vite` is missing, the config factory throws a clear, actionable error.
+
+## Usage
+
+`vite.config.ts` — use the exported factory as your whole config:
+
+```ts
+import { defineNativescriptConfig } from '@gjsify/nativescript-vite';
+
+export default defineNativescriptConfig();
+```
+
+It returns an async Vite config **function**, so Vite resolves `mode` and passes it through; the upstream `@nativescript/vite` config is built for the right mode before the fixes + gjsify transforms are applied. The first argument is forwarded to the `gjsifyNativescript()` preset from `@gjsify/vite-plugin-gjsify` (`{ reflection?, aliases?, optimizeDepsExclude? }`); an optional second argument is a Vite config (object or `(env) => config`) that is `mergeConfig`'d in last, so you can compose your own settings on top.
+
+`nativescript.config.ts` — select the Vite bundler:
+
+```ts
+import { NativeScriptConfig } from '@nativescript/core';
+
+export default {
+  id: 'org.example.app',
+  appPath: 'src',
+  android: { v8Flags: '--expose_gc', markingMode: 'none' },
+  bundler: 'vite',
+} satisfies NativeScriptConfig;
+```
+
+Then build as usual:
+
+```bash
+ns prepare android   # or: ns run android / ns run ios
+```
+
+## Audio-context note
+
+`@nativescript/canvas` transitively pulls a Web-Audio module that references surface a canvas/WebGL app never executes. If your app only does 2D/WebGL rendering, mark it `external` via the composable second argument so it stays out of the bundle:
+
+```ts
+import { defineNativescriptConfig } from '@gjsify/nativescript-vite';
+
+export default defineNativescriptConfig({}, {
+  build: { rollupOptions: { external: [/@nativescript\/audio-context/, /@nativescript\/canvas-media/] } },
+});
+```
+
+## Known limitations
+
+- **Production target.** Validated for the production build path (`ns prepare` / `ns build` / `ns run --no-hmr`). The upstream dev-server / HMR plugins are passed through untouched but not separately validated under Vite 8.
+- **Web Worker builds** keep the upstream `worker` config verbatim; gjsify's transforms are not propagated into `worker.plugins`. A worker-using app is an untested shape.
+- **Conditional exports.** `resolve.conditions` keep upstream's `browser` active alongside `nativescript`, so a package that ships *divergent* `browser` vs `nativescript` conditional exports may resolve its `browser` variant. The validated apps do not hit this.
+- **Version coupling.** The two fixes target `@nativescript/vite`'s returned config shape (array-form aliases with function replacements, a plugin named `commonjs`). If a future version renames/wraps those, the composer warns at build time that the CommonJS fix did not apply.
+
+## License
+
+MIT — see the [gjsify](https://github.com/gjsify/gjsify) workspace.

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigEnv, UserConfig } from 'vite';
+import type { GjsifyNativescriptOptions } from '@gjsify/vite-plugin-gjsify';
+export type GjsifyNativescriptViteOptions = GjsifyNativescriptOptions;
+/** A user-supplied Vite config (or config factory) merged in as the final layer. */
+export type UserConfigInput = UserConfig | ((env: ConfigEnv) => UserConfig | Promise<UserConfig>);
+/**
+ * Build a NativeScript Vite config that works under Vite 8 / Rolldown with
+ * gjsify's transforms. Use it as your app's `vite.config.ts`:
+ *
+ * ```ts
+ * import { defineNativescriptConfig } from '@gjsify/nativescript-vite';
+ * export default defineNativescriptConfig();
+ * ```
+ *
+ * Compose your own Vite config on top (e.g. externalize a canvas/WebGL app's
+ * unused `@nativescript/audio-context`) by passing a second argument — it is
+ * `mergeConfig`'d in last, so it wins:
+ *
+ * ```ts
+ * export default defineNativescriptConfig({}, {
+ *   build: { rollupOptions: { external: [/@nativescript\/audio-context/] } },
+ * });
+ * ```
+ *
+ * Returns an async Vite config FUNCTION (Vite resolves the `mode` and passes it
+ * through), so the upstream `@nativescript/vite` config is built for the right
+ * mode before the fixes + gjsify transforms are applied.
+ *
+ * @param options  forwarded to `@gjsify/vite-plugin-gjsify`'s `gjsifyNativescript()` preset.
+ * @param userConfig  optional final-layer Vite config (object or `(env) => config`).
+ */
+export declare function defineNativescriptConfig(options?: GjsifyNativescriptViteOptions, userConfig?: UserConfigInput): (env: ConfigEnv) => Promise<UserConfig>;
+export default defineNativescriptConfig;
+/**
+ * Apply the two Vite 8 / Rolldown fixes to a returned `@nativescript/vite`
+ * config: drop function-replacement aliases and the explicit
+ * `@rollup/plugin-commonjs`. Returns a shallow copy with the fixed `resolve` and
+ * `plugins` — the input is not mutated.
+ */
+export declare function applyVite8Fixes(config: UserConfig): UserConfig;

package/lib/index.js

@@ -0,0 +1,184 @@
+// `@gjsify/nativescript-vite` — Vite 8 / Rolldown compatibility + gjsify
+// transforms for building NativeScript apps.
+//
+// `@nativescript/vite` (the upstream NativeScript Vite integration) does not
+// build under Vite 8 / Rolldown: its config uses two constructs Rolldown
+// rejects. This package COMPOSES the upstream config and fixes exactly those
+// two pieces on the returned config object, then layers gjsify's NS transforms
+// on top — so a NativeScript app builds under Vite 8 with `gjsify`'s stack.
+//
+// The two upstream incompatibilities (verified by running real builds):
+//   1. Function-replacement `resolve.alias` entries (platform-`main` + tsconfig
+//      wildcard + `@nativescript/core/.../index` canonicalization) →
+//      `Failed to convert builtin plugin 'ViteAlias' … function replacement
+//      into rust type String`. They are DROPPED — the upstream
+//      `nativescript-package-resolver` plugin (a `resolveId` hook, kept) and the
+//      string `~/` / `@` aliases (kept) already cover the same resolution.
+//   2. The explicit `@rollup/plugin-commonjs` plugin → `Cannot read properties
+//      of undefined (reading 'currentLoadingModule')`. It is DROPPED — Rolldown
+//      handles CommonJS (`@nativescript/core`'s modules) natively.
+//
+// On top, it spreads `@gjsify/vite-plugin-gjsify`'s `gjsifyNativescript()`
+// preset (gi:// → empty, platform file resolution, platform defines, the
+// node-builtin alias routing incl. `module` → `@gjsify/module`).
+//
+// `@nativescript/vite`, `@nativescript/core`, the `nativescript` CLI, the
+// optional `@nativescript/canvas*` plugins and `vite` are all OPTIONAL peer
+// dependencies — installed by the consumer only when targeting NativeScript.
+import { mergeConfig } from 'vite';
+import { gjsifyNativescript as gjsifyNativescriptTransforms } from '@gjsify/vite-plugin-gjsify';
+/**
+ * Build a NativeScript Vite config that works under Vite 8 / Rolldown with
+ * gjsify's transforms. Use it as your app's `vite.config.ts`:
+ *
+ * ```ts
+ * import { defineNativescriptConfig } from '@gjsify/nativescript-vite';
+ * export default defineNativescriptConfig();
+ * ```
+ *
+ * Compose your own Vite config on top (e.g. externalize a canvas/WebGL app's
+ * unused `@nativescript/audio-context`) by passing a second argument — it is
+ * `mergeConfig`'d in last, so it wins:
+ *
+ * ```ts
+ * export default defineNativescriptConfig({}, {
+ *   build: { rollupOptions: { external: [/@nativescript\/audio-context/] } },
+ * });
+ * ```
+ *
+ * Returns an async Vite config FUNCTION (Vite resolves the `mode` and passes it
+ * through), so the upstream `@nativescript/vite` config is built for the right
+ * mode before the fixes + gjsify transforms are applied.
+ *
+ * @param options  forwarded to `@gjsify/vite-plugin-gjsify`'s `gjsifyNativescript()` preset.
+ * @param userConfig  optional final-layer Vite config (object or `(env) => config`).
+ */
+export function defineNativescriptConfig(options = {}, userConfig) {
+    return async (env) => {
+        const base = await loadUpstreamConfig(env);
+        const fixed = applyVite8Fixes(base);
+        // Layer gjsify's NS transforms (a Vite plugin array whose `config()` hook
+        // supplies the gi:// → empty redirect, platform resolution, defines, and
+        // node-builtin aliases) — the same composition proven to produce a
+        // working Vite 8 bundle.
+        const withTransforms = mergeConfig(fixed, {
+            plugins: [...gjsifyNativescriptTransforms(options)],
+        });
+        if (userConfig === undefined)
+            return withTransforms;
+        const resolved = typeof userConfig === 'function' ? await userConfig(env) : userConfig;
+        return mergeConfig(withTransforms, resolved);
+    };
+}
+export default defineNativescriptConfig;
+/**
+ * Resolve `@nativescript/vite`'s TypeScript config factory (an optional peer).
+ * Prefers the documented root entry (`@nativescript/vite`) and falls back to the
+ * `./typescript` subpath that some published versions expose; throws a clear,
+ * actionable error if neither resolves or the export is missing.
+ */
+async function loadUpstreamConfig(env) {
+    // String-variable specifiers: `@nativescript/vite` is an OPTIONAL peer, not
+    // installed in this repo, so a literal `import('@nativescript/vite')` would
+    // fail type resolution. Non-literal specifiers resolve at runtime only (the
+    // consumer's NS app provides the package). Root is the documented entry
+    // (`export { typescriptConfig }`); the subpath is a fallback for versions
+    // whose `exports` map exposes `./typescript` but not the root re-export.
+    const candidates = ['@nativescript/vite', '@nativescript/vite/typescript'];
+    let lastError;
+    for (const specifier of candidates) {
+        let mod;
+        try {
+            mod = (await import(specifier));
+        }
+        catch (cause) {
+            lastError = cause;
+            continue;
+        }
+        const { typescriptConfig } = mod;
+        if (typeof typescriptConfig === 'function') {
+            return typescriptConfig({ mode: env.mode });
+        }
+        lastError = new Error(`"${specifier}" resolved but did not export a "typescriptConfig" function`);
+    }
+    throw new Error('@gjsify/nativescript-vite requires the optional peer "@nativescript/vite" exporting `typescriptConfig` ' +
+        '(install it alongside @nativescript/core in your NativeScript app).', { cause: lastError });
+}
+/**
+ * Apply the two Vite 8 / Rolldown fixes to a returned `@nativescript/vite`
+ * config: drop function-replacement aliases and the explicit
+ * `@rollup/plugin-commonjs`. Returns a shallow copy with the fixed `resolve` and
+ * `plugins` — the input is not mutated.
+ */
+export function applyVite8Fixes(config) {
+    const out = { ...config };
+    if (config.resolve?.alias) {
+        out.resolve = { ...config.resolve, alias: dropFunctionAliases(config.resolve.alias) };
+    }
+    if (Array.isArray(config.plugins)) {
+        const before = countPluginByName(config.plugins, 'commonjs');
+        out.plugins = stripPluginByName(config.plugins, 'commonjs');
+        // Observability: the strip depends on `@rollup/plugin-commonjs` registering
+        // exactly `name: 'commonjs'` as a synchronous, top-level (or nested-array)
+        // plugin object. If a future `@nativescript/vite` renames it or wraps it in
+        // a Promise, the strip silently misses and Rolldown crashes again with the
+        // `currentLoadingModule` error this package exists to prevent — so warn loud
+        // when the plugin we expect to remove was NOT found.
+        if (before === 0) {
+            // one-time build-time diagnostic — surfaces a silent upstream rename
+            console.warn('[@gjsify/nativescript-vite] no plugin named "commonjs" found in the upstream config — ' +
+                'if your @nativescript/vite version renamed/wrapped @rollup/plugin-commonjs, the Rolldown ' +
+                'CommonJS fix may not have applied.');
+        }
+    }
+    return out;
+}
+/**
+ * Keep only `resolve.alias` entries Vite 8 / Rolldown accepts. The array form
+ * may carry function `replacement`s (Vite types `Alias.replacement` as `string`,
+ * but `@nativescript/vite` sets functions at runtime — so this check is
+ * LOAD-BEARING; do not remove it as "always true"). Malformed/holey entries are
+ * skipped. The object/record form only ever holds strings, so it passes through.
+ */
+function dropFunctionAliases(alias) {
+    if (!Array.isArray(alias))
+        return alias;
+    return alias.filter((entry) => entry != null && typeof entry.replacement !== 'function');
+}
+/**
+ * Remove every plugin with the given `name` from a (possibly nested) Vite
+ * plugins array, preserving order and nesting of the rest. Assumes plugins are
+ * synchronous objects (not `Promise<Plugin>`); `@nativescript/vite` registers
+ * `@rollup/plugin-commonjs` synchronously, so this holds for the supported
+ * versions.
+ */
+function stripPluginByName(plugins, name) {
+    if (!Array.isArray(plugins))
+        return plugins;
+    const out = [];
+    for (const entry of plugins) {
+        if (Array.isArray(entry)) {
+            out.push(stripPluginByName(entry, name));
+        }
+        else if (entry && typeof entry === 'object' && 'name' in entry && entry.name === name) {
+            // dropped
+        }
+        else {
+            out.push(entry);
+        }
+    }
+    return out;
+}
+/** Count plugins with the given `name` across a (possibly nested) plugins array. */
+function countPluginByName(plugins, name) {
+    if (!Array.isArray(plugins))
+        return 0;
+    let n = 0;
+    for (const entry of plugins) {
+        if (Array.isArray(entry))
+            n += countPluginByName(entry, name);
+        else if (entry && typeof entry === 'object' && 'name' in entry && entry.name === name)
+            n += 1;
+    }
+    return n;
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+    "name": "@gjsify/nativescript-vite",
+    "version": "0.4.36",
+    "description": "Vite 8 / Rolldown compatibility + gjsify transforms for building NativeScript apps — composes @nativescript/vite and fixes the pieces Rolldown rejects.",
+    "type": "module",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/index.d.ts",
+            "default": "./lib/index.js"
+        }
+    },
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "rm -rf lib tsconfig.tsbuildinfo || exit 0",
+        "check": "tsc --noEmit",
+        "build": "tsc"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/nativescript-vite#readme",
+    "keywords": [
+        "vite",
+        "rolldown",
+        "nativescript",
+        "android",
+        "ios",
+        "gjsify"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@gjsify/vite-plugin-gjsify": "workspace:^"
+    },
+    "peerDependencies": {
+        "@nativescript/canvas": "*",
+        "@nativescript/canvas-polyfill": "*",
+        "@nativescript/core": "*",
+        "@nativescript/vite": "*",
+        "nativescript": "*",
+        "vite": "^8.0.14"
+    },
+    "peerDependenciesMeta": {
+        "@nativescript/canvas": {
+            "optional": true
+        },
+        "@nativescript/canvas-polyfill": {
+            "optional": true
+        },
+        "@nativescript/core": {
+            "optional": true
+        },
+        "@nativescript/vite": {
+            "optional": true
+        },
+        "nativescript": {
+            "optional": true
+        },
+        "vite": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@types/node": "^25.9.1",
+        "typescript": "^5.9.3",
+        "vite": "^8.0.14"
+    }
+}