duto 0.0.0 → 0.260906.0

package/src/pages/commands/dev-old.ts

@@ -0,0 +1,213 @@
+import { defineCommand } from 'citty'
+import { build, preview } from 'vite'
+import { withPort } from 't0n/port'
+import { error, event, log, rn, wait } from 't0n/log'
+import { getConfig } from '~/utils'
+import { _root } from '@/utils'
+import { watch } from 't0n/cli'
+import { spawn, type ChildProcess } from 'node:child_process'
+
+export const args = {
+  port: {
+    alias: 'p',
+    description: 'Port to listen on',
+    type: 'number',
+    default: 3000,
+  },
+  host: {
+    description: 'Host to forward requests to, defaults to the zone of project',
+    type: 'string',
+    default: 'localhost',
+  },
+}
+
+export default defineCommand({
+  meta: {
+		name: 'dev',
+		description: '🧪  Start dev server\n',
+	}, // @ts-ignore
+	args,
+  async run({ args }) {
+    const config = await getConfig()
+		const desiredPort = args.port ? Number(args.port) : (config?.preview?.port ? Number(config.preview.port) : 3000)
+    const host = args.host ? String(args.host) : (config?.preview?.host ? config.preview.host : 'localhost')
+
+    // const _build = async () => {
+    //   return await build(await getConfig())
+    // }
+
+    // let buildProcess: ChildProcess | null = null
+    // const _build = async () => {
+    //   if (buildProcess) await killProcess(buildProcess)
+
+    //   return new Promise<void>((resolve, reject) => {
+    //     let timeoutId: NodeJS.Timeout | null = null
+
+    //     buildProcess = spawn('duto', ['build'], {
+    //       // stdio: 'ignore',
+    //       stdio: ['inherit', 'ignore', 'inherit', 'ipc'],
+    //       shell: process.platform === 'win32'
+    //     })
+
+    //     buildProcess.on('close', (code) => {
+    //       if (timeoutId) clearTimeout(timeoutId)
+    //       buildProcess = null
+
+    //       if (code === 0) {
+    //         resolve()
+    //       } else {
+    //         reject(new Error(`Build failed with code ${code}`))
+    //       }
+    //     })
+
+    //     buildProcess.on('error', (error) => {
+    //       if (timeoutId) clearTimeout(timeoutId)
+    //       buildProcess = null
+    //       reject(error)
+    //     })
+    //   })
+    // }
+
+		// const killProcess = async (app: ChildProcess | null) => {
+		// 	if (!app) return null
+		// 	// event('Stopping..')
+		// 	try {
+		// 		if (!app?.killed) {
+		// 			app.kill('SIGTERM')
+		// 			await wait(1000)
+
+		// 			if (!app?.killed) { // force kill
+		// 				app.kill('SIGKILL')
+		// 				await wait(1000)
+		// 			}
+		// 		}
+
+		// 		return null
+		// 	} catch (e) {
+		// 		error('Error stopping:', e)
+		// 	}
+
+		// 	return null
+    // }
+
+    let buildProcess: Bun.Subprocess | null = null
+
+    const _build = async () => {
+      if (buildProcess) await killProcess(buildProcess)
+      buildProcess = Bun.spawn(['duto', 'build'], {stdin: 'inherit', stdout: 'ignore', stderr: 'inherit'})
+
+      try {
+        const code = await buildProcess.exited
+
+        if (code !== 0)
+          throw new Error(`Build failed with code ${code}`)
+      } finally {
+        buildProcess = null
+      }
+    }
+
+    const killProcess = async (proc: Bun.Subprocess | null) => {
+      if (!proc || proc.exitCode !== null) return
+
+      try {
+        proc.kill('SIGTERM')
+
+        const exited = await Promise.race([
+          proc.exited.then(() => true),
+          new Promise(r => setTimeout(r, 1000)).then(() => false),
+        ])
+
+        if (!exited && proc.exitCode === null) {
+          proc.kill('SIGKILL')
+          await proc.exited
+        }
+      } catch (e) {
+        error('Error stopping:', e)
+      }
+    }
+
+    withPort(desiredPort, async (port) => {
+      const ignore = [
+        /(^|[\/\\])\.(duto|git|cache|vscode|idea|next|nuxt|nyc_output)([\/\\]|$)/,
+        /(^|[\/\\])(node_modules|tmp|dist|build|out|coverage)([\/\\]|$)/,
+
+        /\.(DS_Store|localized|tmp|temp|log|pid|swp|swo)$/,
+        /(Thumbs\.db|desktop\.ini)$/,
+        /~$/,
+
+        /(^|[\/\\])\.(Spotlight-V100|Trashes)([\/\\]|$)/,
+        /(^|[\/\\])__MACOSX([\/\\]|$)/,
+      ]
+
+      try {
+        await _build()
+
+        const clients = new Set<ReadableStreamDefaultController<string>>()
+        const reload = () => {
+          for (const client of clients)
+            client.enqueue('data: reload\n\n')
+        }
+        Bun.serve({
+          port: 1322,
+
+          fetch(req) {
+            const headers = {
+             'Access-Control-Allow-Origin': '*',
+             'Access-Control-Allow-Methods': 'GET',
+             'Access-Control-Allow-Headers': '*',
+            }
+
+            if (req.method === 'OPTIONS')
+              return new Response(null, { status: 204, headers })
+
+            const { pathname } = new URL(req.url)
+
+            if (pathname !== '/events')
+              return new Response(null, { status: 404, headers })
+
+            const stream = new ReadableStream<string>({
+              start(controller) {
+                clients.add(controller)
+
+                req.signal.addEventListener('abort', () => {
+                  clients.delete(controller)
+                  controller.close()
+                })
+              },
+            })
+
+            return new Response(stream, {
+              headers: {
+                ...headers,
+               'Content-Type': 'text/event-stream',
+               'Cache-Control': 'no-cache',
+               'Connection': 'keep-alive',
+              },
+            })
+          },
+        })
+
+        await preview({ ...config, preview: { port, host } })
+
+        log(`Running on http://${host}:${port}`)
+
+				watch(async () => {
+          await _build()
+          reload()
+				}, '.', _root, (path: string) => {
+          for (const pattern of ignore)
+            if (pattern.test(path)) return true
+
+          return false
+        })
+
+      } catch (e: any) {
+        error(e)
+        process.exit(0)
+      } finally {
+        rn()
+      }
+    })
+
+	},
+})

