@nativescript/vite 0.0.1-alpha.0

package/dist/configuration/solid.js

@@ -0,0 +1,48 @@
+import solid from "vite-plugin-solid";
+import path from "path";
+import alias from "@rollup/plugin-alias";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { getProjectRootPath } from "../helpers/project.js";
+import { mergeConfig } from "vite";
+import { baseConfig } from "./base.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = getProjectRootPath();
+const solidPath = path.resolve(projectRoot, "node_modules/solid-js");
+const prod = !!process.env.production;
+const plugins = [
+    {
+        ...alias({
+            entries: {
+                // Fix the web alias - it should NOT point to web/dist but to the main dist
+                "solid-js/web": resolve(solidPath, `web/dist/${prod ? "web" : "dev"}.js`),
+                // Alias solid-js modules to proper locations
+                "solid-js/universal": resolve(solidPath, `universal/dist/${prod ? "universal" : "dev"}.js`),
+                "solid-js/store": resolve(solidPath, `store/dist/${prod ? "store" : "dev"}.js`),
+                "solid-js": resolve(solidPath, `dist/${prod ? "solid" : "dev"}.js`),
+            },
+        }),
+        enforce: "pre",
+    },
+    // Enable SolidJS support with NativeScript configuration
+    solid({
+        // Configure for development
+        dev: !prod,
+        // Enable HMR for development
+        hot: !prod,
+        // Configure solid compiler options for NativeScript
+        solid: {
+            // Use universal instead of dom for NativeScript compatibility
+            generate: "universal",
+            hydratable: false,
+            // Use the NativeScript community SolidJS renderer
+            moduleName: "@nativescript-community/solid-js",
+        },
+    }),
+];
+export const solidConfig = ({ mode }) => {
+    return mergeConfig(baseConfig({ mode }), {
+        plugins,
+    });
+};

package/dist/configuration/vue.d.ts

@@ -0,0 +1,4 @@
+import { type UserConfig } from "vite";
+export declare const vueConfig: ({ mode }: {
+    mode: any;
+}) => UserConfig;

package/dist/configuration/vue.js

@@ -0,0 +1,45 @@
+import vue from "@vitejs/plugin-vue";
+import vueJsx from "@vitejs/plugin-vue-jsx";
+import path from "path";
+import alias from "@rollup/plugin-alias";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { mergeConfig } from "vite";
+import { baseConfig } from "./base.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const plugins = [
+    {
+        ...alias({
+            entries: {
+                vue: "nativescript-vue",
+                "set-value": resolve(__dirname, "../shims/set-value.js"),
+            },
+        }),
+        enforce: "pre",
+    },
+    // Enable Vue Single File Component support
+    vue({
+        // NativeScript projects often use <script setup lang="ts">
+        script: {
+            defineModel: true,
+            propsDestructure: true,
+        },
+        // Keep template compilation basic; transform asset URLs is not needed for NS
+        template: {
+            transformAssetUrls: false,
+            compilerOptions: {
+                // Only treat real web custom elements (hyphenated) as custom.
+                // DO NOT match PascalCase NativeScript tags.
+                isCustomElement: (tag) => tag.includes("-"),
+            },
+        },
+    }),
+    // Optional: allow JSX/TSX in Vue components if used
+    vueJsx(),
+];
+export const vueConfig = ({ mode }) => {
+    return mergeConfig(baseConfig({ mode }), {
+        plugins,
+    });
+};

package/dist/helpers/commonjs-plugins.d.ts

@@ -0,0 +1,6 @@
+export declare const commonjsPlugins: {
+    name: string;
+    enforce: string;
+    resolveId(id: any): any;
+    load(id: any): string;
+}[];

package/dist/helpers/commonjs-plugins.js

