@tanstack/start-plugin-core 1.20.3-alpha.1

package/src/schema.ts

@@ -0,0 +1,193 @@
+import path from 'node:path'
+import { existsSync } from 'node:fs'
+import { z } from 'zod'
+import { configSchema, getConfig } from '@tanstack/router-generator'
+import type { NitroConfig } from 'nitropack'
+
+const tsrConfig = configSchema.partial().extend({
+  srcDirectory: z.string().optional().default('src'),
+})
+
+export function createTanStackConfig<
+  TFrameworkPlugin extends Record<string, unknown>,
+>(frameworkPlugin?: TFrameworkPlugin) {
+  const schema = createTanStackStartOptionsSchema(frameworkPlugin)
+
+  return {
+    schema,
+    parse: (opts?: z.input<typeof schema>) => {
+      const options = schema.parse(opts)
+
+      const srcDirectory = options.tsr.srcDirectory
+
+      const routesDirectory =
+        options.tsr.routesDirectory ?? path.join(srcDirectory, 'routes')
+
+      const generatedRouteTree =
+        options.tsr.generatedRouteTree ??
+        path.join(srcDirectory, 'routeTree.gen.ts')
+
+      const clientEntryPath = (() => {
+        if (options.client.entry) {
+          return path.join(srcDirectory, options.client.entry)
+        }
+
+        if (existsSync(path.join(srcDirectory, 'client.tsx'))) {
+          return path.join(srcDirectory, 'client.tsx')
+        }
+
+        return '/~start/default-client-entry'
+      })()
+
+      const serverEntryPath = (() => {
+        if (options.server.entry) {
+          return path.join(srcDirectory, options.server.entry)
+        }
+
+        if (existsSync(path.join(srcDirectory, 'server.tsx'))) {
+          return path.join(srcDirectory, 'server.tsx')
+        }
+
+        return '/~start/default-server-entry'
+      })()
+
+      return {
+        ...options,
+        tsr: {
+          ...options.tsr,
+          ...getConfig({
+            ...options.tsr,
+            routesDirectory,
+            generatedRouteTree,
+          }),
+        },
+        clientEntryPath,
+        serverEntryPath,
+      }
+    },
+  }
+}
+
+export function createTanStackStartOptionsSchema(
+  frameworkPlugin: Record<string, unknown> = {},
+) {
+  return z
+    .object({
+      root: z.string().optional().default(process.cwd()),
+      target: z.custom<NitroConfig['preset']>().optional(),
+      ...frameworkPlugin,
+      tsr: tsrConfig.optional().default({}),
+      client: z
+        .object({
+          entry: z.string().optional(),
+          base: z.string().optional().default('/_build'),
+        })
+        .optional()
+        .default({}),
+      server: z
+        .object({
+          entry: z.string().optional(),
+        })
+        .optional()
+        .default({}),
+      serverFns: z
+        .object({
+          base: z.string().optional().default('/_server'),
+        })
+        .optional()
+        .default({}),
+      public: z
+        .object({
+          dir: z.string().optional().default('public'),
+          base: z.string().optional().default('/'),
+        })
+        .optional()
+        .default({}),
+      pages: z
+        .array(z.union([z.string(), pageSchema]))
+        .optional()
+        .default([]),
+      sitemap: pagePrerenderOptionsSchema
+        .extend({
+          host: z.string().optional(),
+        })
+        .optional(),
+      prerender: z
+        .object({
+          enabled: z.boolean().optional(),
+          concurrency: z.number().optional(),
+          filter: z.function().args(pageSchema).returns(z.any()).optional(),
+          failOnError: z.boolean().optional(),
+        })
+        .and(pagePrerenderOptionsSchema.optional())
+        .optional(),
+    })
+    .optional()
+    .default({})
+}
+
+const pageSitemapOptionsSchema = z.object({
+  exclude: z.boolean().optional(),
+  priority: z.number().min(0).max(1).optional(),
+  changefreq: z
+    .enum(['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never'])
+    .optional(),
+  lastmod: z.union([z.string(), z.date()]).optional(),
+  alternateRefs: z
+    .array(
+      z.object({
+        href: z.string(),
+        hreflang: z.string(),
+      }),
+    )
+    .optional(),
+  images: z
+    .array(
+      z.object({
+        loc: z.string(),
+        caption: z.string().optional(),
+        title: z.string().optional(),
+      }),
+    )
+    .optional(),
+  news: z
+    .object({
+      publication: z.object({
+        name: z.string(),
+        language: z.string(),
+      }),
+      publicationDate: z.union([z.string(), z.date()]),
+      title: z.string(),
+    })
+    .optional(),
+})
+
+const pageBaseSchema = z.object({
+  path: z.string(),
+  sitemap: pageSitemapOptionsSchema.optional(),
+  fromCrawl: z.boolean().optional(),
+})
+
+const pagePrerenderOptionsSchema = z.object({
+  enabled: z.boolean().optional(),
+  autoSubfolderIndex: z.boolean().optional(),
+  crawlLinks: z.boolean().optional(),
+  retryCount: z.number().optional(),
+  retryDelay: z.number().optional(),
+  onSuccess: z
+    .function()
+    .args(
+      z.object({
+        page: pageBaseSchema,
+        html: z.string(),
+      }),
+    )
+    .returns(z.any())
+    .optional(),
+})
+
+export const pageSchema = pageBaseSchema.extend({
+  prerender: pagePrerenderOptionsSchema.optional(),
+})
+
+export type Page = z.infer<typeof pageSchema>