package/src/pages/commands/dev.ts

@@ -0,0 +1,87 @@
+import { command, watch, killProcess } from 't0n/cli'
+import { dim } from 't0n/color'
+import { error, log, rn } from 't0n/log'
+import { withPort } from 't0n/port'
+import { getMetadata } from '@/meta'
+import { _root } from '@/utils'
+import { getConfig, preview, reload } from '~/utils'
+
+export const args = {
+  port: {
+    alias: 'p',
+    description: 'Port to listen on',
+    type: 'number',
+    default: 3000,
+  },
+  host: {
+    description: 'Host to forward requests to, defaults to the zone of project',
+    type: 'string',
+    default: 'localhost',
+  },
+}
+
+export default command({
+  meta: {
+		name: 'dev',
+		description: '🧪  Start dev server\n',
+	}, // @ts-ignore
+	args,
+  async run({ args }) {
+    const config = await getConfig()
+		const desiredPort = args.port ? Number(args.port) : (config?.preview?.port ? Number(config.preview.port) : 3000)
+    const host = args.host ? String(args.host) : (config?.preview?.host ? String(config.preview.host) : 'localhost')
+
+    let buildProcess: Bun.Subprocess | null = null
+
+    const _build = async () => {
+      if (buildProcess) await killProcess(buildProcess)
+      buildProcess = Bun.spawn(['duto', 'build', '--hmr'], {stdin: 'inherit', stdout: 'ignore', stderr: 'inherit'})
+
+      try {
+        const code = await buildProcess.exited
+
+        if (code !== 0)
+          throw new Error(`Build failed with code ${code}`)
+      } finally {
+        buildProcess = null
+      }
+    }
+
+    withPort(desiredPort, async (port) => {
+      const ignore = [
+        /(^|[\/\\])\.(duto|git|cache|vscode|idea|next|nuxt|nyc_output)([\/\\]|$)/,
+        /(^|[\/\\])(node_modules|tmp|dist|build|out|coverage)([\/\\]|$)/,
+
+        /\.(DS_Store|localized|tmp|temp|log|pid|swp|swo)$/,
+        /(Thumbs\.db|desktop\.ini)$/,
+        /~$/,
+
+        /(^|[\/\\])\.(Spotlight-V100|Trashes)([\/\\]|$)/,
+        /(^|[\/\\])__MACOSX([\/\\]|$)/,
+      ]
+
+      try {
+        await _build()
+        await preview(await getMetadata(config.root as string, config.pagesDir as string), host, port)
+
+        log(`Running on http://${host}:${port}${global?.__st ? dim(` in ${Math.ceil(performance.now() - global.__st)} ms`) : ''}`)
+
+				watch(async () => {
+          await _build()
+          reload()
+				}, '.', _root, (path: string) => {
+          for (const pattern of ignore)
+            if (pattern.test(path)) return true
+
+          return false
+        })
+      } catch (e: any) {
+        error(e)
+        process.exit(0)
+      } finally {
+        rn()
+      }
+    })
+
+	},
+})

