duto 0.260906.0 → 0.261001.0

package/src/pages/compiler/types.ts

@@ -1,4 +1,5 @@
 // import type { ComponentType, FunctionComponent, VNode } from 'preact'
+import type { Platform } from '$/cli/types'
 import type { FunctionComponent, VNode } from 'preact'
 
 export type PluginOptions = {
@@ -7,17 +8,6 @@ export type PluginOptions = {
   pagesDir?: string,
 }
 
-export type DepMetadata = {
-  path: string,
-  ref: string,
-}
-
-export type FileMetadata = {
-  path: string,
-  content: string,
-  deps: Map<string, DepMetadata>,
-}
-
 export type I18nMetadata = {
   fallbackLocale: string,
   locales: string[],
@@ -41,16 +31,22 @@ export type SummaryMetadata = {
 export type Metadata = {
   root: string,
   dir: string,
+  type: 'pages' | 'server',
+  platform: Platform,
+  dev: {
+    host: string,
+    port: number,
+  },
+  hmr: boolean,
+  minify: boolean,
+
   aliases: Record<string, string>,
-  map: Map<string, FileMetadata>,
-  violations: Map<string, DepMetadata[]>,
   layouts: Map<string, IRoute>, // all layouts
   nf: Map<string, IRoute>, // all 404
   pages: Map<string, IRoute>, // all
   spages: Set<string>, // ssg pages
   routes: Routes, // client-side
   // routes: Map<string, IRoute>, // client-side
-  assets: string[],
   i18n: I18nMetadata,
   string: string,
   summary: Map<string, SummaryMetadata>,
@@ -59,8 +55,7 @@ export type Metadata = {
 export type Page<P = {}> = FunctionComponent<VNode<P>>
 // A page module as imported by Bun/Vite
 export type PageModule<P = {}> = {
-  default: Page<P>,
-  // default: ComponentType<VNode<any>>,
+  default: Page<P>, // ComponentType<VNode<any>>,
   getStaticProps?: GetStaticProps,
   getProps?: GetProps,
 }
@@ -76,12 +71,6 @@ export type GetStaticProps =
   | (() => StaticProps[] | Promise<StaticProps[]>)
 export type StaticProps = Record<string, unknown>
 
-/** browser-only */
-// export type $duto = {
-//   sroutes: Set<string>,
-//   navigate: {},
-//   route: { pattern: string, params: RouteParams, path: string },
-// }
 export type GetProps = (params: RouteParams) => StaticProps | Promise<StaticProps>
 export type RouteParams = Record<string, string | string[] | undefined>
 
@@ -89,14 +78,9 @@ export type Routes = IRoute[]
 export type IRoute = {
   content: string,
   mod: PageModule,
-  /** True if the page exports getStaticProps */
   hasGetStaticProps: boolean,
-  /** True if the page exports getProps */
   hasGetProps: boolean,
   isClientOnly: boolean,
-  islands: ImportUsage[], // TODO mover para cá
-  // islands: IslandMeta[],
-  // safeFilePath: string,
   layouts: IRoute[],
   importName: string,
 
@@ -133,77 +117,3 @@ export type RouteParam = {
   catchAll: boolean,
   value?: string | string[],
 }
-
-
-
-export interface Usage {
-  type: 'jsx' | 'call' | 'reference'
-  source: string,
-  imported: string,
-  local: string,
-  start: number,
-  end: number,
-  text: string,
-  node: unknown,
-  parent: unknown,
-}
-
-export interface ImportUsage {
-  source: string,
-  imported: string,
-  local: string,
-  importStart: number,
-  importEnd: number,
-  importText: string,
-  usages: Usage[],
-}
-
-export interface IslandMeta {
-  /** Identificador curto e único (base64url de 7 chars) */
-  id: string
-  /** URL pública do asset JS do componente */
-  url: string
-  /** Nome do export usado */
-  export: string
-  /** Props serializadas como JSON (HTML-encoded) */
-  props: string
-  /** HTML do SSR do componente */
-  ssrHtml: string
-}
-
-// export interface ReplaceIslandsOptions {
-//   /**
-//    * Função que resolve o nome do componente para a URL pública do asset JS.
-//    * Ex: 'Counter' → '/assets/Counter.BQxoyJbC.js'
-//    */
-//   resolveUrl: (exportName: string) => string
-//   /**
-//    * Função que carrega o módulo do componente para fazer SSR.
-//    * Recebe o source da importação (ex: '@/components/counter2') e o nome do export.
-//    */
-//   loadComponent: (source: string, exportName: string) => Promise<unknown>
-// }
-
-
-// export type Island = {
-//   /** Unique id — written as data-island on the placeholder div */
-//   id: string,
-//   /** Component display name — used by the client to look up the component */
-//   name: string,
-//   /** Props serialised into the placeholder for client hydration */
-//   props: Record<string, unknown>,
-// }
-
-// export type RenderResult = {
-//   html: string,
-//   islands: Island[],
-//   /** true if any islands were found (= client JS needed) */
-//   hasIslands: boolean,
-// }
-
-// export type IslandMeta = {
-//   id: string,
-//   name: string,
-//   props: Record<string, unknown>,
-// }
-

package/src/pages/compiler/vite-plugin.ts

@@ -1,34 +1,33 @@
 // REF: https://github.com/tailwindlabs/tailwindcss/blob/main/packages/%40tailwindcss-vite/src/index.ts
 
-import { existsSync, readFileSync, rmSync } from 'node:fs'
+import { existsSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 import { defineConfig } from 'vite'
 
 import preact from '@preact/preset-vite'
 import tailwind from '@tailwindcss/vite'
+import { JSJSON } from 't0n'
 
 import { EXT_RE } from './constants'
-import { setAsset, setChunk, setEntry } from './assets'
+import { getChunk, setAsset, setChunk, setEntry } from './assets'
 import { renderPage } from '.'
 import { removeExports, resolveImport } from './ast'
 import { getMetadata } from './meta'
 
-import type { IncomingMessage, ServerResponse } from 'node:http'
 import type {
-  // Plugin,
   UserConfig, ConfigEnv, ResolvedConfig,
-  PreviewServer,
+  // PreviewServer,
   // ViteDevServer,
   EnvironmentOptions,
   PluginOption,
 } from 'vite'
 import type { Metadata, PluginOptions } from './types'
-import { _duto, _root } from './utils'
+import { _pages, _root } from '@/utils'
 
 const VIRTUAL_ID = ':duto'
 const RESOLVED_ID = '\0'+ VIRTUAL_ID
 
-export const config = (opts: UserConfig & PluginOptions) => {
+export const config = (opts: UserConfig & PluginOptions) => { // @ts-ignore
   if (!opts.root) opts.root = _root
   if (!opts.pagesDir) opts.pagesDir = 'pages',
 
@@ -43,6 +42,7 @@ export const config = (opts: UserConfig & PluginOptions) => {
   return defineConfig(opts)
 }
 
+// TODO: remover..
 export default config
 
 let metadata: Metadata
@@ -51,15 +51,12 @@ export function meta() {
 }
 
 export function plugin(options: PluginOptions = {}): PluginOption[] {
-  // let server: ViteDevServer
   let config: ResolvedConfig
   const {
-    root = _root, // process.env.npm_config_local_prefix || process.env.PWD || process.cwd() || __dirname,
+    root = _root,
     pagesDir = 'pages',
   } = options
 
-  // let metadata: Metadata
-
   const PAGES_RE = new RegExp(`\/${pagesDir}\/.*\.(tsx?|jsx?)$`, 'i')
   const stripTarget = new Set(['getStaticProps'])
 
@@ -101,44 +98,14 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
 
         return opts
       },
-
-      // configurePreviewServer(server: PreviewServer) {
-      //   const distDir = join(server.config.root, 'dist')
-
-      //   server.middlewares.use((req: IncomingMessage, res: ServerResponse, next: (err?: any) => void) => {
-      //     if (req.url && !existsSync(join(distDir, req.url.split('?')[0]))) {
-      //       const notFound = join(distDir, '404.html')
-
-      //       if (existsSync(notFound)) {
-      //         res.statusCode = 404
-      //         res.setHeader('Content-Type', 'text/html')
-      //           .end(readFileSync(notFound, 'utf-8'))
-      //         return
-      //       }
-      //     }
-
-      //     next()
-      //   })
-      // },
-
     },
 
     {
       name: 'duto:scan',
       enforce: 'pre',
 
-      // configureServer(_server) {
-      //   server = _server
-      //   // servers.push(server)
-      // },
-
       async config(conf: UserConfig, env: ConfigEnv) {
-        // if (!metadata)
-          metadata = await getMetadata(root, pagesDir)
-
-        // console.log(metadata.map)
-        // console.log(metadata.violations)
-        // console.log(Array.from(metadata.violations).filter(file => EXT_RE.test(file)))
+        metadata = await getMetadata(root as string, pagesDir)
 
         if (conf.build) {
           // conf.build.emptyOutDir = false
@@ -146,44 +113,47 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
           conf.build.manifest = false
           conf.build.modulePreload = { polyfill: false }
 
-          conf.build.minify = true
-          conf.build.cssMinify = true //////
+          conf.build.minify = metadata.minify
+          conf.build.cssMinify = metadata.minify
 
           conf.build.rolldownOptions = conf.build.rolldownOptions || {}
           conf.build.rolldownOptions.preserveEntrySignatures = 'exports-only' ///
           conf.build.rolldownOptions.input = [
+            ...metadata.routes.map(r => r.is404 ? '' : r.fullFilePath).filter(Boolean),
             ':duto/client/app.tsx',
             // ':duto/not-found.tsx',
-            ...Object.keys(metadata.pages),
-            ...metadata.assets,
+            // ...Object.keys(metadata.pages),
+            // ...metadata.assets,
           ]
+
+          const filePrefix = metadata.minify ? '' : '[name].'
           // conf.build.rolldownOptions.input = ':duto/client/app.tsx'
           conf.build.rolldownOptions.output = {
             hoistTransitiveImports: false,
             format: 'esm',
-            minifyInternalExports: true,
-
-            // manualChunks: {
-            //   vendor: ['preact', '@preact/signals', 'wouter-preact'],
-            // },
-            // preserveModules: true,
+            minifyInternalExports: metadata.minify,
             preserveModulesRoot: '/',
-            assetFileNames: '[hash][extname]',
-            entryFileNames: '[hash].js',
-            chunkFileNames: '[hash].js',
+            assetFileNames: filePrefix +'[hash][extname]',
+            entryFileNames: filePrefix +'[hash].js',
+            chunkFileNames: filePrefix +'[hash].js',
 
             // chunkFileNames: '[name].[hash].js',
             // entryFileNames: 'assets/[name].js',
             // chunkFileNames: 'assets/chunks/[name]-[hash].js',
             // assetFileNames: 'assets/[name][extname]',
+
+            // manualChunks: {
+            //   vendor: ['preact', '@preact/signals', 'wouter-preact'],
+            // },
+            // preserveModules: true,
           }
         }
 
         return conf
       },
 
-      async configResolved(conf) {
-        config = conf
+      async configResolved(c) {
+        config = c
       },
 
       resolveId(id) {
@@ -213,13 +183,13 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
         if (!id.startsWith(VIRTUAL_ID)) return null
 
         if (EXT_RE.test(id) && id.includes('/')) {
-          const path = join(_duto, id.replace(VIRTUAL_ID, ''))
+          const path = join(_pages, id.replace(VIRTUAL_ID, ''))
           setEntry(id, path)
           return path
         }
 
-        if (id.endsWith('/hmr') && global.__hmr)
-          return join(_duto, id.replace(VIRTUAL_ID, '') + '.ts')
+        if (id.endsWith('/hmr') && metadata.hmr)
+          return join(_pages, 'client', id.replace(VIRTUAL_ID, '') + '.ts')
 
         return id.replace(VIRTUAL_ID, RESOLVED_ID)
       },
@@ -238,15 +208,18 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
         // for (const id of moduleIds)
         // console.error(id)
 
+        // TODO: rever isso...
         for (const key in bundle) {
           const file = bundle[key]
+
           if (file.type === 'chunk' && file.isEntry) {
             setChunk(file.facadeModuleId, '/'+ file.fileName)
             continue
           }
 
-          if (file.type === 'asset' && file?.originalFileName?.endsWith('duto/client/app.tsx'))
-            file.source += 'd-b,d-p,i-d,i-s,i-i{display:contents}'
+          if (file.type === 'asset' && file?.originalFileName?.endsWith('duto/pages/client/app.tsx'))
+            file.source += 'i-i{display:contents}'
+            // file.source += 'd-b,d-p,i-d,i-s,i-i{display:contents}'
 
           if (file.type === 'asset' && file.fileName.endsWith('.css')) {
             setAsset(resolveImport(file.originalFileName as string, metadata.root, metadata.aliases), '/'+ file.fileName)
@@ -262,6 +235,35 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
 
     },
 
+    // {
+    //   name: 'duto:routes-inject',
+    //   enforce: 'post',
+    //   generateBundle(_, bundle) {
+    //     // monta o mapa a partir dos inputs de metadata.routes
+    //     const routeMap: Record<string, string> = {}
+    //     for (const r of metadata.routes) {
+    //       if (r.is404) continue
+    //       // encontra o chunk cujo facadeModuleId bate com r.fullFilePath
+    //       for (const [fileName, chunk] of Object.entries(bundle)) {
+    //         if (chunk.type === 'chunk' && chunk.facadeModuleId === r.fullFilePath) {
+    //           routeMap[r.path] = fileName
+    //           break
+    //         }
+    //       }
+    //     }
+
+    //     // injeta no chunk do app
+    //     for (const chunk of Object.values(bundle)) {
+    //       if (chunk.type !== 'chunk') continue
+    //       if (chunk.facadeModuleId?.includes('app.tsx') || chunk.code.includes('__DUTO_ROUTES__')) {
+    //         chunk.code = chunk.code.replace(
+    //           '__DUTO_ROUTES__',
+    //           JSON.stringify(routeMap)
+    //         )
+    //       }
+    //     }
+    //   }
+    // },
     {
       name: 'duto:build',
       enforce: 'pre',
@@ -296,13 +298,36 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
       },
 
       async closeBundle() {
-        for (const [_filePath, page] of metadata.pages) {
+        for (const [_filePath, page] of metadata.pages)
           await renderPage(metadata, config, page)
           // const mod = await server.ssrLoadModule(_filePath)
-        }
 
         rmSync(join(metadata.root, 'tmp'), {recursive: true, force: true})
         // await server.close()
+
+        const outPath = join(config.root, config.build.outDir)
+        const entry = Bun.file(join(outPath, getChunk(':duto/client/app.tsx')))
+        let entryContent = await entry.text()
+
+        for (const r of metadata.routes.filter(r => !r.is404))
+          entryContent = entryContent.replace(r.fullFilePath, getChunk(r.fullFilePath.replace(config.root, '')))
+
+        await entry.write(entryContent)
+
+        // i18n
+        for (const locale of metadata.i18n.locales) {
+          const intlPath = join(metadata.root, 'i18n', locale + '.ts')
+          if (existsSync(intlPath)) {
+            const intlMod = await import(intlPath)
+            await Bun.write(
+              join(outPath, locale +'.js'),
+              `var a=${JSJSON({
+                routes: intlMod.routes ?? intlMod.default?.routes,
+                messages: intlMod.messages ?? intlMod.default?.messages,
+              })};export { a as default }`
+            )
+          }
+        }
       },
 
       // TODO: precisa ser aqui mesmo pois se a pagina for importada no entry, pode incluir codigo nao usado no chunck/bundle
@@ -311,12 +336,8 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
         // console.log(this.getModuleInfo(id))
 
         const stripped = removeExports(id, code, stripTarget)
-        if (!stripped || stripped === code) return null
 
-        return {
-          code: stripped,
-          map: null, // source maps omitted for brevity, add if needed
-        }
+        return (!stripped || stripped === code) ? null : { code: stripped, map: null }
       },
 
     },

package/src/pages/i18n/client.ts

@@ -1,5 +1,5 @@
 import { h, type JSX } from 'preact'
-import { local } from '#/storage'
+import { local } from '#/client/storage'
 import { navigate } from '..'
 
 const accepted = (lang: string | undefined, locales: string[] = [], fallback: string) => lang && locales.includes(lang) ? lang : fallback
@@ -84,12 +84,22 @@ export const getLocale = () => {
   }
 }
 
-export const setLocale = (lang: string) => {
+export const setLocale = async (lang: string) => {
+  await loadLang(lang)
   cache(lang)
   _locale = accepted(lang, _locales, _detected)
 }
 
-export default function i18n(
+async function loadLang(lang: string) {
+  if (!_routes[lang] || !_messages[lang]) {
+    const intlMod = await import('/'+ lang +'.js')
+    if (!intlMod) return
+    _routes[lang] = intlMod.routes ?? intlMod.default?.routes
+    _messages[lang] = intlMod.messages ?? intlMod.default?.messages
+  }
+}
+
+export default async function i18n(
   fallbackLocale: string,
   locales: string[],
   messages: Record<string, Record<string, string>>,
@@ -103,6 +113,8 @@ export default function i18n(
   _detected = detect(locales, fallbackLocale)
   _locale = typeof window === 'undefined' ? fallbackLocale : getLocale()
 
+  await loadLang(_locale)
+
   // console.error(routes)
   // console.error(routeMap)
 }
@@ -173,10 +185,10 @@ type TProps = {
 }
 
 const lookup = (key: string, lang: string): string => {
-  if (!key) return '';
-  if (key.startsWith('_')) return key.replace(/^_+/, '');
-  const msg = _messages[lang] ?? _messages[_locale];
-  return (key in msg ? msg[key] : key) as string;
+  if (!key) return ''
+  if (key.startsWith('_')) return key.replace(/^_+/, '')
+  const msg = _messages[lang] ?? _messages[_locale]
+  return (msg && key in msg ? msg[key] : key) as string
 }
 
 const interpolate = (template: string, params: Record<string, Primitives> | Primitives[]): string => {

package/src/pages/i18n/element.ts

@@ -1,4 +1,4 @@
-import { local } from '#/storage'
+import { local } from '#/client/storage'
 import { t, _prefixed } from './client'
 
 export default class EI18n extends HTMLElement {

package/src/pages/i18n/server.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path'
 import { IMPORT, JSJSON } from 't0n'
 
-import type { Metadata, I18nMetadata } from '@/types'
+import type { Metadata, I18nMetadata } from '#/compiler/types'
 import { existsSync } from 'node:fs'
 
 export default async function getI18n(meta: Metadata) {
@@ -11,7 +11,7 @@ export default async function getI18n(meta: Metadata) {
     'i18n.ts',
     'i18n/index.ts',
   ]) {
-     const path = join(meta.root, variant)
+    const path = join(meta.root, variant)
     if (existsSync(path)) {
       file = path
       break
@@ -22,13 +22,28 @@ export default async function getI18n(meta: Metadata) {
   const mod = await IMPORT<I18nMetadata>(file)
 
   // @ts-ignore
-  if (['locales', 'fallbackLocale', 'messages', 'routes', 'options'].some(i => !mod[i]))
+  if (['locales', 'fallbackLocale', 'options'].some(i => !mod[i]))
     return {} as I18nMetadata
 
+  // const routes = Object.fromEntries(mod.locales.map(locale => [locale, ]))
+
+  const routes: Record<string, Record<string, string>> = {}
+  const messages: Record<string, Record<string, string>> = {}
+  for (const locale of mod.locales) {
+    const intlPath = join(meta.root, 'i18n', locale + '.ts')
+    if (existsSync(intlPath)) {
+      const intlMod = await IMPORT<{default:{routes: Record<string, string>, messages: Record<string, string>}}>(intlPath)
+      routes[locale] = intlMod.default.routes
+      messages[locale] = intlMod.default.messages
+    }
+  }
+
   const i18n: I18nMetadata = {
     ...mod,
+    routes,
+    messages,
     routeMap: Object.fromEntries(
-      Object.values(mod.routes)
+      Object.values(routes)
         .map(paths => Object.entries(paths).map(([key, path]) => path == key ? 0 : [path, key]).filter(Boolean))
         .flat() as Array<[string, string]>
     ),
@@ -36,7 +51,7 @@ export default async function getI18n(meta: Metadata) {
     string: '',
   }
 
-  Object.entries(mod.routes)
+  Object.entries(routes)
     .forEach(([locale, paths]) => {
        Object.entries(paths)
         .forEach(([route, path]) => i18n.pageRoutes.push({ locale, path }))
@@ -44,8 +59,8 @@ export default async function getI18n(meta: Metadata) {
 
   i18n.string = `export const fallbackLocale = ${JSJSON(mod.fallbackLocale)}
 export const locales = ${JSJSON(mod.locales)}
-export const messages = ${JSJSON(mod.messages)}
-export const routes = ${JSJSON(mod.routes)}
+export const messages = ${JSJSON(messages)}
+export const routes = ${JSJSON(routes)}
 export const routeMap = ${JSJSON(i18n.routeMap)}
 export const pageRoutes = ${JSJSON(i18n.pageRoutes)}
 export const options = ${JSJSON(mod.options)}

package/src/pages/index.ts

@@ -21,8 +21,7 @@ export const navigate = <S = any>(
     return
   }
 
-  const n = window?.$duto?.navigate || useLocation()[1]
-  n(to, options)
+  window?.$duto?.navigate || useLocation()[1](to, options)
 }
 
 export { Link } from './components/link'

package/src/pages/preact/server.ts

@@ -8,7 +8,7 @@ import { getContext, incrementIslandId } from './context'
 import { restoreSignalsOnProps, serializeSignals } from './signals'
 import StaticHtml from './static-html'
 import type { IslandAttrs } from './types'
-import type { IslandMeta } from '@/types'
+import type { IslandMeta } from '#/compiler/types'
 // import type { AstroPreactAttrs, RendererContext } from './types.js'
 // import { createFilter } from '@astrojs/internal-helpers/create-filter'
 

package/src/server/app.ts

@@ -1,18 +1,16 @@
 import { Hono } from 'hono'
-import { Envir } from 't0n'
 import type {
   Env, Context, Next,
   HTTPResponseError,
   ServerOptions, Route
 } from './types'
-import request, { GET_REQUEST } from './request'
+import request from './request'
 import response from './response'
 import { isDev } from './utils/environment'
-import { getVerb } from './http'
+import { getVerb } from './utils'
 import { registerMiddleware, resolveHandle, resolveMw } from './handle'
 
-const NFHandler = () => response.notFound()
-const EHandler = async (e: Error | HTTPResponseError) => {
+async function EHandler(e: Error | HTTPResponseError) {
   console.error(e)
 
   switch (true) {
@@ -59,7 +57,7 @@ const EHandler = async (e: Error | HTTPResponseError) => {
   // stack: isDev (? e.stack : undefined
 }
 
-export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
+export default function createApp<E extends Env>(options?: ServerOptions<E>) {
   // const root = options?.root ?? '/'
   const app = options?.app ?? new Hono<E>()
 
@@ -76,8 +74,7 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
 
   // @ts-ignore
   app.onError(options?.onError || EHandler)
-  // @ts-ignore
-  app.notFound(options?.notFound || NFHandler)
+  app.notFound(options?.notFound || response.notFound)
 
   if (options?.init) options.init(app)
 
@@ -92,5 +89,3 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
 
   return app
 }
-
-export default createApp

package/src/server/auth/ability.ts

@@ -1,4 +1,4 @@
-import { verbAlias } from '$/http'
+import { verbAlias } from '$/utils'
 import type { IRequest, Routes } from '$/types'
 import type { Roles, Abilities } from './types'