duto 0.261001.0 → 0.261011.0

package/src/pages/compiler/types.ts

@@ -1,6 +1,5 @@
-// import type { ComponentType, FunctionComponent, VNode } from 'preact'
-import type { Platform } from '$/cli/types'
 import type { FunctionComponent, VNode } from 'preact'
+import type { Platform } from '$/cli/types'
 
 export type PluginOptions = {
   root?: string,
@@ -43,8 +42,7 @@ export type Metadata = {
   aliases: Record<string, string>,
   layouts: Map<string, IRoute>, // all layouts
   nf: Map<string, IRoute>, // all 404
-  pages: Map<string, IRoute>, // all
-  spages: Set<string>, // ssg pages
+  pages: Map<string, IRoute>, // all pages
   routes: Routes, // client-side
   // routes: Map<string, IRoute>, // client-side
   i18n: I18nMetadata,
@@ -64,15 +62,17 @@ export type PageModule<P = {}> = {
  * getStaticProps — build-only.
  * For static pages (no dynamic segments): returns a single props object.
  * For dynamic pages: returns an array of { [routeParam]: value, ...props }
- *
  */
 export type GetStaticProps =
   | (() => StaticProps | Promise<StaticProps>)
   | (() => StaticProps[] | Promise<StaticProps[]>)
 export type StaticProps = Record<string, unknown>
 
-export type GetProps = (params: RouteParams) => StaticProps | Promise<StaticProps>
 export type RouteParams = Record<string, string | string[] | undefined>
+export type GetProps = (params: RouteParams) => StaticProps | Promise<StaticProps>
+export type Params = Record<string, RouteParams>
+
+export type View = [string, Page, Params | 0, GetProps | 0 | 1 | null, Page[]]
 
 export type Routes = IRoute[]
 export type IRoute = {
@@ -80,34 +80,25 @@ export type IRoute = {
   mod: PageModule,
   hasGetStaticProps: boolean,
   hasGetProps: boolean,
-  isClientOnly: boolean,
+  useClient: boolean,
+  useRaw: boolean,
+  useHtml: boolean,
   layouts: IRoute[],
   importName: string,
 
+  props?: StaticProps,
+
   ////////////////////////////
 
   fileExt: string,
   fileName: string,
-  /** Original file path relative to pages dir, e.g. `blog/[slug].tsx` */
-  filePath: string,
+  filePath: string, // Original file path relative to pages dir, e.g. `blog/[slug].tsx`
   fullFilePath: string,
-  /** Wouter-compatible pattern, e.g. `/blog/:slug` */
-  pattern: string,
-  /** Params extracted from the path segments */
-  params: Record<string, RouteParam>,
-  // params: RouteParam[],
-	/**
-	 * Similar to the "params" field, but with more associated metadata. For example, for `/site/[blog]/[...slug].tsx`, the segments are:
-	 *
-	 * 1. `{ content: 'site', dynamic: false, spread: false }`
-	 * 2. `{ content: 'blog', dynamic: true, spread: false }`
-	 * 3. `{ content: '...slug', dynamic: true, spread: true }`
-	 */
-	// segments: RoutePart[][]; // alternativa ao "params"
+  pattern: string, // Wouter-compatible pattern, e.g. `/blog/:slug`
+  params: Params,
   is404: boolean,
-  /** True if this route has any dynamic segments */
+
   isDynamic: boolean,
-  /** True if this route are internal */
   isInternal: boolean,
 }
 

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

@@ -23,6 +23,7 @@ import type {
 } from 'vite'
 import type { Metadata, PluginOptions } from './types'
 import { _pages, _root } from '@/utils'
+import { cp } from 'node:fs/promises'
 
 const VIRTUAL_ID = ':duto'
 const RESOLVED_ID = '\0'+ VIRTUAL_ID
@@ -219,10 +220,15 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
 
           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)
+
+            const css = typeof file.source === 'string'
+              ? file.source
+              : Buffer.from(file.source).toString('utf-8')
+
+            file.source = css.replace(/\/\*!\s*tailwindcss[^*]*\*\/\s*/g, '')
             continue
           }
 
@@ -235,35 +241,6 @@ 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',
@@ -306,13 +283,26 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
         // await server.close()
 
         const outPath = join(config.root, config.build.outDir)
+
+        await cp(join(config.root, 'public'), outPath, { recursive: true, force: true })
+
         const entry = Bun.file(join(outPath, getChunk(':duto/client/app.tsx')))
-        let entryContent = await entry.text()
+        if (await entry.exists()) {
+          let entryContent = await entry.text()
+
+          for (const r of metadata.routes.filter(r => !r.is404)) {
+            const rPath = getChunk(r.fullFilePath.replace(config.root, ''))
 
-        for (const r of metadata.routes.filter(r => !r.is404))
-          entryContent = entryContent.replace(r.fullFilePath, getChunk(r.fullFilePath.replace(config.root, '')))
+            if (r.props) {
+              const rFile = Bun.file(join(outPath, rPath))
+              await rFile.write((await rFile.text()).replace('}export{', `}export const props=${JSJSON(r.props)};export{`))
+            }
 
-        await entry.write(entryContent)
+            entryContent = entryContent.replace(r.fullFilePath, rPath)
+          }
+
+          await entry.write(entryContent)
+        }
 
         // i18n
         for (const locale of metadata.i18n.locales) {
@@ -328,6 +318,7 @@ export function plugin(options: PluginOptions = {}): PluginOption[] {
             )
           }
         }
+
       },
 
       // TODO: precisa ser aqui mesmo pois se a pagina for importada no entry, pode incluir codigo nao usado no chunck/bundle