@@ -0,0 +1,75 @@
+// Support various @nativescript/core transient commonjs dependency cases
+export const commonjsPlugins = [
+    // Fix source-map-js subpath imports for css-tree compatibility
+    {
+        name: "source-map-js-subpath-compat",
+        enforce: "pre",
+        resolveId(id) {
+            if (id === "source-map-js/lib/source-map-generator.js") {
+                return "\0source-map-generator-virtual";
+            }
+            return null;
+        },
+        load(id) {
+            if (id === "\0source-map-generator-virtual") {
+                // Import the main source-map-js package and extract SourceMapGenerator
+                return `
+import * as sourceMapJs from 'source-map-js';
+const { SourceMapGenerator } = sourceMapJs;
+export { SourceMapGenerator };
+`;
+            }
+            return null;
+        },
+    },
+    // Fix html-entities ESM compatibility issue
+    {
+        name: "html-entities-compat",
+        enforce: "pre",
+        resolveId(id) {
+            if (id === "html-entities") {
+                return id;
+            }
+            return null;
+        },
+        load(id) {
+            if (id === "html-entities") {
+                // html-entities exports: exports.encode = encode; exports.decode = decode; exports.decodeEntity = decodeEntity;
+                return `
+import * as htmlEntitiesModule from 'html-entities/lib/index.js';
+export const encode = htmlEntitiesModule.encode;
+export const decode = htmlEntitiesModule.decode;
+export const decodeEntity = htmlEntitiesModule.decodeEntity;
+export default htmlEntitiesModule;
+`;
+            }
+            return null;
+        },
+    },
+    // Fix fast-xml-parser ESM compatibility issue
+    {
+        name: "fast-xml-parser-compat",
+        enforce: "pre",
+        resolveId(id) {
+            if (id === "fast-xml-parser") {
+                return id;
+            }
+            return null;
+        },
+        load(id) {
+            if (id === "fast-xml-parser") {
+                // fast-xml-parser exports: exports.XMLParser = XMLParser; exports.XMLBuilder = XMLBuilder; exports.XMLValidator = XMLValidator; etc.
+                return `
+import * as fastXmlParser from 'fast-xml-parser/src/fxp.js';
+export const XMLParser = fastXmlParser.XMLParser;
+export const XMLBuilder = fastXmlParser.XMLBuilder;
+export const XMLValidator = fastXmlParser.XMLValidator;
+export const X2jOptions = fastXmlParser.X2jOptions;
+export const J2xOptions = fastXmlParser.J2xOptions;
+export default fastXmlParser;
+`;
+            }
+            return null;
+        },
+    },
+];

package/dist/helpers/config-as-json.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export default function nsConfigAsJsonPlugin(): Plugin;

package/dist/helpers/config-as-json.js

@@ -0,0 +1,35 @@
+import { nsConfigToJson } from "./utils.js";
+const nsConfigVirtualId = "\0nsvite:nsconfig-json";
+export default function nsConfigAsJsonPlugin() {
+    // will hold your parsed config object
+    let configObject;
+    return {
+        name: "nsvite-nsconfig-as-json",
+        // 1. Intercept imports of "~/package.json"
+        resolveId(source) {
+            if (source === "~/package.json") {
+                return nsConfigVirtualId;
+            }
+            return null;
+        },
+        // 2. When Vite asks us to load that virtual ID...
+        load(id) {
+            if (id === nsConfigVirtualId) {
+                configObject = nsConfigToJson();
+                // c) Return an ESM wrapper so Vite can import it at build‑time
+                return `export default ${JSON.stringify(configObject)};`;
+            }
+            return null;
+        },
+        // 3. After Rollup has generated all chunks, emit a package.json asset
+        //    into the output directory (dist/ by default)
+        generateBundle(_options, _bundle) {
+            const json = JSON.stringify(configObject, null, 2);
+            this.emitFile({
+                type: "asset",
+                fileName: "package.json",
+                source: json,
+            });
+        },
+    };
+}

package/dist/helpers/css-tree.d.ts

@@ -0,0 +1,4 @@
+export declare const aliasCssTree: {
+    find: string;
+    replacement: string;
+}[];

package/dist/helpers/css-tree.js

