@octanejs/tanstack-start 0.1.0

package/src/internal/router-plugin/vite.d.ts

@@ -0,0 +1,201 @@
+import { configSchema, getConfig, CodeSplittingOptions, Config } from './core/config.js';
+import { RouterPluginContext } from './core/router-plugin-context.js';
+type RouterPluginOptions = Partial<Config | (() => Config)> | undefined;
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanstackRouterGenerator()],
+ *   // ...
+ * })
+ * ```
+ */
+declare const tanstackRouterGenerator: (
+	options?: RouterPluginOptions,
+	routerPluginContext?: RouterPluginContext,
+) => import('vite').Plugin<any> | import('vite').Plugin<any>[];
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanStackRouterCodeSplitter()],
+ *   // ...
+ * })
+ * ```
+ */
+declare const tanStackRouterCodeSplitter: (
+	options?: RouterPluginOptions,
+	routerPluginContext?: RouterPluginContext,
+) => import('vite').Plugin<any> | import('vite').Plugin<any>[];
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanstackRouter()],
+ *   // ...
+ * })
+ * ```
+ */
+declare const tanstackRouter: (
+	options?:
+		| Partial<
+				| {
+						target: 'vue' | 'react' | 'solid' | 'octane';
+						routeFileIgnorePrefix: string;
+						routesDirectory: string;
+						quoteStyle: 'single' | 'double';
+						semicolons: boolean;
+						disableLogging: boolean;
+						routeTreeFileHeader: string[];
+						indexToken:
+							| string
+							| RegExp
+							| {
+									regex: string;
+									flags?: string | undefined;
+							  };
+						routeToken:
+							| string
+							| RegExp
+							| {
+									regex: string;
+									flags?: string | undefined;
+							  };
+						generatedRouteTree: string;
+						disableTypes: boolean;
+						addExtensions: string | boolean;
+						enableRouteTreeFormatting: boolean;
+						tmpDir: string;
+						importRoutesUsingAbsolutePaths: boolean;
+						virtualRouteConfig?:
+							| string
+							| import('@tanstack/virtual-file-routes').VirtualRootRoute
+							| undefined;
+						routeFilePrefix?: string | undefined;
+						routeFileIgnorePattern?: string | undefined;
+						pathParamsAllowedCharacters?:
+							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
+							| undefined;
+						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
+						autoCodeSplitting?: boolean | undefined;
+						customScaffolding?:
+							| {
+									routeTemplate?: string | undefined;
+									lazyRouteTemplate?: string | undefined;
+							  }
+							| undefined;
+						experimental?:
+							| {
+									enableCodeSplitting?: boolean | undefined;
+							  }
+							| undefined;
+						plugins?: import('#tanstack-start/router-generator').GeneratorPlugin[] | undefined;
+						enableRouteGeneration?: boolean | undefined;
+						codeSplittingOptions?: CodeSplittingOptions | undefined;
+						plugin?:
+							| {
+									hmr?:
+										| {
+												style?: 'vite' | 'webpack' | undefined;
+										  }
+										| undefined;
+									vite?:
+										| {
+												environmentName?: string | undefined;
+										  }
+										| undefined;
+							  }
+							| undefined;
+				  }
+				| (() => Config)
+		  >
+		| undefined,
+) => import('vite').Plugin<any> | import('vite').Plugin<any>[];
+/**
+ * @deprecated Use `tanstackRouter` instead.
+ */
+declare const TanStackRouterVite: (
+	options?:
+		| Partial<
+				| {
+						target: 'vue' | 'react' | 'solid' | 'octane';
+						routeFileIgnorePrefix: string;
+						routesDirectory: string;
+						quoteStyle: 'single' | 'double';
+						semicolons: boolean;
+						disableLogging: boolean;
+						routeTreeFileHeader: string[];
+						indexToken:
+							| string
+							| RegExp
+							| {
+									regex: string;
+									flags?: string | undefined;
+							  };
+						routeToken:
+							| string
+							| RegExp
+							| {
+									regex: string;
+									flags?: string | undefined;
+							  };
+						generatedRouteTree: string;
+						disableTypes: boolean;
+						addExtensions: string | boolean;
+						enableRouteTreeFormatting: boolean;
+						tmpDir: string;
+						importRoutesUsingAbsolutePaths: boolean;
+						virtualRouteConfig?:
+							| string
+							| import('@tanstack/virtual-file-routes').VirtualRootRoute
+							| undefined;
+						routeFilePrefix?: string | undefined;
+						routeFileIgnorePattern?: string | undefined;
+						pathParamsAllowedCharacters?:
+							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
+							| undefined;
+						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
+						autoCodeSplitting?: boolean | undefined;
+						customScaffolding?:
+							| {
+									routeTemplate?: string | undefined;
+									lazyRouteTemplate?: string | undefined;
+							  }
+							| undefined;
+						experimental?:
+							| {
+									enableCodeSplitting?: boolean | undefined;
+							  }
+							| undefined;
+						plugins?: import('#tanstack-start/router-generator').GeneratorPlugin[] | undefined;
+						enableRouteGeneration?: boolean | undefined;
+						codeSplittingOptions?: CodeSplittingOptions | undefined;
+						plugin?:
+							| {
+									hmr?:
+										| {
+												style?: 'vite' | 'webpack' | undefined;
+										  }
+										| undefined;
+									vite?:
+										| {
+												environmentName?: string | undefined;
+										  }
+										| undefined;
+							  }
+							| undefined;
+				  }
+				| (() => Config)
+		  >
+		| undefined,
+) => import('vite').Plugin<any> | import('vite').Plugin<any>[];
+export default tanstackRouter;
+export {
+	configSchema,
+	getConfig,
+	tanStackRouterCodeSplitter,
+	tanstackRouterGenerator,
+	TanStackRouterVite,
+	tanstackRouter,
+};
+export type { Config, CodeSplittingOptions, RouterPluginContext };

package/src/internal/router-plugin/vite.js

@@ -0,0 +1,62 @@
+import { configSchema, getConfig } from './core/config.js';
+import { createRouterPluginContext } from './core/router-plugin-context.js';
+import { createRouterCodeSplitterPlugin } from './core/router-code-splitter-plugin.js';
+import { createRouterGeneratorPlugin } from './core/router-generator-plugin.js';
+import { unpluginRouterComposedFactory } from './core/router-composed-plugin.js';
+import { createVitePlugin } from 'unplugin';
+//#region src/vite.ts
+var defaultRouterPluginContext = createRouterPluginContext();
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanstackRouterGenerator()],
+ *   // ...
+ * })
+ * ```
+ */
+var tanstackRouterGenerator = (options, routerPluginContext) => {
+	const pluginContext = routerPluginContext ?? defaultRouterPluginContext;
+	return createVitePlugin((pluginOptions) =>
+		createRouterGeneratorPlugin(pluginOptions, pluginContext),
+	)(options);
+};
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanStackRouterCodeSplitter()],
+ *   // ...
+ * })
+ * ```
+ */
+var tanStackRouterCodeSplitter = (options, routerPluginContext) => {
+	const pluginContext = routerPluginContext ?? defaultRouterPluginContext;
+	return createVitePlugin((pluginOptions) =>
+		createRouterCodeSplitterPlugin(pluginOptions, pluginContext),
+	)(options);
+};
+/**
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [tanstackRouter()],
+ *   // ...
+ * })
+ * ```
+ */
+var tanstackRouter = createVitePlugin(unpluginRouterComposedFactory);
+/**
+ * @deprecated Use `tanstackRouter` instead.
+ */
+var TanStackRouterVite = tanstackRouter;
+//#endregion
+export {
+	TanStackRouterVite,
+	configSchema,
+	tanstackRouter as default,
+	tanstackRouter,
+	getConfig,
+	tanStackRouterCodeSplitter,
+	tanstackRouterGenerator,
+};