package/src/pages/components/link.tsx

@@ -1,4 +1,4 @@
-import { Link as WouterLink, useLocation } from 'wouter-preact'
+import { useLocation } from 'wouter-preact'
 import type { LinkProps } from 'wouter-preact'
 
 const isExternalUrl = (href?: string) =>
@@ -12,27 +12,19 @@ export const Link = ({
   href = to,
   ...rest
 }: LinkProps) => {
-  const isExternal = isExternalUrl(rest.href = href)
-  const isSRoute = window?.$duto?.sroutes?.has(href)
-
-  if (isExternal) {
+  if (isExternalUrl(rest.href = href)) {
     rest.target = '_blank'
     rest.rel = 'noopener noreferrer'
+  } else {
+    rest.is = 'i-l'
   }
 
-  if (!href || isExternal || isSRoute) {
-    const [pathname] = useLocation()
-    const baseClass = typeof rest.class === 'string' || !rest?.class
-      ? (rest.class || '') as string
-      : ''
-    rest.class = baseClass + (pathname === href ? ' active' : '')
-
-    !href && (delete rest.href)
-    return <a is='i-l' {...rest} />
-  }
-
-  if (typeof rest.class === 'string' || !rest?.class)
-    rest.className = a => (rest.class || '') + (a ? ' active' : '')
+  const [pathname] = useLocation()
+  const baseClass = typeof rest.class === 'string' || !rest?.class
+    ? (rest.class || '') as string
+    : ''
+  rest.class = baseClass + (pathname === href ? ' active' : '')
 
-  return <WouterLink is='i-l' {...rest} />
+  !href && (delete rest.href)
+  return <a {...rest} />
 }

package/src/pages/i18n/client.ts

@@ -1,6 +1,5 @@
 import { h, type JSX } from 'preact'
 import { local } from '#/client/storage'
-import { navigate } from '..'
 
 const accepted = (lang: string | undefined, locales: string[] = [], fallback: string) => lang && locales.includes(lang) ? lang : fallback
 
@@ -41,7 +40,7 @@ const getAccepted = (lang: string, locales: string[] = [], defaultLocale = '') =
   return defaultLocale
 }
 
