remove cli config

vike/node/api/build.ts

@@ -1,12 +1,10 @@
 export { build }
 
-import type { InlineCliConfig } from './utils.js'
-
-async function build(config: InlineCliConfig = {}) {
+async function build() {
   const { default: pc } = await import('@brillout/picocolors')
   const { build: buildVite } = await import('vite')
   const { resolveConfig, isCliCall } = await import('./utils.js')
-  const { viteConfig, vikeConfigResolved, viteConfigResolved: resolvedConfig } = await resolveConfig(config, 'build')
+  const { viteConfig, vikeConfigResolved, viteConfigResolved: resolvedConfig } = await resolveConfig({}, 'build')
 
   const clientOutput = await buildVite(viteConfig).catch((error) => {
     if (!isCliCall) {

vike/node/api/prerender.ts

@@ -5,10 +5,10 @@ import type { PrerenderOptions } from '../prerender/runPrerender.js'
 
 // only called programatically on user-land or by running vike prerender
 // adds the vike plugin if not present
-async function prerender(options: PrerenderOptions) {
+async function prerender(options: PrerenderOptions = {}) {
   const { resolveConfig } = await import('./utils.js')
-  const { viteConfig, pageContextInit, onPagePrerender } = options
-  const resolved = await resolveConfig({ vite: viteConfig }, 'build')
+  const { viteConfig = {}, pageContextInit, onPagePrerender } = options
+  const resolved = await resolveConfig(viteConfig, 'build')
   return _prerender({ viteConfig: resolved.viteConfig, pageContextInit, onPagePrerender })
 }
 

vike/node/api/preview.ts

@@ -1,12 +1,10 @@
 export { preview }
 
-import type { InlineCliConfig } from './utils.js'
-
-async function preview(config: InlineCliConfig = {}) {
+async function preview() {
   const { preview: previewVite } = await import('vite')
   const { resolveConfig, isCliCall } = await import('./utils.js')
   // Adds vike to viteConfig if not present
-  const { viteConfig, viteConfigResolved: resolvedConfig } = await resolveConfig(config, 'preview')
+  const { viteConfig, viteConfigResolved: resolvedConfig } = await resolveConfig({}, 'preview')
   if (!isCliCall) return previewVite(viteConfig)
 
   const { default: pc } = await import('@brillout/picocolors')

vike/node/api/serve.ts

@@ -1,12 +1,10 @@
 export { serve }
 
-import type { InlineCliConfig } from './utils.js'
-
-async function serve(config: InlineCliConfig = {}) {
+async function serve() {
   const { createServer: createServerVite } = await import('vite')
   const { resolveConfig, isCliCall } = await import('./utils.js')
   // Adds vike to viteConfig if not present
-  const { viteConfig, viteConfigResolved: resolvedConfig } = await resolveConfig(config, 'serve')
+  const { viteConfig, viteConfigResolved: resolvedConfig } = await resolveConfig({}, 'serve')
   if (!isCliCall) return createServerVite(viteConfig)
 
   const { default: pc } = await import('@brillout/picocolors')

vike/node/api/utils.ts

@@ -1,16 +1,11 @@
-export type { InlineCliConfig }
 export { resolveConfig }
 export { isCliCall, setCliCall }
 
 import type { InlineConfig } from 'vite'
-import type { ConfigVikeResolved, ConfigVikeUserProvided } from '../../shared/ConfigVike.js'
 
-type InlineCliConfig = ConfigVikeUserProvided & { vite?: InlineConfig }
-
-async function resolveConfig(config: InlineCliConfig, command: 'build' | 'serve' | 'preview') {
+async function resolveConfig(viteConfig: InlineConfig, command: 'build' | 'serve' | 'preview') {
   const { default: pc } = await import('@brillout/picocolors')
   const { resolveConfig: resolveViteConfig, mergeConfig } = await import('vite')
-  const { vite: viteConfig = {}, ...vikeConfig } = config
   let nodeEnv = 'development'
   if (['build', 'preview'].includes(command)) {
     nodeEnv = 'production'
@@ -30,36 +25,27 @@ async function resolveConfig(config: InlineCliConfig, command: 'build' | 'serve'
   })
 
   // Add vike to plugins if not present
-  if (!viteConfigResolved.plugins.some((p) => p.name === 'vike:resolveVikeConfig')) {
+  if (!viteConfigResolved.plugins.some((p) => p.name.startsWith('vike:'))) {
     const { plugin } = await import('../plugin/index.js')
 
-    config.vite ??= {}
-    config.vite.plugins ??= []
-    config.vite.plugins.push(plugin(vikeConfig))
+    viteConfig ??= {}
+    viteConfig.plugins ??= []
+    viteConfig.plugins.push(plugin())
 
-    return resolveConfig(config, command)
+    return resolveConfig(viteConfig, command)
   }
 
   const { getConfigVike } = await import('../shared/getConfigVike.js')
   const vikeConfigResolved = await getConfigVike(viteConfigResolved)
-  // merge the inline config from the cli/api with the config resolved by vike
-  // for example:
-  // vike.config.js -> prerender:false
-  // --config={prerender:true}
-  // merged - {prerender:true}
-  const mergedConfig = mergeConfig(vikeConfigResolved, config) as ConfigVikeResolved & {
-    vite?: InlineConfig
-  }
-  const { vite: viteConfigMerged, ...mergedVikeConfigResolved } = mergedConfig
 
   return {
     viteConfig,
-    vikeConfigResolved: mergedVikeConfigResolved,
+    vikeConfigResolved,
     viteConfigResolved
   }
 }
 
 let isCliCall = false
 function setCliCall() {
   isCliCall = true
-}
+}

vike/node/cli/bin.ts

@@ -1,45 +1,35 @@
 import { cac } from 'cac'
 import { projectInfo } from '../../utils/projectInfo.js'
 import { assertUsage } from '../../utils/assert.js'
-import { setCliCall, type InlineCliConfig } from '../api/utils.js'
+import { setCliCall } from '../api/utils.js'
 
 setCliCall()
 
 const cli = cac(projectInfo.projectName)
 export const startTime = performance.now()
 
-cli.option('-c, --config [string]', `[string] use specified config`)
-
-cli.command('prerender', 'Pre-render the HTML of your pages').action(async (options) => {
-  const config = parseConfigString(options.config)
+cli.command('prerender', 'Pre-render the HTML of your pages').action(async () => {
   const { prerender } = await import('../api/prerender.js')
-  setInlineCliConfig(config)
-  await prerender({
-    viteConfig: config.vite
-  })
+  await prerender()
 })
 
 cli
   .command('', 'Start the development server')
   .alias('serve')
   .alias('dev')
-  .action(async (options) => {
-    const config = parseConfigString(options.config)
+  .action(async () => {
     const { serve } = await import('../api/serve.js')
-    return serve(config)
+    return serve()
   })
 
-cli.command('build', 'Build for production').action(async (options) => {
-  const config = parseConfigString(options.config)
-  setInlineCliConfig(config)
+cli.command('build', 'Build for production').action(async () => {
   const { build } = await import('../api/build.js')
-  return build(config)
+  return build()
 })
 
-cli.command('preview', 'Start a preview server using production build').action(async (options) => {
-  const config = parseConfigString(options.config)
+cli.command('preview', 'Start a preview server using production build').action(async () => {
   const { preview } = await import('../api/preview.js')
-  return preview(config)
+  return preview()
 })
 
 // Listen to unknown commands
@@ -55,19 +45,3 @@ cli.parse()
 process.on('unhandledRejection', (rejectValue) => {
   throw rejectValue
 })
-
-function parseConfigString(configString?: string): InlineCliConfig {
-  if (!configString) {
-    return {}
-  }
-  const config = eval(`(${configString})`)
-  return config
-}
-
-function setInlineCliConfig(config: InlineCliConfig) {
-  // skip the api layer of the prerender function and directly pass the prerender config to vike
-  // so the exposed prerender api can be preserved
-  config.vite ??= {}
-  //@ts-ignore
-  config.vite._vike_cli = { prerender: config.prerender }
-}