@vindo/cli 0.0.2 → 0.0.3

package/bin/builder/index.js

@@ -0,0 +1,240 @@
+
+const es = require('esbuild')
+const sass = require('sass')
+const util = require('../util')
+const config = require('../config')
+
+
+module.exports = exports = Object.create(util, {
+	config: {
+		value: config
+	}
+})
+const {file, string, resolve} = util
+
+
+/**
+ * Get basename
+ * @param {string} file
+ */
+function getname(val) {
+	return file.path.parse(val).name
+}
+
+
+/**
+ * Get chunk
+ * @param {string} dir 
+ */
+async function getChunk(dir) {
+	var code = []
+	var files = await file.readdir(dir, {recursive: true})
+
+	for(var {name, parentPath} of files) {
+		if(!/\.(js|tsx|jsx)$/.test(name)) {
+			continue
+		}
+
+		var name = getname(name)
+		if(name) {
+			var _file = file.path.join(parentPath, name)
+
+			if(name == 'index') {
+				_file = parentPath
+				name = getname(parentPath)
+			}
+			code.push(`import ${name} from '${_file}'`, `data.${name} = ${name}`)
+		}
+	}
+	return code
+}
+
+
+/**
+ * Get imported files
+ * @param {object} opt 
+ * @param {string} data 
+ */
+async function getImports(entry, data) {
+	var imp = []
+	var matches = data.matchAll(/import\s(.*)\sfrom.*('|"|\/)([a-zA-Z0-9_-]+)('|")/g)
+
+	for(var item of matches) {
+		if(/(\.\/|)components\//.test(item[0])) {
+			imp.push(`var ${item[1]} = ${item[3]}`)
+		}
+		else if(/(\.\/)/.test(item[0])) {
+			imp.push(item[0].replace(/('|")(\.\/)/, `$1${resolve.dirname(entry)}/`))
+		}
+		else {
+			imp.push(item[0])
+		}
+	}
+	return imp
+}
+
+
+/**
+ * Get all imports from components directory
+ * @param {object} opt 
+ */
+async function getComponents(opt) {
+	var data = []
+	
+	if(Array.isArray(opt.includes)) {
+		for(var item of opt.includes) {
+			const dir = file.path.resolve(process.cwd(), 'node_modules', item)
+			if(!file.exists(dir)) {
+				continue
+			}
+			data = data.concat(await getChunk(dir))
+		}
+	}
+
+	return data.concat(await getChunk(opt.components))
+}
+
+
+/**
+ * Collect components and assemble before building
+ * 
+ * @param {object} opt option
+ */
+async function startBuild(opt) {
+
+	if(!file.exists(opt.entry)) {
+		throw new Error(`Entry file not found. "${opt.entry}"`)
+	}
+	
+	const data = file.read(opt.entry)
+	const temp = file.read(opt.template)
+	
+	const impo = await getImports(opt.entry, data)
+	const comp = await getComponents(opt)
+
+	const code = string.replace(temp, {
+		REACT_COMPONENTS: comp.join('\n'),
+		IMPORTED_COMPONENTS: impo.join('\n'),
+		HEAD_COMPONENT: data.match(/<head.*>((.|\n)*)<\/head>/g)[0],
+		BODY_COMPONENT: data.match(/<body.*>((.|\n)*)<\/body>/g)[0]
+	})
+
+	await file.promises.writeFile(opt.chunk, code, {flag: 'w'})
+}
+
+
+/**
+ * Create a bundle file
+ * 
+ * @param {object} opt option
+ */
+async function startBundle(opt) {
+
+	if(!file.exists(opt.chunk)) {
+		return
+	}
+
+	const build = await es.build({
+		...opt.settings,
+		minify: opt.minify,
+		outfile: opt.outfile,
+		entryPoints: [opt.chunk],
+	})
+	const meta = Object.keys(build.metafile.outputs)[0]
+
+	/**
+	 * Append bundle hash to vindo config
+	 */
+	const name = opt.bundleName
+	const hash = await config.bundle(opt.name ?? name, [meta.match(/-(.*).js/)[1], name])
+	/**
+	 * Delete old bundle
+	 */
+	const files = file.readdir(resolve.root(opt.output))
+	files.forEach((item) => {
+		const matched = item.name.match(
+			new RegExp(`^${name}-([A-Z0-9+]{8})\.js$`)
+		)
+		if(matched) {
+			if(hash == matched[1]) {
+				return
+			}
+			file.unlink(file.path.resolve(item.parentPath, item.name))
+		}
+	})
+
+	if(file.exists(opt.chunk)) {
+		file.unlink(opt.chunk)
+	}
+}
+
+
+/**
+ * Compile scss file
+ * @param {object} opt 
+ */
+async function startCompile(opt) {
+	if(!opt.compileSass) {
+		return
+	}
+	const input = resolve.root(opt.compileSass.input)
+	const output = resolve.root(opt.compileSass.output)
+
+	/**
+	 * Create output dir if not exists
+	 */
+	if(!file.exists(input)) {
+		throw new Error(`No sass input directory found. "${input}"\n`)
+	}
+	
+	/**
+	 * Create output dir if not exists
+	 */
+	if(!file.exists(output)) {
+		await file.makedir(output)
+	}
+
+	function scss(name) {
+		return resolve.root(opt.compileSass.input, name)
+	}
+
+
+	const files = await file.readdir(input)
+	for(var item of files) {
+		
+		if(item.isFile()) {
+			const url = scss(item.name)
+			
+			if(file.exists(url)) {
+				const css = sass.compile(url).css
+
+				const out = resolve.root(
+					output,
+					item.name.replace(/\.scss/, '.css')
+				)
+				await file.promises.writeFile(out, css, {flag: 'w'})
+			}
+		}
+	}
+}
+
+
+/**
+ * 
+ * @param {object} config 
+ */
+exports.build = async function build(opt) {
+	/**
+	 * Create build directory
+	 */
+	await file.makedir(resolve.root(opt.output))
+
+	try {
+		await startBuild(opt)
+		await startBundle(opt)
+		await startCompile(opt)
+	}
+	catch(e) {
+		console.log(e)
+	}
+}

package/bin/{server.js → builder/server.js}

@@ -2,8 +2,8 @@ const {parse} = require('node:path')
 const {createServer} = require('node:http')
 
 
-module.exports = function(cb) {
 
+function server(cb) {
   return createServer((req, res) => {
     const url = parse(req.url)
 
@@ -37,7 +37,38 @@ module.exports = function(cb) {
     }
     res.headers({'Access-Control-Allow-Origin': '*'})
 
-    
+
     cb(req, res)
   })
+}
+
+
+module.exports = function(builder, cb) {
+  var file = builder.file
+  var events = builder.events
+  var resolve = builder.resolve
+  var option = builder.config.option
+
+  /**
+   * Run development server and create bundle
+   */
+  const http = server(async function(req, res) {
+    const data = await file.read(resolve.clidir('builder/development.js'))
+
+    if(req.isStream()) {
+      events.on('change', () => {
+        res.write(`data: {changed: true}\n\n`)
+      })
+    }
+
+    if(req.is('development')) {
+      res.headers({
+        'Content-Type':
+        'application/javascript'
+      })
+      res.end(data)
+    }
+  })
+
+  http.listen(option.port, cb)
 }

package/bin/builder/template.js

@@ -0,0 +1,43 @@
+
+import React from 'react'
+import * as client from '@vindo/react/client'
+
+/**
+ * This will be the holder of all components that will be imported
+ */
+const data = {}
+
+/**
+ * Template for components to be imported
+ */
+{REACT_COMPONENTS}
+{IMPORTED_COMPONENTS}
+
+
+data.Link = client.Link
+
+
+if(data.head || data.body) {
+  throw new SyntaxError(`Component name '${data.head ? 'head' : 'body'}' is a reserved name for SSR client components.`)
+}
+
+data.head = function head(meta) {
+  const {props:{children}} = React.cloneElement((
+    {HEAD_COMPONENT}
+  ))
+  return children
+}
+
+data.body = function body({meta}) {
+  var {props:{children}} = React.cloneElement(({BODY_COMPONENT}))
+
+  if(!Array.isArray(children)) {
+    children = React.Children.toArray(children)
+  }
+
+  return React.Children.map(children, (child, key) => {
+    return React.cloneElement(child, {key, ...arguments[0]})
+  })
+}
+
+client.render(document, data)

package/bin/config.js

@@ -1,70 +1,120 @@
 const util = require('./util')
-const config = util.use('@vindo/core/lib/config')
+const option = require('./option')
 
 
-module.exports = {
-	/**
-	 * Development script
-	 */
-	get devScript() {
-		return `http://127.0.0.1:${this.option.port}/development`
-	},
+const file = util.file
+const object = util.object
+const resolve = util.resolve
+const parseArgs = util.parseArgs
 
-	/**
-	 * Vindo config
-	 */
-	get vindo() {
-
-		return config.config({
-			buildOption: {
-				port: 2001,
-				minify: true,
-				watch: [
-					'./src'
-				],
-				output: './public'
-			}
-		})
-	},
 
-	/**
-	 * Build Options
-	 */
-	get option() {
-		const opt = this.vindo.buildOption
-		const args = this.argv()
-
-		return Object.assign(opt, {
-			...args,
-			settings: {
-				bundle: true,
-				format: 'esm',
-				logLevel: 'error',
-				allowOverwrite: true,
-			},
-			output: typeof args.output == 'string' ? args.output : opt.output,
-		})
-	},
+/**
+ * Exports
+ */
+module.exports = exports = Object.create({}, {
+	args: {get: getArgs},
+  option: {get: getOption},
+})
 
-	/**
-	 * Get args
-	 */
-	argv() {
-		const args = {}
-		const argv = process.argv
 
-		for(var i in argv) {
-			const pat = /^([a-z-]+)=/
+var path = resolve.root('vindo.json')
+if(!file.exists(path)) {
+	throw Error(`vindo.json file does not exists.`)    
+}
+var vindo = file.get(path)
+
+
+/**
+ * To string
+ */
+function toStr(data) {
+	return Buffer.from(JSON.stringify(data)).toString('base64').replace(/=/g, '')
+}
+
+/**
+ * Get arguments
+ */
+function getArgs() {
+	const args = process.argv
+
+	const command = args[2]
+	if(!option.commands.includes(command)) {
+		throw new ReferenceError('You need to provide at least one command.')
+	}
+
+  const {values} = parseArgs({
+    args: args.slice(3),
+    allowPositionals: true,
+    options: option.argsOptions,
+  })
+
+  return object.merge(values, {[command]: true, command})
+}
 
-			if(i < 2) {
-				continue
-			}
-			var arg = argv[i].split(pat, 3).filter(String)
 
-			if(arg) {
-				args[arg[0].substring(2)] = arg[1] ? arg[1] : true
-			}
+/**
+ * Get build option and arguments
+ */
+function getOption() {
+	var opt = object.merge(option.buildOptions, vindo.buildOptions)
+	var opt = object.merge(opt, getArgs())
+
+	return {
+		...opt,
+		name: vindo.name,
+		sass: option.sass,
+		settings: option.settings,
+
+		entry: resolve.root(opt.entry),
+		chunk: resolve.root(opt.output, 'chunk.jsx'),
+		template: resolve.clidir('builder', 'template.js'),
+		components: resolve.dirname(opt.entry, 'components'),
+		outfile: resolve.root(`${opt.output}/${opt.bundleName}.js`),
+		devScript: `http://127.0.0.1:${opt.port}/development`,
+	}
+}
+
+
+/**
+ * Add bundle
+ */
+exports.add = function add(opt) {
+  if(opt.package) {
+		var pkg = resolve.current('node_modules', opt.package, 'vindo.json')
+    if(!file.exists(pkg)) {
+			return
 		}
-		return args
+		
+		var pkg = file.get(pkg)
+    if(pkg) {
+      exports.bundle(null, pkg.bundles)
+    }
+  }
+}
+
+
+/**
+ * Add bundle metadata to vindo config
+ */
+exports.bundle = async function bundle(name, data) {
+	if(!vindo.bundles) {
+		vindo.bundles = {}
 	}
+	/**
+	 * Add new bundle
+	 */
+	if(name) {
+		vindo.bundles[name] = toStr(data)
+	}
+	/**
+	 * Merge to existing bundles
+	 */
+	else {
+		vindo.bundles = object.merge(vindo.bundles, data)
+	}
+	/**
+	 * Update the config file
+	 */
+	await file.promises.writeFile(path, JSON.stringify(vindo, null, 2), {flag: 'w'})
+	return data[0]
 }

package/bin/index.js

@@ -1,27 +1,28 @@
 #! /usr/bin/env node
 
 
-const util = require('./util')
-const build = require('./build')
-const server = require('./server')
-const config = require('./config')
+const builder = require('./builder')
+const server = require('./builder/server')
 
-const {watch} = require('chokidar')
 const kill = require('tree-kill')
-const {exec, spawn} = require('node:child_process')
-
-
-const {log, read, events, colors, resolve} = util
+const chokidar = require('chokidar')
+const childProcess = require('node:child_process')
 
 
 var child = null
-var option = config.option
+var log = builder.log
+var build = builder.build
+var config = builder.config
+var events = builder.events
+var colors = builder.colors
+var option = builder.config.option
+
 
 /**
  * Set to global environment
  */
-process.env.DEV_SERVER = config.devScript
-process.env.DEV_SERVER_PORT = config.option.port
+process.env.DEV_PORT = option.port
+process.env.DEV_SERVER = option.devScript
 
 
 /**
@@ -32,8 +33,7 @@ async function watcher(dirs, cb) {
     if(!Array.isArray(dirs)) {
       throw TypeError('Expected a value of type `Array` but received a `String`.')
     }
-    watch(dirs, {
-      // ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
+    chokidar.watch(dirs, {
       persistent: true
     })
     .on('change', (path) => cb({path}))
@@ -47,13 +47,18 @@ async function watcher(dirs, cb) {
 /**
  * 
  */
-function execute() {
+function execute(cmd) {
   var i = 0
-  var sp = exec(option.execute, {
+
+  if(Array.isArray(cmd)) {
+    cmd = cmd.join(' && ')
+  }
+
+  var sp = childProcess.exec(cmd, {
     env: process.env,
     cwd: process.cwd(),
   })
-  log('green', `[vindo] Running ${option.execute}`)
+  log('green', `[vindo] Running ${cmd}`)
 
   /**
    * Emit change event to reload client
@@ -94,7 +99,7 @@ function execute() {
  * Restart server and rebuild
  */
 function restart(event) {
-  log('gray', `[vindo] File changed '${event.path}'`)
+  log('green', `[vindo] File changed '${event.path}'`)
   log('green', `[vindo] Rebuilding...`)
   log('green', `[vindo] Restarting server...`)
 
@@ -103,36 +108,18 @@ function restart(event) {
   if(child) {
     kill(child.pid)
   }
-  child = execute()
+  child = execute(option.execute)
 }
 
 
 /**
- * Create server
+ * Start building and execute
  */
-const http = server(async (req, res) => {
-  if(req.isStream()) {
-    events.on('change', () => {
-      res.write(`data: {changed: true}\n\n`)
-    })
-  }
-
-  if(req.is('development')) {
-    res.headers({
-      'Content-Type':
-      'application/javascript'
-    })
-    res.end(await read(resolve.curr('development.js')))
-  }
-})
-
-
-
-http.listen(option.port, function() {
-  child = execute()
-
+function start() {
   build(option)
 
+  child = execute(option.execute)
+
   if(option.watch) {
     log('yellow', '[vindo] v0.0.1')
     log('yellow', `[vindo] Watching at ${option.watch}`)
@@ -140,4 +127,22 @@ http.listen(option.port, function() {
 
     watcher(option.watch, restart)
   }
-})
+}
+
+
+/**
+ * Command specific tasks
+ */
+switch(option.command) {
+  case 'add':
+    config.add(option)
+    break
+
+  case 'run':
+    server(builder, start)
+    break
+
+  case 'build':
+    build(option)
+    break
+}

package/bin/option.json

@@ -0,0 +1,46 @@
+{
+  "buildOptions": {
+    "port": 2001,
+    "minify": true,
+    "watch": [
+      "./src"
+    ],
+    "output": "./public",
+    "bundleName": "main"
+  },
+  "sass": {
+    "style": "compressed"
+  },
+  "settings": {
+    "bundle": true,
+		"metafile": true,
+    "format": "esm",
+    "jsx": "automatic",
+    "logLevel": "error",
+    "outfile": "dist/bundle.js",
+    "loader": {
+      ".js": "jsx",
+      ".jsx": "jsx",
+      ".ts": "tsx",
+      ".tsx": "tsx"
+    },
+    "entryNames": "[name]-[hash]",
+    "allowOverwrite": true,
+    "jsxImportSource": "react"
+  },
+  "commands": [
+    "run",
+    "add",
+    "build",
+    "bundle"
+  ],
+  "argsOptions": {
+    "add": {"type": "string"},
+    "port": {"type": "string"},
+    "package": {"type": "string"},
+    "output": {"type": "string"},
+    "mergeTo": {"type": "string"},
+    "execute": {"type": "string"},
+    "bundleName": {"type": "string"}
+  }
+}

package/bin/{util.js → util/index.js}

@@ -1,19 +1,13 @@
-const {styleText:color} = require('util')
-const {file, events, string} = require('@vindo/utility')
+const util = require('util')
+const {file, events, string, object} = require('@vindo/utility')
 
 
-
-module.exports = exports = Object.create(file, {
-  string: {value: string},
-  events: {value: events},
-})
-
 /**
  * Set colors
  */
 const colors = {
   set(name, text) {
-    return color(name, text)
+    return util.styleText(name, text)
   },
   colorize(text) {
     var text = text.toString()
@@ -31,46 +25,47 @@ const colors = {
     }
 
     for(var item of Object.values(pattern)) {
-      text = text.replace(item.pat, color(item.color, item.text))
+      text = text.replace(item.pat, util.styleText(item.color, item.text))
     }
     return text.trim()
   }
 }
 
-function replace(string, data = {}) {
-  if(Object.keys(data).length == 0) {
-    return string
-  }
-
-  function repl(v) {
-    var value = data[v.match(/([a-z_]+)/g)]
-    if(value) {
-      return value
-    }
-    return ''
-  }
-
-  if(string) {
-    var patt = string.match(/(\{[a-z_]+\})/g)
-    if(patt) {
-      return string.replace(new RegExp(patt.join('|'), 'g'), repl)
-    }
-  }
-  return string
-}
-
 /**
  * Resolve path
  */
 const resolve = {
-  main(...args) {
-    return file.path.resolve(process.cwd(), ...args)
+  /**
+   * Resolve either a root directory
+   * of where a command executed or the current working directory.
+   */
+  root(...args) {
+    var path = process.env.INIT_CWD
+    if(!path) {
+      path = process.cwd()
+    }
+    return file.path.resolve(path, ...args)
   },
-  curr(...args) {
-    return file.path.resolve(__dirname, ...args)
+  /**
+   * Resolve files of this cli package.
+   */
+  clidir(...args) {
+    return file.path.resolve(file.path.dirname(__dirname), ...args)
   },
+  /**
+   * Resolve file from current directory.
+   */
   dirname(path, ...args) {
-    return resolve.main(file.path.dirname(path), ...args)
+    if(!path) {
+      return
+    }
+    return resolve.root(file.path.dirname(path), ...args)
+  },
+  /**
+   * Resolve current working directory
+   */
+  current(...args) {
+    return file.path.resolve(process.cwd(), ...args)
   },
 }
 
@@ -79,42 +74,25 @@ const resolve = {
  */
 function log(name, text) {
   if(name) {
-    return console.log(color(name, text.toString().trim()))
+    return console.log(util.styleText(name, text.toString().trim()))
   }
   return console.log(text)
 }
 
-/**
- * Use module
- */
-function use(name) {
-  return require(resolve.main('node_modules', name))
-}
-
-/**
- * 
- * File system utilities
- * 
- */
-async function copy(dest) {
-  const src = resolve.curr(
-    path.basename(dest)
-  )
-  return await file.promises.cp(src, dest)
-}
 /**
  * 
  */
-async function makedir(path) {
+file.makedir = async function makedir(path) {
 	try {
     await file.promises.mkdir(path)
 	}
 	catch(e) {}
 }
+
 /**
  * 
  */
-async function unlink(path) {
+file.unlink = async function unlink(path) {
 	try {
     await file.promises.unlink(path)
 	}
@@ -122,10 +100,13 @@ async function unlink(path) {
 }
 
 
+module.exports = exports = Object.create(util, {
+  file: {value: file},
+  string: {value: string},
+  object: {value: object},
+  events: {value: events},
+})
+
 exports.log = log
-exports.use = use
-exports.copy = copy
-exports.unlink = unlink
-exports.makedir = makedir
 exports.colors = colors
 exports.resolve = resolve

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vindo/cli",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Command line for running vindo server and react SSR for development.",
   "main": "bin/index.js",
   "publishConfig": {
@@ -24,9 +24,10 @@
   },
   "homepage": "https://github.com/rmindo/vindo/tree/main/packages/cli",
   "dependencies": {
-    "@vindo/utility": "^0.0.7",
+    "@vindo/utility": "^0.0.13",
     "chokidar": "^4.0.3",
-    "esbuild": "^0.25.4",
+    "esbuild": "^0.27.3",
+    "sass": "^1.98.0",
     "tree-kill": "^1.2.2"
   }
 }

package/bin/build.js

@@ -1,172 +0,0 @@
-
-const es = require('esbuild')
-const {
-	path,
-	read,
-	exists,
-	string,
-	unlink,
-	makedir,
-	resolve,
-	readdir,
-	promises,
-}
-= require('./util')
-
-
-/**
- * Get basename
- * @param {string} file
- */
-function getname(file) {
-	return path.parse(file).name
-}
-
-/**
- * Get imported files
- * @param {object} opt 
- * @param {string} data 
- */
-async function getImports(entry, data) {
-	var imp = []
-	var matches = data.matchAll(/import\s(.*)\sfrom.*('|"|\/)([a-zA-Z_-]+)('|")/g)
-
-	for(var item of matches) {
-		if(/(\.\/|)components\//.test(item[0])) {
-			imp.push(`var ${item[1]} = ${item[3]}`)
-		}
-		else if(/(\.\/)/.test(item[0])) {
-			imp.push(item[0].replace(/('|")(\.\/)/, `$1${resolve.dirname(entry)}/`))
-		}
-		else {
-			imp.push(item[0])
-		}
-	}
-	return imp
-}
-
-
-/**
- * Get all codes from components
- * @param {object} opt 
- */
-async function getComponents(opt) {
-	var files = await readdir(opt.components, {recursive: true})
-	var files = files.filter(file => {
-		return /\.(tsx|jsx)$/.test(file.name)
-	})
-	
-	var code = []
-
-	for(var {name, parentPath} of files) {
-		var name = getname(name)
-		if(name) {
-			var file = path.join(parentPath, name)
-
-			if(name == 'index') {
-				file = parentPath
-				name = getname(parentPath)
-			}
-			code.push(`import ${name} from '${file}'`, `chunk.${name} = ${name}`)
-		}
-	}
-	return code
-}
-
-
-/**
- * Collect components and assemble before building
- * 
- * @param {object} opt option
- */
-async function build(opt) {
-	const data = read(opt.entry)
-	const temp = read(opt.template)
-	
-	const impo = await getImports(opt.entry, data)
-	const comp = await getComponents(opt)
-
-	const code = string.replace(temp, {
-		CHUNK_IMPORTS: comp.join('\n'),
-		ENTRY_IMPORTS: impo.join('\n'),
-		HEAD_COMPONENT: data.match(/<head.*>((.|\n)*)<\/head>/g)[0],
-		BODY_COMPONENT: data.match(/<Provider.*>((.|\n)*)<\/Provider>/g)[0]
-	})
-
-	await promises.writeFile(opt.chunk, code, {flag: 'w'})
-}
-
-
-/**
- * Create a bundle file
- * 
- * @param {object} opt option
- */
-async function bundle(opt) {
-	if(!exists(opt.chunk)) {
-		return
-	}
-	
-	const {metafile} = await es.build({
-		...opt.settings,
-		metafile: true,
-		minify: opt.minify,
-		outfile: opt.bundle,
-		entryPoints: [opt.chunk],
-		entryNames: '[name]-[hash]'
-	})
-
-	const file = Object.keys(metafile.outputs)[0]
-	const data = {
-		file,
-		hash: file.match(/-(.*).js/)[1],
-		bundle: file.match(/.*(\/.*)$/)[1]
-	}
-
-	/**
-	 * Delete old bundle
-	 */
-	const manifest = resolve.main(opt.output, 'manifest.json')
-	if(exists(manifest)) {
-		const files = readdir(resolve.main(opt.output))
-
-		files.forEach((file) => {
-			const matched = file.name.match(/^bundle-([A-Z0-9+]{8})\.js$/)
-			if(matched) {
-				if(data.hash == matched[1]) {
-					return
-				}
-				unlink(path.resolve(file.parentPath, file.name))
-			}
-		})
-	}
-
-	await promises.writeFile(manifest, JSON.stringify(data), {flag: 'w'})
-	unlink(opt.chunk)
-}
-
-
-/**
- * 
- * @param {object} config 
- */
-module.exports = async function(opt) {
-	/**
-	 * Create build directory
-	 */
-	await makedir(resolve.main(opt.output))
-
-	opt.entry = resolve.main(opt.entry)
-	opt.chunk = resolve.main(opt.output, 'chunk.jsx')
-	opt.bundle = resolve.main(opt.output, 'bundle.js')
-	opt.template = resolve.dirname(__filename, 'template.js')
-	opt.components = resolve.dirname(opt.entry, 'components')
-
-	try {
-		await build(opt)
-		await bundle(opt)
-	}
-	catch(e) {
-		console.log(e)
-	}
-}

package/bin/template.js

@@ -1,29 +0,0 @@
-
-import React from 'react'
-import client from '@vindo/react/client'
-
-const chunk = {}
-
-{CHUNK_IMPORTS}
-{ENTRY_IMPORTS}
-
-
-if(chunk.head || chunk.body) {
-  throw new SyntaxError(`Component name '${chunk.head ? 'head' : 'body'}' is a reserved name for SSR client components.`)
-}
-
-chunk.head = function head(meta) {
-  const {props:{children}} = React.cloneElement((
-    {HEAD_COMPONENT}
-  ))
-  return children
-}
-
-chunk.body = function body(props) {
-  const {props:{children}, type} = React.cloneElement((
-    {BODY_COMPONENT}
-  ))
-  return type({children, ...props})
-}
-
-client.render(document, chunk)