package/src/pages/commands/preview.ts

@@ -0,0 +1,33 @@
+import { command } from 't0n/cli'
+import { dim } from 't0n/color'
+import { error, log, rn } from 't0n/log'
+import { withPort } from 't0n/port'
+import { getMetadata } from '@/meta'
+import { _root } from '@/utils'
+import { args } from './dev'
+import { getConfig, preview } from '~/utils'
+
+export default command({
+  meta: {
+		name: 'preview',
+		description: '💻  Locally preview production build\n',
+	}, // @ts-ignore
+	args,
+  async run({ args }) {
+    const config = await getConfig()
+		const desiredPort = args.port ? Number(args.port) : (config?.preview?.port ? Number(config.preview.port) : 3000)
+    const host = args.host ? String(args.host) : (config?.preview?.host ? config.preview.host as string : 'localhost')
+
+    withPort(desiredPort, async (port) => {
+      try {
+        await preview(await getMetadata(config.root as string, config.pagesDir as string), host, port)
+        log(`Running on http://${host}:${port}${global?.__st ? dim(` in ${Math.ceil(performance.now() - global.__st)} ms`) : ''}`)
+      } catch (e: any) {
+        error('Preview failed:', e?.message || e)
+        process.exit(0)
+      } finally {
+        rn()
+      }
+    })
+	},
+})

package/src/pages/compiler/aliases.ts

@@ -0,0 +1,36 @@
+import { join, resolve } from 'node:path'
+import { readFileSync } from 'node:fs'
+import { resolveExtension } from './file'
+
+export function getTsConfig(configPath = './tsconfig.json') {
+  const content = readFileSync(configPath, 'utf8')
+  return JSON.parse(content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, ''))
+}
+
+export function getAliases(root: string) {
+  const tsconfig = getTsConfig(join(root, './tsconfig.json'))
+  const compilerOptions = tsconfig.compilerOptions || {}
+  const paths = Object.entries(compilerOptions.paths || {})
+  const baseUrl = compilerOptions.baseUrl || '.'
+
+  const aliases = {}
+
+  for (const [aliasPattern, targetPatterns] of paths) // @ts-ignore
+    aliases[aliasPattern.replace(/\/\*$/, '')] = resolve(process.cwd(), baseUrl, targetPatterns[0].replace(/\/\*$/, ''))
+
+  return aliases
+}
+
+export function resolveAlias(importPath: string, aliases: Record<string, string>) {
+  for (const [alias, realPath] of Object.entries(aliases)) {
+    if (importPath.startsWith(alias +'/') || importPath === alias) {
+      const subPath = importPath.substring(alias.length)
+      const cleanSubPath = subPath.startsWith('/') ? subPath.substring(1) : subPath
+      const resolved = join(realPath, cleanSubPath)
+
+      return resolveExtension(resolved) ?? resolved
+    }
+  }
+
+  return resolveExtension(importPath) ?? importPath
+}

package/src/pages/compiler/assets.ts

@@ -0,0 +1,43 @@
+const distMap: Record<string, string> = {}
+
+// export function getDist(){
+//   return distMap
+// }
+export function getAsset(id: string) {
+  const entry = getChunk(id, 1)
+  return distMap['\0'+ entry] || null
+}
+export function setAsset(id: string | null, val: string) {
+  distMap['\0'+ normalizeId(id)] = val
+}
+
+// corririr isso...
+export function getChunk(id: string, deep: number = 3, loop: number = 1) {
+  if (!distMap[id]) return id
+
+  const currentValue = distMap[id]
+
+  if (loop < deep && distMap[currentValue] && currentValue !== id)
+    return getChunk(currentValue, deep, loop + 1)
+
+  return currentValue
+}
+export function setChunk(id: string | null, val: string) {
+  distMap[normalizeId(id)] = val
+}
+
+export function getEntry(id: string) {
+  if (id in distMap) return distMap[id]
+  const key = id in distMap ? id : normalizeId(id)
+  return distMap[key] || id
+}
+export function setEntry(id: string | null, val: string) {
+  if (!id) return
+  distMap[id] = normalizeId(val)
+}
+
+export function normalizeId(id?: string | null) {
+  id = id?.replace(process.cwd(), '') || ''
+  if (id && !id.startsWith('/')) id = '/'+ id
+  return id
+}