@gjsify/vite-plugin-gjsify 0.4.36 → 0.4.38

package/lib/index.js

@@ -28,7 +28,10 @@
 // `aliasPlugin` from rolldown-plugin-gjsify is intentionally NOT used here
 // (it is not part of that package's public API). Vite has a native
 // `resolve.alias`, which is what the inline config hook below sets.
-import { gjsImportsEmptyPlugin } from '@gjsify/rolldown-plugin-gjsify';
+import { createRequire } from 'node:module';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { gjsImportsEmptyPlugin, platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from '@gjsify/rolldown-plugin-gjsify';
 import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
 import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
 import { ALIASES_NODE_FOR_NATIVESCRIPT } from '@gjsify/resolve-npm';
@@ -99,6 +102,153 @@ export function gjsifyBrowser(options = {}) {
     ];
 }
 export default gjsifyBrowser;
+/**
+ * `@nativescript/core`'s CSS parser pulls in `css-tree`, whose data modules
+ * (`data.js` / `data-patch.js` / `version.js`) load JSON via
+ * `createRequire(import.meta.url)('mdn-data/*.json' | '../package.json')` at
+ * module-evaluation time. Rolldown can't statically resolve those dynamic
+ * requires, so they survive into the bundle and throw on the NativeScript V8
+ * runtime ("Module evaluation promise rejected") — crashing every NS app that
+ * uses `@nativescript/core`'s styling. css-tree ships a self-contained
+ * `dist/csstree.esm.js` with the data inlined (no `createRequire`); aliasing the
+ * bare `css-tree` specifier to it keeps those requires out of the bundle.
+ *
+ * Resolved from the consuming project (`css-tree` is `@nativescript/core`'s
+ * transitive dep, not a direct one here). Returns no alias when css-tree isn't
+ * installed — a non-NS-core consumer keeps resolving `css-tree` normally.
+ */
+function nativescriptCssTreeAlias(fromDir) {
+    try {
+        const require = createRequire(import.meta.url);
+        return { 'css-tree': require.resolve('css-tree/dist/csstree.esm', { paths: [fromDir] }) };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Collect the barrel modules referenced from the app's XML via `xmlns="~/MOD"`
+ * that `@nativescript/vite`'s `ns-bundler-context` does NOT register — i.e. those
+ * with no paired `.xml` sibling. Returns the NS nickname + a root-relative import
+ * specifier for each.
+ */
+function collectXmlnsBarrels(appDir, root) {
+    const xmlFiles = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = nodePath.join(dir, entry);
+            let isDir;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir)
+                walk(full);
+            else if (full.endsWith('.xml'))
+                xmlFiles.push(full);
+        }
+    };
+    walk(appDir);
+    const names = new Set();
+    const xmlnsRe = /xmlns:[\w-]+\s*=\s*["']~\/([^"']+)["']/g;
+    for (const file of xmlFiles) {
+        let src;
+        try {
+            src = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const match of src.matchAll(xmlnsRe)) {
+            names.add(match[1].replace(/\/+$/, ''));
+        }
+    }
+    const barrels = [];
+    for (const name of names) {
+        // ns-bundler-context already registers any module that has an `.xml` sibling.
+        if (existsSync(nodePath.join(appDir, `${name}.xml`)))
+            continue;
+        const file = ['.ts', '.js', '/index.ts', '/index.js']
+            .map((suffix) => nodePath.join(appDir, `${name}${suffix}`))
+            .find((candidate) => existsSync(candidate));
+        if (!file)
+            continue;
+        const spec = '/' + nodePath.relative(root, file).split(nodePath.sep).join('/');
+        barrels.push({ name, spec });
+    }
+    return barrels;
+}
+/**
+ * Register barrel modules referenced from XML via `xmlns` namespaces, which
+ * `@nativescript/vite`'s `ns-bundler-context` leaves unregistered.
+ *
+ * NativeScript resolves a custom element — e.g. `<w:SourceView>` declared with
+ * `xmlns:w="~/widgets/index"` — at runtime via `global.loadModule("widgets/index")`,
+ * a lookup in the registry populated by `registerModule` / `registerBundlerModules`.
+ * `ns-bundler-context` registers every XML file, its paired code-behind and CSS,
+ * but deliberately NOT standalone barrels (`index.ts` with no `.xml` sibling). So a
+ * barrel reachable only via `xmlns` (`~/widgets/index`, `~/mdx/index`) is never
+ * registered; an ESM bundle has no `global.require` fallback, so `loadModule(...)`
+ * returns `null` → "Module 'SourceView' not found". `@nativescript/webpack`'s
+ * `xml-namespace-loader` registered every `.ts`, so these resolved for free there —
+ * this plugin reproduces that behaviour for the Vite build.
+ *
+ * It augments `@nativescript/vite`'s generated `virtual:ns-bundler-context` module
+ * (guaranteed imported early, before `Application.run`) by prepending a namespace
+ * import of each missing barrel and appending matching `registerModule` calls. The
+ * barrels enter the bundle via the added imports; registration runs right after the
+ * upstream `registerBundlerModules`.
+ */
+function nativescriptXmlnsBarrelsPlugin() {
+    const BUNDLER_CONTEXT_ID = '\0virtual:ns-bundler-context';
+    let root = process.cwd();
+    let appDir;
+    return {
+        name: 'gjsify-nativescript-xmlns-barrels',
+        configResolved(config) {
+            root = config.root || process.cwd();
+            // `~/` maps to the NativeScript app directory (`appPath`, default `app`;
+            // `src` is the other common layout). Probe both; XML lives under it.
+            appDir = ['app', 'src'].map((dir) => nodePath.join(root, dir)).find((dir) => existsSync(dir));
+        },
+        transform(code, id) {
+            if (id !== BUNDLER_CONTEXT_ID || !appDir)
+                return null;
+            const barrels = collectXmlnsBarrels(appDir, root);
+            if (barrels.length === 0)
+                return null;
+            const imports = barrels
+                .map((barrel, i) => `import * as __gjsifyXmlnsBarrel${i} from ${JSON.stringify(barrel.spec)};`)
+                .join('\n');
+            const registrations = barrels
+                .map((barrel, i) => `    global.registerModule(${JSON.stringify(barrel.name)}, () => __gjsifyXmlnsBarrel${i});`)
+                .join('\n');
+            const footer = [
+                '',
+                ';(function () {',
+                '  try {',
+                "    if (typeof global !== 'undefined' && typeof global.registerModule === 'function') {",
+                registrations,
+                '    }',
+                '  } catch (e) {',
+                "    try { console.warn('[gjsify-nativescript] xmlns barrel registration failed', e); } catch (_) {}",
+                '  }',
+                '})();',
+                '',
+            ].join('\n');
+            return { code: `${imports}\n${code}${footer}`, map: null };
+        },
+    };
+}
 /**
  * Returns the Vite plugin array that brings `gjsify build --app nativescript`'s
  * NS-target transforms to a Vite project (dev + build). Spread it into a
@@ -124,23 +274,32 @@ export function gjsifyNativescript(options = {}) {
         nodePrefixAliases[bare] = target;
         nodePrefixAliases[`node:${bare}`] = target;
     }
-    const alias = {
-        ...nodePrefixAliases,
-        ...options.aliases,
-    };
     const optimizeDepsExclude = ['@gjsify/unit', ...(options.optimizeDepsExclude ?? [])];
+    // Target platform from the env NS' CLI sets when it spawns the bundler
+    // (else `undefined` → `.native`-only resolution + neutral defines).
+    const platform = detectNativescriptPlatform();
     const configPlugin = {
         name: 'gjsify-nativescript-config',
-        config() {
+        config(userConfig, env) {
+            // `__DEV__` tracks Vite's mode (dev server vs `vite build`).
+            const dev = env?.mode !== 'production';
+            // Resolve css-tree from the project root (its dist is the consumer's
+            // transitive dep). User `aliases` are merged last so they win.
+            const root = userConfig?.root ?? process.cwd();
             return {
                 resolve: {
-                    alias,
+                    alias: { ...nodePrefixAliases, ...nativescriptCssTreeAlias(root), ...options.aliases },
                     conditions: ['import', 'nativescript'],
                     mainFields: ['nativescript', 'module', 'main'],
                 },
                 define: {
                     global: 'globalThis',
                     // NO `window` define — NS apps have no DOM
+                    //
+                    // Standard NS compile-time platform flags, matching the
+                    // Rolldown `--app nativescript` factory + the globals
+                    // `@nativescript/vite` seeds in its main entry.
+                    ...nativescriptPlatformDefines(platform, { dev }),
                 },
                 build: {
                     target: 'esnext',
@@ -153,6 +312,15 @@ export function gjsifyNativescript(options = {}) {
     };
     return [
         gjsImportsEmptyPlugin(),
+        // Platform-specific source variants (`*.android` / `*.ios` /
+        // `*.native`). A `resolveId` HOOK, NOT a `resolve.alias` — so it works
+        // under Vite 8 / Rolldown, where @nativescript/vite's function-based
+        // alias for the same feature is rejected.
+        platformResolvePlugin({ platform }),
+        // Register `xmlns`-referenced barrel modules that @nativescript/vite's
+        // ns-bundler-context leaves unregistered (its tree-shaking gap for
+        // barrels with no `.xml` sibling). Reproduces webpack's xml-namespace-loader.
+        nativescriptXmlnsBarrelsPlugin(),
         // NO blueprintPlugin — Blueprint is GTK-specific
         // NO cssAsStringPlugin — NS handles CSS via @nativescript/core
         deepkitPlugin({ reflection: options.reflection }),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/vite-plugin-gjsify",
-    "version": "0.4.36",
+    "version": "0.4.38",
     "description": "Vite plugin presets mirroring `gjsify build --app browser` / `--app nativescript` — dev (Vite/HMR) parity with the gjsify CLI targets.",
     "type": "module",
     "main": "lib/index.js",
@@ -39,10 +39,11 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/resolve-npm": "^0.4.36",
-        "@gjsify/rolldown-plugin-deepkit": "^0.4.36",
-        "@gjsify/rolldown-plugin-gjsify": "^0.4.36",
-        "@gjsify/vite-plugin-blueprint": "^0.4.36"
+        "@gjsify/empty": "^0.4.38",
+        "@gjsify/resolve-npm": "^0.4.38",
+        "@gjsify/rolldown-plugin-deepkit": "^0.4.38",
+        "@gjsify/rolldown-plugin-gjsify": "^0.4.38",
+        "@gjsify/vite-plugin-blueprint": "^0.4.38"
     },
     "peerDependencies": {
         "vite": "^8.0.14"
@@ -54,7 +55,7 @@
     },
     "devDependencies": {
         "@types/node": "^25.9.1",
-        "typescript": "^5.9.3",
+        "typescript": "^6.0.3",
         "vite": "^8.0.14"
     }
 }