@@ -0,0 +1,21 @@
+import path from "path";
+import { __dirname } from './project.js';
+export const aliasCssTree = [
+    // Node.js built-ins and mdn-data polyfills for css-tree
+    {
+        find: "module",
+        replacement: path.resolve(__dirname, "../polyfills/module.js"),
+    },
+    {
+        find: "mdn-data/css/properties.json",
+        replacement: path.resolve(__dirname, "../polyfills/mdn-data-properties.js"),
+    },
+    {
+        find: "mdn-data/css/syntaxes.json",
+        replacement: path.resolve(__dirname, "../polyfills/mdn-data-syntaxes.js"),
+    },
+    {
+        find: "mdn-data/css/at-rules.json",
+        replacement: path.resolve(__dirname, "../polyfills/mdn-data-at-rules.js"),
+    },
+];

package/dist/helpers/dynamic-import-plugin.d.ts

@@ -0,0 +1,4 @@
+export declare function dynamicImportPlugin(): {
+    name: string;
+    generateBundle(options: any, bundle: any): void;
+};

package/dist/helpers/dynamic-import-plugin.js

@@ -0,0 +1,62 @@
+// Fix NativeScript dynamic imports by transforming paths and simplifying __vitePreload
+// Vite auto adds __vitePreload which includes browser APIs we don't need.
+// Note: ideally build.modulePreload = false in build settings would fix this
+// by simply removing the existence of __vitePreload in the bundle.
+// However, this appears to be a known Vite issue: https://github.com/vitejs/vite/issues/13952
+// Keep issue in mind for future Vite updates as may be able to remove this eventually.
+export function dynamicImportPlugin() {
+    return {
+        name: "nativescript-dynamic-import-fix",
+        generateBundle(options, bundle) {
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (chunk.type === "chunk") {
+                    let hasChanges = false;
+                    // 1. Transform all relative import paths from ./ to ~/
+                    if (chunk.code.includes("import('./")) {
+                        chunk.code = chunk.code.replace(/import\(['"]\.\/([^'"]*)['"]\)/g, "import('~/$1')");
+                        hasChanges = true;
+                    }
+                    // 2. Replace __vitePreload with simple implementation
+                    if (chunk.code.includes("__vitePreload")) {
+                        const vitePreloadStart = chunk.code.indexOf("const __vitePreload = function preload");
+                        if (vitePreloadStart !== -1) {
+                            // Find the matching closing brace by counting braces
+                            let braceCount = 0;
+                            let functionStart = chunk.code.indexOf("{", vitePreloadStart);
+                            let i = functionStart;
+                            while (i < chunk.code.length) {
+                                if (chunk.code[i] === "{")
+                                    braceCount++;
+                                else if (chunk.code[i] === "}") {
+                                    braceCount--;
+                                    if (braceCount === 0) {
+                                        // Found the end of the function
+                                        const functionEnd = i + 1;
+                                        const before = chunk.code.substring(0, vitePreloadStart);
+                                        const after = chunk.code.substring(functionEnd);
+                                        // Simple implementation that just calls baseModule()
+                                        const replacement = `const __vitePreload = function preload(baseModule, deps, importerUrl) {
+      return baseModule().catch(err => {
+        console.error("Dynamic import error:", err);
+        throw err;
+      });
+    }`;
+                                        chunk.code = before + replacement + after;
+                                        hasChanges = true;
+                                        break;
+                                    }
+                                }
+                                i++;
+                            }
+                        }
+                    }
+                    //   if (hasChanges) {
+                    //     console.log(
+                    //       `Fixed NativeScript dynamic imports in: ${fileName}`,
+                    //     );
+                    //   }
+                }
+            }
+        },
+    };
+}

package/dist/helpers/external-configs.d.ts

@@ -0,0 +1,6 @@
+import type { UserConfig } from 'vite';
+export declare const externalConfigMerges: UserConfig[];
+/**
+ * @internal
+ */
+export declare function applyExternalConfigs(): void;