package/src/start-compiler-plugin.ts

@@ -0,0 +1,111 @@
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { logDiff } from '@tanstack/router-utils'
+
+import { compileStartOutputFactory } from './compilers'
+import type { Plugin } from 'vite'
+import type { CompileStartFrameworkOptions } from './compilers'
+
+const debug =
+  process.env.TSR_VITE_DEBUG &&
+  ['true', 'start-plugin'].includes(process.env.TSR_VITE_DEBUG)
+
+export type TanStackStartViteOptions = {
+  globalMiddlewareEntry: string
+}
+
+const transformFuncs = [
+  'createServerFn',
+  'createMiddleware',
+  'serverOnly',
+  'clientOnly',
+  'createIsomorphicFn',
+  'createServerFileRoute',
+]
+
+const tokenRegex = new RegExp(transformFuncs.join('|'))
+
+export function TanStackStartCompilerPlugin(
+  framework: CompileStartFrameworkOptions,
+  inputOpts?: {
+    client?: {
+      envName?: string
+    }
+    server?: {
+      envName?: string
+    }
+  },
+): Plugin {
+  const opts = {
+    client: {
+      envName: 'client',
+      ...inputOpts?.client,
+    },
+    server: {
+      envName: 'server',
+      ...inputOpts?.server,
+    },
+  }
+
+  return {
+    name: 'vite-plugin-tanstack-start-create-server-fn',
+    enforce: 'pre',
+    applyToEnvironment(env) {
+      return [opts.client.envName, opts.server.envName].includes(env.name)
+    },
+    transform(code, id) {
+      const env =
+        this.environment.name === opts.client.envName
+          ? 'client'
+          : this.environment.name === opts.server.envName
+            ? 'server'
+            : (() => {
+                throw new Error(
+                  `Environment ${this.environment.name} not configured`,
+                )
+              })()
+
+      return transformCode({
+        code,
+        id,
+        env,
+        framework,
+      })
+    },
+  }
+}
+
+function transformCode(opts: {
+  code: string
+  id: string
+  env: 'server' | 'client'
+  framework: CompileStartFrameworkOptions
+}) {
+  const { code, env, framework } = opts
+  let { id } = opts
+
+  const url = pathToFileURL(id)
+  url.searchParams.delete('v')
+  id = fileURLToPath(url).replace(/\\/g, '/')
+
+  const includesToken = tokenRegex.test(code)
+
+  if (!includesToken) {
+    return null
+  }
+
+  if (debug) console.info(`${env} Compiling Start: `, id)
+
+  const compileStartOutput = compileStartOutputFactory(framework)
+  const compiled = compileStartOutput({
+    code,
+    filename: id,
+    env,
+  })
+
+  if (debug) {
+    logDiff(code, compiled.code)
+    console.log('Output:\n', compiled.code + '\n\n')
+  }
+
+  return compiled
+}

package/src/start-server-routes-plugin/config.ts

@@ -0,0 +1,8 @@
+import { baseConfigSchema } from '@tanstack/router-generator'
+import { z } from 'zod'
+
+export const configSchema = baseConfigSchema.extend({
+  srcDirectory: z.string().optional().default('src'),
+})
+
+export type Config = z.infer<typeof configSchema>