package/src/internal/router-plugin/webpack.d.ts

@@ -0,0 +1,50 @@
+import { configSchema, CodeSplittingOptions, Config } from './core/config.js';
+import { RouterPluginContext } from './core/router-plugin-context.js';
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [TanStackRouterGeneratorWebpack()],
+ * }
+ * ```
+ */
+declare const TanStackRouterGeneratorWebpack: (
+	options?: Partial<Config>,
+	routerPluginContext?: RouterPluginContext,
+) => import('unplugin').WebpackPluginInstance;
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [TanStackRouterCodeSplitterWebpack()],
+ * }
+ * ```
+ */
+declare const TanStackRouterCodeSplitterWebpack: (
+	options?: Partial<Config>,
+	routerPluginContext?: RouterPluginContext,
+) => import('unplugin').WebpackPluginInstance;
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [tanstackRouter()],
+ * }
+ * ```
+ */
+declare const TanStackRouterWebpack: (
+	options?: unknown,
+) => import('unplugin').WebpackPluginInstance;
+declare const tanstackRouter: (options?: unknown) => import('unplugin').WebpackPluginInstance;
+export default TanStackRouterWebpack;
+export {
+	configSchema,
+	TanStackRouterWebpack,
+	TanStackRouterGeneratorWebpack,
+	TanStackRouterCodeSplitterWebpack,
+	tanstackRouter,
+};
+export type { Config, CodeSplittingOptions, RouterPluginContext };

package/src/internal/router-plugin/webpack.js

@@ -0,0 +1,77 @@
+import { configSchema } from './core/config.js';
+import { createRouterPluginContext } from './core/router-plugin-context.js';
+import { createRouterCodeSplitterPlugin } from './core/router-code-splitter-plugin.js';
+import { createRouterGeneratorPlugin } from './core/router-generator-plugin.js';
+import { unpluginRouterComposedFactory } from './core/router-composed-plugin.js';
+import { createWebpackPlugin } from 'unplugin';
+//#region src/webpack.ts
+var defaultRouterPluginContext = createRouterPluginContext();
+/**
+ * Webpack uses `module.hot` / `import.meta.webpackHot` HMR. Force
+ * `plugin.hmr.style = 'webpack'` so the router HMR adapter emits the correct
+ * accept/dispose shape regardless of user config.
+ */
+function withWebpackHmrStyle(options) {
+	return {
+		...options,
+		plugin: {
+			...options?.plugin,
+			hmr: {
+				...options?.plugin?.hmr,
+				style: 'webpack',
+			},
+		},
+	};
+}
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [TanStackRouterGeneratorWebpack()],
+ * }
+ * ```
+ */
+var TanStackRouterGeneratorWebpack = (options, routerPluginContext) => {
+	const pluginContext = routerPluginContext ?? defaultRouterPluginContext;
+	return createWebpackPlugin((pluginOptions) =>
+		createRouterGeneratorPlugin(pluginOptions, pluginContext),
+	)(options);
+};
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [TanStackRouterCodeSplitterWebpack()],
+ * }
+ * ```
+ */
+var TanStackRouterCodeSplitterWebpack = (options, routerPluginContext) => {
+	const pluginContext = routerPluginContext ?? defaultRouterPluginContext;
+	return createWebpackPlugin((pluginOptions) =>
+		createRouterCodeSplitterPlugin(withWebpackHmrStyle(pluginOptions), pluginContext),
+	)(options);
+};
+/**
+ * @example
+ * ```ts
+ * export default {
+ *   // ...
+ *   plugins: [tanstackRouter()],
+ * }
+ * ```
+ */
+var TanStackRouterWebpack = /* @__PURE__ */ createWebpackPlugin((options, meta) =>
+	unpluginRouterComposedFactory(withWebpackHmrStyle(options), meta),
+);
+var tanstackRouter = TanStackRouterWebpack;
+//#endregion
+export {
+	TanStackRouterCodeSplitterWebpack,
+	TanStackRouterGeneratorWebpack,
+	TanStackRouterWebpack,
+	TanStackRouterWebpack as default,
+	configSchema,
+	tanstackRouter,
+};

package/src/internal/start-plugin-core/build-sitemap.d.ts

@@ -0,0 +1,34 @@
+import { TanStackStartOutputConfig } from './schema.js';
+export type SitemapUrl = {
+	loc: string;
+	lastmod: string;
+	priority?: number;
+	changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+	alternateRefs?: Array<{
+		href: string;
+		hreflang?: string;
+	}>;
+	images?: Array<{
+		loc: string;
+		title?: string;
+		caption?: string;
+	}>;
+	news?: {
+		publication: {
+			name: string;
+			language: string;
+		};
+		publicationDate: string | Date;
+		title: string;
+	};
+};
+export type SitemapData = {
+	urls: Array<SitemapUrl>;
+};
+export declare function buildSitemap({
+	startConfig,
+	publicDir,
+}: {
+	startConfig: TanStackStartOutputConfig;
+	publicDir: string;
+}): void;

package/src/internal/start-plugin-core/build-sitemap.js

@@ -0,0 +1,125 @@
+import { createLogger } from './utils.js';
+import path from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { create } from 'xmlbuilder2';
+//#region src/build-sitemap.ts
+function buildSitemapJson(pages, host) {
+	const slash = checkSlash(host);
+	return {
+		urls: pages
+			.filter((page) => {
+				return page.sitemap?.exclude !== true;
+			})
+			.map((page) => ({
+				loc: `${host}${slash}${page.path.replace(/^\/+/g, '')}`,
+				lastmod: page.sitemap?.lastmod
+					? new Date(page.sitemap.lastmod).toISOString().split('T')[0]
+					: /* @__PURE__ */ new Date().toISOString().split('T')[0],
+				priority: page.sitemap?.priority,
+				changefreq: page.sitemap?.changefreq,
+				alternateRefs: page.sitemap?.alternateRefs,
+				images: page.sitemap?.images,
+				news: page.sitemap?.news,
+			})),
+	};
+}
+function jsonToXml(sitemapData) {
+	const sitemap = createXml('urlset');
+	for (const item of sitemapData.urls) {
+		const page = sitemap.ele('url');
+		page.ele('loc').txt(item.loc);
+		page.ele('lastmod').txt(item.lastmod);
+		if (item.priority !== void 0) page.ele('priority').txt(item.priority.toString());
+		if (item.changefreq) page.ele('changefreq').txt(item.changefreq);
+		if (item.alternateRefs?.length)
+			for (const ref of item.alternateRefs) {
+				const alternateRef = page.ele('xhtml:link');
+				alternateRef.att('rel', 'alternate');
+				alternateRef.att('href', ref.href);
+				if (ref.hreflang) alternateRef.att('hreflang', ref.hreflang);
+			}
+		if (item.images?.length)
+			for (const image of item.images) {
+				const imageElement = page.ele('image:image');
+				imageElement.ele('image:loc').txt(image.loc);
+				if (image.title) imageElement.ele('image:title').txt(image.title);
+				if (image.caption) imageElement.ele('image:caption').txt(image.caption);
+			}
+		if (item.news) {
+			const newsElement = page.ele('news:news');
+			const publication = newsElement.ele('news:publication');
+			publication.ele('news:name').txt(item.news.publication.name);
+			publication.ele('news:language').txt(item.news.publication.language);
+			newsElement
+				.ele('news:publication_date')
+				.txt(new Date(item.news.publicationDate).toISOString().split('T')[0]);
+			newsElement.ele('news:title').txt(item.news.title);
+		}
+	}
+	return sitemap.end({ prettyPrint: true });
+}
+function buildSitemap({ startConfig, publicDir }) {
+	const logger = createLogger('sitemap');
+	let sitemapOptions = startConfig.sitemap;
+	if (!sitemapOptions && startConfig.pages.length)
+		sitemapOptions = {
+			enabled: true,
+			outputPath: 'sitemap.xml',
+		};
+	if (!sitemapOptions?.enabled) throw new Error('Sitemap is not enabled');
+	const { host, outputPath } = sitemapOptions;
+	if (!host) {
+		if (!startConfig.sitemap) {
+			logger.info(
+				'Hint: Pages found, but no sitemap host has been set. To enable sitemap generation, set the `sitemap.host` option.',
+			);
+			return;
+		}
+		throw new Error('Sitemap host is not set and required to build the sitemap.');
+	}
+	if (!outputPath) throw new Error('Sitemap output path is not set');
+	const { pages } = startConfig;
+	if (!pages.length) {
+		logger.info('No pages were found to build the sitemap. Skipping...');
+		return;
+	}
+	logger.info('Building Sitemap...');
+	const sitemapData = buildSitemapJson(pages, host);
+	const xmlOutputPath = path.join(publicDir, outputPath);
+	const pagesOutputPath = path.join(publicDir, 'pages.json');
+	try {
+		logger.info(`Writing sitemap XML at ${xmlOutputPath}`);
+		writeFileSync(xmlOutputPath, jsonToXml(sitemapData));
+		logger.info(`Writing pages data at ${pagesOutputPath}`);
+		writeFileSync(
+			pagesOutputPath,
+			JSON.stringify(
+				{
+					pages,
+					host,
+					lastBuilt: /* @__PURE__ */ new Date().toISOString(),
+				},
+				null,
+				2,
+			),
+		);
+	} catch (e) {
+		logger.error(`Unable to write sitemap files`, e);
+	}
+}
+function createXml(elementName) {
+	return create({
+		version: '1.0',
+		encoding: 'UTF-8',
+	})
+		.ele(elementName, {
+			xmlns: 'https://www.sitemaps.org/schemas/sitemap/0.9',
+			'xmlns:xhtml': 'http://www.w3.org/1999/xhtml',
+		})
+		.com(`This file was automatically generated by TanStack Start.`);
+}
+function checkSlash(host) {
+	return host.slice(-1) === '/' ? '' : '/';
+}
+//#endregion
+export { buildSitemap };

package/src/internal/start-plugin-core/config-context.d.ts

@@ -0,0 +1,30 @@
+import { resolveStartEntryPlan } from './planning.js';
+import { TanStackStartOutputConfig } from './schema.js';
+import { GetConfigFn, ResolvedStartConfig, TanStackStartCoreOptions } from './types.js';
+export interface StartConfigContext {
+	resolvedStartConfig: ResolvedStartConfig;
+	getConfig: GetConfigFn;
+	resolveEntries: () => ReturnType<typeof resolveStartEntryPlan>;
+}
+export declare function createStartConfigContext<TInputConfig>(opts: {
+	corePluginOpts: TanStackStartCoreOptions;
+	startPluginOpts: TInputConfig | undefined;
+	parseConfig: (
+		opts: TInputConfig | undefined,
+		core: {
+			framework: TanStackStartCoreOptions['framework'];
+		},
+		root: string,
+	) => TanStackStartOutputConfig;
+}): StartConfigContext;
+export declare function applyResolvedBaseAndOutput(opts: {
+	resolvedStartConfig: ResolvedStartConfig;
+	root: string;
+	publicBase: string;
+	clientOutputDirectory: string;
+	serverOutputDirectory: string;
+}): void;
+export declare function applyResolvedRouterBasepath(opts: {
+	resolvedStartConfig: ResolvedStartConfig;
+	startConfig: TanStackStartOutputConfig;
+}): string;

package/src/internal/start-plugin-core/config-context.js

@@ -0,0 +1,89 @@
+import {
+	createNormalizedBasePaths,
+	createNormalizedOutputDirectories,
+	deriveRouterBasepath,
+	resolveStartEntryPlan,
+} from './planning.js';
+//#region src/config-context.ts
+function createStartConfigContext(opts) {
+	const resolvedStartConfig = {
+		root: '',
+		startFilePath: void 0,
+		routerFilePath: '',
+		srcDirectory: '',
+		basePaths: {
+			publicBase: '',
+			assetBase: {
+				dev: '',
+				build: '',
+			},
+		},
+		outputDirectories: {
+			client: '',
+			server: '',
+		},
+	};
+	let startConfig = null;
+	let resolvedEntryPlanCache;
+	function requireRoot() {
+		if (!resolvedStartConfig.root) throw new Error(`Cannot get config before root is resolved`);
+		return resolvedStartConfig.root;
+	}
+	function getStartConfig() {
+		if (!startConfig)
+			startConfig = opts.parseConfig(
+				opts.startPluginOpts,
+				{ framework: opts.corePluginOpts.framework },
+				requireRoot(),
+			);
+		return startConfig;
+	}
+	function getResolvedEntryPlan() {
+		if (resolvedEntryPlanCache) return resolvedEntryPlanCache;
+		resolvedEntryPlanCache = resolveStartEntryPlan({
+			root: requireRoot(),
+			startConfig: getStartConfig(),
+			defaultEntryPaths: opts.corePluginOpts.defaultEntryPaths,
+		});
+		Object.assign(resolvedStartConfig, {
+			srcDirectory: resolvedEntryPlanCache.srcDirectory,
+			startFilePath: resolvedEntryPlanCache.startFilePath,
+			routerFilePath: resolvedEntryPlanCache.routerFilePath,
+		});
+		return resolvedEntryPlanCache;
+	}
+	const getConfig = () => {
+		const startConfig = getStartConfig();
+		getResolvedEntryPlan();
+		return {
+			startConfig,
+			resolvedStartConfig,
+		};
+	};
+	function resolveEntries() {
+		return getResolvedEntryPlan();
+	}
+	return {
+		resolvedStartConfig,
+		getConfig,
+		resolveEntries,
+	};
+}
+function applyResolvedBaseAndOutput(opts) {
+	opts.resolvedStartConfig.root = opts.root;
+	opts.resolvedStartConfig.basePaths = createNormalizedBasePaths({ publicBase: opts.publicBase });
+	opts.resolvedStartConfig.outputDirectories = createNormalizedOutputDirectories({
+		client: opts.clientOutputDirectory,
+		server: opts.serverOutputDirectory,
+	});
+}
+function applyResolvedRouterBasepath(opts) {
+	const routerBasepath = deriveRouterBasepath({
+		configuredBasepath: opts.startConfig.router.basepath,
+		publicBase: opts.resolvedStartConfig.basePaths.publicBase,
+	});
+	opts.startConfig.router.basepath = routerBasepath;
+	return routerBasepath;
+}
+//#endregion
+export { applyResolvedBaseAndOutput, applyResolvedRouterBasepath, createStartConfigContext };

package/src/internal/start-plugin-core/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const START_ENVIRONMENT_NAMES: {
+	readonly server: 'ssr';
+	readonly client: 'client';
+};
+export type StartEnvironmentName =
+	(typeof START_ENVIRONMENT_NAMES)[keyof typeof START_ENVIRONMENT_NAMES];
+export declare const VITE_ENVIRONMENT_NAMES: {
+	readonly server: 'ssr';
+	readonly client: 'client';
+};
+export type ViteEnvironmentNames = StartEnvironmentName;
+export declare const ENTRY_POINTS: {
+	readonly client: 'virtual:tanstack-start-client-entry';
+	readonly server: 'virtual:tanstack-start-server-entry';
+	readonly start: '#tanstack-start-entry';
+	readonly router: '#tanstack-router-entry';
+};
+export declare const DEV_CLIENT_ENTRY = 'virtual:tanstack-start-dev-client-entry';
+export declare const SERVER_FN_LOOKUP = 'server-fn-module-lookup';
+export declare const TRANSFORM_ID_REGEX: RegExp[];