package/dist/helpers/external-configs.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import fs from 'fs';
+import { createRequire } from "module";
+// import { pathToFileURL } from 'url';
+import { getAllDependencies, getDependencyPath } from './utils.js';
+const require = createRequire(import.meta.url);
+export const externalConfigMerges = [];
+/**
+ * @internal
+ */
+export function applyExternalConfigs() {
+    for (const dependency of getAllDependencies()) {
+        const packagePath = getDependencyPath(dependency);
+        if (!packagePath) {
+            continue;
+        }
+        const configPath = path.join(packagePath, 'nativescript.vite.mjs');
+        if (fs.existsSync(configPath)) {
+            console.log(`Discovered external config: ${configPath}`);
+            try {
+                const externalModule = require(configPath);
+                const externalConfig = externalModule?.default ?? externalModule;
+                externalConfigMerges.push(externalConfig());
+            }
+            catch (err) {
+                console.warn(`
+					Unable to apply config: ${configPath}.
+					Error is: ${err}
+				`);
+            }
+        }
+    }
+}

package/dist/helpers/flavor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility to determine the project flavor based on installed dependencies
+ * (vue, angular, react, svelete, typescript, javascript...)
+ */
+export declare function determineProjectFlavor(): string | false;

package/dist/helpers/flavor.js

@@ -0,0 +1,40 @@
+// import { defaultConfigs } from '..';
+import { getAllDependencies } from "./utils.js";
+/**
+ * Utility to determine the project flavor based on installed dependencies
+ * (vue, angular, react, svelete, typescript, javascript...)
+ */
+export function determineProjectFlavor() {
+    const dependencies = getAllDependencies();
+    if (dependencies.includes("nativescript-vue")) {
+        return "vue";
+    }
+    if (dependencies.includes("@nativescript/angular")) {
+        return "angular";
+    }
+    if (dependencies.includes("react-nativescript")) {
+        return "react";
+    }
+    if (dependencies.includes("@nativescript-community/solid-js") ||
+        dependencies.includes("solid-js")) {
+        return "solid";
+    }
+    if (dependencies.includes("svelte-native") ||
+        dependencies.includes("@nativescript-community/svelte-native")) {
+        return "svelte";
+    }
+    // the order is important - angular, react, and svelte also include these deps
+    // but should return prior to this condition!
+    if (dependencies.includes("@nativescript/core") &&
+        dependencies.includes("typescript")) {
+        return "typescript";
+    }
+    if (dependencies.includes("@nativescript/core")) {
+        return "javascript";
+    }
+    console.info(`
+		Could not determine project flavor.
+		Please use webpack.useConfig('<flavor>') to explicitly set the base config.
+	`);
+    return false;
+}

package/dist/helpers/global-defines.d.ts

@@ -0,0 +1,14 @@
+export declare function getGlobalDefines(platform: string, targetMode: string): {
+    __ANDROID__: string;
+    __IOS__: string;
+    __VISIONOS__: string;
+    __APPLE__: string;
+    __DEV__: string;
+    __COMMONJS__: boolean;
+    __NS_WEBPACK__: boolean;
+    __NS_ENV_VERBOSE__: boolean;
+    __CSS_PARSER__: string;
+    __UI_USE_XML_PARSER__: boolean;
+    __UI_USE_EXTERNAL_RENDERER__: boolean;
+    __TEST__: boolean;
+};

package/dist/helpers/global-defines.js

@@ -0,0 +1,18 @@
+export function getGlobalDefines(platform, targetMode) {
+    return {
+        // Define platform flags for runtime checks
+        __ANDROID__: JSON.stringify(platform === "android"),
+        __IOS__: JSON.stringify(platform === "ios"),
+        __VISIONOS__: JSON.stringify(platform === "visionos"),
+        __APPLE__: JSON.stringify(platform === "ios" || platform === "visionos"),
+        __DEV__: JSON.stringify(targetMode === "development"),
+        __COMMONJS__: false,
+        __NS_WEBPACK__: true,
+        __NS_ENV_VERBOSE__: !!process.env.verbose,
+        __CSS_PARSER__: JSON.stringify("css-tree"),
+        __UI_USE_XML_PARSER__: true,
+        __UI_USE_EXTERNAL_RENDERER__: false,
+        // various ecosystems use this global (react for example)
+        __TEST__: false,
+    };
+}

package/dist/helpers/main-entry.d.ts