-const detect = (locales: string[], defaultLocale: string) => {
+export const detect = (locales: string[], defaultLocale: string) => {
   if (!defaultLocale) defaultLocale = 'en'
   if (typeof window === 'undefined') return defaultLocale
 
@@ -125,7 +124,7 @@ export const cached = () => local.get('lang') as string || ''
 export const updateWidth = (el: HTMLSelectElement) => {
   if (el) {
     const option = el.querySelector(`option[value="${el.value}"]`) as HTMLOptionElement
-    const length = option.textContent.split(' ')[0]?.length || 0
+    const length = option?.textContent.split(' ')[0]?.length || 0
     el.style.width = (length * 15.7)+ 'px'
   }
 }
@@ -153,7 +152,7 @@ export const r = (key: string, lang?: string) => {
   const path = '/'+ lang + (key ? '/'+ route(key, lang) : '')
 
   if (!location.pathname.endsWith(path))
-    navigate(path)
+    self.$duto?.navigate(path)
 
   // return '/' + lang + '/' + (key in _routes[lang] ? _routes[lang][key] : key)
 }

package/src/pages/index.ts

@@ -1,27 +1,10 @@
 export {
-  Redirect,
-  useLocation, useParams, useSearch, useSearchParams,
-  matchRoute,
-} from 'wouter-preact'
-
-export {
-  t, r, d,
-  getLocale, setLocale,
-  isPrefixed,
+  route, r, redirect,
+  t, tl, d,
+  getLocale, setLocale, isPrefixed,
 } from './i18n/client'
 
 export { local } from './client/storage'
 
-export const navigate = <S = any>(
-  to: string | URL,
-  options?: { replace?: boolean; state?: S; transition?: boolean }
-) => {
-  if (window?.$duto?.sroutes?.has(to)) {
-    location.pathname = to
-    return
-  }
-
-  window?.$duto?.navigate || useLocation()[1](to, options)
-}
-
+export * from './client/theme'
 export { Link } from './components/link'

package/src/server/app.ts

@@ -10,6 +10,7 @@ import { isDev } from './utils/environment'
 import { getVerb } from './utils'
 import { registerMiddleware, resolveHandle, resolveMw } from './handle'
 
+const NFHandler = () => response.notFound()
 async function EHandler(e: Error | HTTPResponseError) {
   console.error(e)
 
@@ -74,7 +75,7 @@ export default function createApp<E extends Env>(options?: ServerOptions<E>) {
 
   // @ts-ignore
   app.onError(options?.onError || EHandler)
-  app.notFound(options?.notFound || response.notFound)
+  app.notFound(options?.notFound || NFHandler)
 
   if (options?.init) options.init(app)
 

package/src/pages/client/router.ts

@@ -1,63 +0,0 @@
-import { render, h } from 'preact'
-import type { Page, GetProps, IRoute } from '#/compiler/types'
-
-function normalizeParams(
-  raw: Record<string, string>,
-  paramDefs: IRoute['params']
-): Record<string, string | string[] | undefined> {
-  const result: Record<string, string | string[] | undefined> = {};
-  for (const def of paramDefs) {
-    const val = raw[def.name];
-    if (def.catchAll) {
-      result[def.name] = val
-        ? val.split('/').filter(Boolean)
-        : def.optional ? undefined : []
-    } else {
-      result[def.name] = val === undefined && def.optional ? undefined : val;
-    }
-  }
-  return result
-}
-
-export async function renderRoute(
-  container: HTMLElement,
-  Component: Page,
-  rawParams: Record<string, string>,
-  paramDefs?: IRoute['params'] | 0,
-  getProps?: GetProps | 0 | 1,
-  layouts?: Page[]
-) {
-  while (document.body.firstChild)
-    document.body.removeChild(document.body.firstChild)
-
-  let props: Record<string, unknown> = paramDefs ? normalizeParams(rawParams, paramDefs) : rawParams
-
-  if (typeof Component === 'string') {
-    const mod = await import(Component)
-    Component = mod.default
-    getProps = getProps === 1 ? mod.getProps : 0
-  }
-
-  // @ts-ignore
-  const sProps = self.$duto?.props
-  if (typeof sProps === 'object' && sProps !== null) {
-    Object.assign(props, sProps)
-  } else if (typeof getProps === 'function') {
-    try { // TODO: melhorar tipagem do props
-      const fetched = await Promise.resolve(getProps(props as Record<string, string | string[] | undefined>))
-      props = { ...fetched, ...props }
-    } catch (e) {
-      console.error('[ssg] getProps failed:', e)
-    }
-  }
-
-
-  let el = h(Component, props as any)
-
-  const _layouts = layouts ? (Array.isArray(layouts) ? layouts : [layouts]) : []
-  for (const layout of _layouts)
-    el = h(layout, null, el)
-
-  render(el, container)
-  // render(h(Component, props as any), container)
-}