@@ -0,0 +1,5 @@
+export declare function mainEntryPlugin(cliFlags: any, debug?: boolean): {
+    name: string;
+    resolveId(id: any): string;
+    load(id: any): string;
+};

package/dist/helpers/main-entry.js

@@ -0,0 +1,75 @@
+import { getPackageJson, getProjectFilePath, getProjectRootPath, } from "./project.js";
+import fs from "fs";
+import path from "path";
+const projectRoot = getProjectRootPath();
+// main entry
+const packageJson = getPackageJson();
+const mainEntry = getProjectFilePath(packageJson.main);
+// console.log("mainEntry:", mainEntry);
+// hmr client
+const hmrClientPath = getProjectFilePath("./node_modules/@nativescript/vite/dist/hmr/hmr-client.js");
+const hmrClientExists = fs.existsSync(hmrClientPath);
+// console.log("hmrClientPath:", hmrClientPath);
+// console.log("hmrClientExists:", hmrClientExists);
+// Check if polyfills file exists
+const polyfillsPath = getProjectFilePath("src/polyfills.ts");
+const polyfillsExists = fs.existsSync(polyfillsPath);
+// console.log("polyfillsPath:", polyfillsPath);
+// console.log("polyfillsExists:", polyfillsExists);
+const VIRTUAL_ID = 'virtual:entry-with-polyfills';
+const RESOLVED = '\0' + VIRTUAL_ID;
+export function mainEntryPlugin(cliFlags, debug) {
+    return {
+        name: "main-entry",
+        resolveId(id) {
+            if (id === VIRTUAL_ID) {
+                return RESOLVED;
+            }
+            return null;
+        },
+        load(id) {
+            if (id === RESOLVED) {
+                let imports = "";
+                if (polyfillsExists) {
+                    imports += `import '${polyfillsPath}';\n`;
+                }
+                // Import WebSocket support for HMR in development
+                if (debug && cliFlags.hmr) {
+                    imports += `import '${hmrClientPath}';\n`;
+                }
+                // Import inspector modules for debugging in development
+                if (debug) {
+                    imports += `import '@nativescript/core/inspector_modules';\n`;
+                }
+                // Import CSS and apply via Application.addCss before main entry
+                const appCssPath = path.resolve(projectRoot, "src/app.css");
+                if (fs.existsSync(appCssPath)) {
+                    imports += `
+    // Import and apply global CSS
+    import appCssContent from './src/app.css?inline';
+    import { Application } from '@nativescript/core';
+    
+    if (typeof global !== 'undefined' && appCssContent) {
+      try {
+        // Just testing logs if needed
+        // console.log('🎨 CSS content length:', appCssContent.length);
+        // console.log('🎨 CSS content preview:', appCssContent.substring(0, 200) + '...');
+    
+        Application.addCss(appCssContent);
+        // console.log('🎨 Global CSS applied');
+      } catch (error) {
+        console.error('Error applying CSS:', error);
+      }
+    }
+    `;
+                }
+                imports += `import '${mainEntry}';`;
+                if (debug) {
+                    console.log("🔄 Virtual entry imports:", imports);
+                }
+                return imports;
+            }
+            return null;
+        },
+    };
+}

package/dist/helpers/module-resolution.d.ts

@@ -0,0 +1 @@
+export declare function findPackageInNodeModules(packageName: string, startDir: string): string;

package/dist/helpers/module-resolution.js

@@ -0,0 +1,17 @@
+import path from "path";
+import fs from "fs";
+// Node.js-style module resolution: walk up directory tree looking for node_modules
+export function findPackageInNodeModules(packageName, startDir) {
+    let currentDir = startDir;
+    while (currentDir !== path.dirname(currentDir)) {
+        // Stop at filesystem root
+        const nodeModulesDir = path.join(currentDir, "node_modules");
+        const packagePath = path.join(nodeModulesDir, packageName);
+        if (fs.existsSync(packagePath)) {
+            return packagePath;
+        }
+        // Move up one directory
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}

package/dist/helpers/nativescript-package-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare function nativescriptPackageResolver(platform: string): {
+    name: string;
+    enforce: string;
+    resolveId(id: any, importer: any): any;
+};