davaux 0.8.0 → 0.8.1

package/src/create-multisite.ts

@@ -1,310 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { join, resolve } from 'node:path'
-
-export async function scaffoldMultisite(name: string | undefined, cwd: string) {
-  if (!name) {
-    console.error('Usage: davaux create-multisite <project-name>')
-    process.exit(1)
-  }
-
-  if (!/^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/.test(name)) {
-    console.error(
-      `[davaux] Invalid project name "${name}". Use lowercase letters, numbers, hyphens, underscores, or dots.`,
-    )
-    process.exit(1)
-  }
-
-  const dir = resolve(cwd, name)
-
-  if (existsSync(dir)) {
-    console.error(`[davaux] Directory "${name}" already exists.`)
-    process.exit(1)
-  }
-
-  const title = name.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
-
-  mkdirSync(join(dir, 'src', 'routes'), { recursive: true })
-  mkdirSync(join(dir, 'sites', 'main', 'routes'), { recursive: true })
-  mkdirSync(join(dir, 'public'), { recursive: true })
-
-  write(dir, 'package.json', packageJson(name))
-  write(dir, 'tsconfig.json', tsConfig())
-  write(dir, 'biome.json', biomeConfig())
-  write(dir, 'multisite.config.ts', multisiteConfig())
-  write(dir, 'server.ts', serverEntry())
-  write(dir, 'build.ts', buildEntry())
-  write(dir, 'src/routes/_layout.tsx', baseLayout(title))
-  write(dir, 'src/routes/index.page.tsx', baseIndexPage(title))
-  write(dir, 'sites/main/routes/_layout.tsx', siteLayout())
-  write(dir, 'sites/main/routes/index.page.tsx', siteIndexPage(title))
-
-  console.log(`\n  Created multisite project: ${name}\n`)
-  console.log('  Next steps:\n')
-  console.log(`    cd ${name}`)
-  console.log('    npm install')
-  console.log('    npm run dev\n')
-  console.log('  Docs: https://davaux.codeberg.page/docs/packages/multisite\n')
-}
-
-function write(dir: string, file: string, content: string) {
-  writeFileSync(join(dir, file), content, 'utf8')
-}
-
-function packageJson(name: string) {
-  return (
-    JSON.stringify(
-      {
-        name,
-        version: '0.1.0',
-        type: 'module',
-        scripts: {
-          dev: 'node --watch --import tsx/esm server.ts',
-          build: 'tsx build.ts',
-          start: 'NODE_ENV=production node dist/server.js',
-        },
-        dependencies: {
-          '@davaux/multisite': 'latest',
-          davaux: 'latest',
-        },
-        devDependencies: {
-          '@biomejs/biome': 'latest',
-          '@types/node': 'latest',
-          tsx: 'latest',
-        },
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function tsConfig() {
-  return (
-    JSON.stringify(
-      {
-        compilerOptions: {
-          target: 'ESNext',
-          module: 'NodeNext',
-          moduleResolution: 'NodeNext',
-          jsx: 'react-jsx',
-          jsxImportSource: 'davaux',
-          strict: true,
-          lib: ['ESNext', 'DOM'],
-          allowImportingTsExtensions: true,
-          noEmit: true,
-          skipLibCheck: true,
-          types: ['node', 'davaux/env'],
-        },
-        include: ['src/**/*', 'sites/**/*', '*.ts'],
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function biomeConfig() {
-  return (
-    JSON.stringify(
-      {
-        $schema: 'https://biomejs.dev/schemas/2.4.15/schema.json',
-        assist: { actions: { source: { organizeImports: 'on' } } },
-        linter: {
-          enabled: true,
-          rules: {
-            recommended: true,
-            correctness: {
-              noUnusedVariables: 'error',
-              noUnusedImports: 'error',
-            },
-            style: {
-              noNonNullAssertion: 'warn',
-            },
-          },
-        },
-        formatter: {
-          enabled: true,
-          indentStyle: 'space',
-          indentWidth: 2,
-          lineWidth: 100,
-        },
-        javascript: {
-          formatter: {
-            quoteStyle: 'single',
-            trailingCommas: 'all',
-            semicolons: 'asNeeded',
-          },
-        },
-        css: {
-          formatter: {
-            enabled: true,
-            quoteStyle: 'single',
-          },
-        },
-        files: {
-          includes: ['src/**', 'sites/**', '*.ts'],
-        },
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function multisiteConfig() {
-  return `import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { defineSites } from '@davaux/multisite'
-
-const root = fileURLToPath(new URL('.', import.meta.url))
-
-export interface SiteConfig {
-  name: string
-  primaryColor: string
-}
-
-export const sites = defineSites<SiteConfig>({
-  baseDir: join(root, 'src/routes'),
-  sites: [
-    {
-      name: 'main',
-      hostname: 'localhost',
-      routesDir: join(root, 'sites/main/routes'),
-      config: { name: 'Main Site', primaryColor: '#1d4ed8' },
-    },
-    {
-      name: 'fallback',
-      hostname: '*',
-      config: { name: 'Fallback', primaryColor: '#374151' },
-    },
-  ],
-})
-`
-}
-
-function serverEntry() {
-  return `import { startMultisite } from '@davaux/multisite'
-import { sites } from './multisite.config.js'
-
-startMultisite(sites, { port: 3000, hostname: 'localhost', cwd: import.meta.dirname })
-`
-}
-
-function buildEntry() {
-  return `import { buildMultisite } from '@davaux/multisite/build'
-import { sites } from './multisite.config.js'
-
-await buildMultisite(sites, { cwd: import.meta.dirname })
-`
-}
-
-function baseLayout(title: string) {
-  return `import { defineLayout } from 'davaux'
-
-export default defineLayout(({ children, ctx }) => (
-  <html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>{ctx.head.title ?? '${title}'}</title>
-      {ctx.head.description && <meta name="description" content={ctx.head.description} />}
-      {Object.entries(ctx.head.meta).map(([name, content]) => (
-        <meta name={name} content={content} />
-      ))}
-      {ctx.head.stylesheets.map((href) => (
-        <link rel="stylesheet" href={href} />
-      ))}
-    </head>
-    <body>
-      {children as unknown as string}
-      {ctx.head.scripts.map((src) => (
-        <script type="module" src={src}></script>
-      ))}
-    </body>
-  </html>
-))
-`
-}
-
-function baseIndexPage(title: string) {
-  return `import { definePage } from 'davaux'
-
-export default definePage((ctx) => {
-  ctx.head.title = '${title}'
-  return (
-    <main>
-      <h1>Welcome to ${title}</h1>
-      <p>
-        This page is served from the shared base routes (<code>src/routes/</code>). It is visible
-        at any hostname not explicitly registered in <code>multisite.config.ts</code> — in this
-        project, that means any hostname other than <code>localhost</code>.
-      </p>
-      <h2>Get started</h2>
-      <ul>
-        <li>
-          <a href="https://davaux.codeberg.page/docs/packages/multisite">@davaux/multisite</a>
-          {' — '}concepts, API reference, and operating modes
-        </li>
-        <li>
-          <a href="https://davaux.codeberg.page/docs/routing">Routing</a>
-          {' — '}file-based routing, dynamic segments, layouts, and middlewares
-        </li>
-        <li>
-          <a href="https://davaux.codeberg.page/docs/getting-started">Getting started</a>
-          {' — '}core Davaux concepts
-        </li>
-      </ul>
-      <h2>Project structure</h2>
-      <ul>
-        <li>
-          <code>multisite.config.ts</code> — site definitions and per-site config
-        </li>
-        <li>
-          <code>src/routes/</code> — shared base routes (you are here)
-        </li>
-        <li>
-          <code>sites/main/routes/</code> — main site overrides (served at <code>localhost</code>)
-        </li>
-        <li>
-          <code>server.ts</code> — starts the dev and production server
-        </li>
-        <li>
-          <code>build.ts</code> — production build script
-        </li>
-      </ul>
-    </main>
-  )
-})
-`
-}
-
-function siteLayout() {
-  return `export { default } from '../../../src/routes/_layout.js'
-`
-}
-
-function siteIndexPage(title: string) {
-  return `import { definePage } from 'davaux'
-import { getSite } from '@davaux/multisite'
-import type { SiteConfig } from '../../../multisite.config.js'
-
-export default definePage((ctx) => {
-  const site = getSite<SiteConfig>(ctx)
-  ctx.head.title = site?.name ?? '${title}'
-  return (
-    <main>
-      <h1>Welcome to {site?.name ?? '${title}'}</h1>
-      <p>
-        You're looking at the <strong>main</strong> site. Edit{' '}
-        <code>sites/main/routes/index.page.tsx</code> to get started.
-      </p>
-      <p>
-        Site config is defined in <code>multisite.config.ts</code> and accessed here via{' '}
-        <code>getSite(ctx)</code>. Use it for per-site themes, database URLs, feature flags —
-        anything that varies between sites.
-      </p>
-    </main>
-  )
-})
-`
-}

package/src/create.ts

@@ -1,194 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { join, resolve } from 'node:path'
-
-export async function scaffold(name: string | undefined, cwd: string) {
-  if (!name) {
-    console.error('Usage: davaux create <project-name>')
-    process.exit(1)
-  }
-
-  if (!/^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/.test(name)) {
-    console.error(
-      `[davaux] Invalid project name "${name}". Use lowercase letters, numbers, hyphens, underscores, or dots.`,
-    )
-    process.exit(1)
-  }
-
-  const dir = resolve(cwd, name)
-
-  if (existsSync(dir)) {
-    console.error(`[davaux] Directory "${name}" already exists.`)
-    process.exit(1)
-  }
-
-  const title = name.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
-
-  mkdirSync(join(dir, 'src', 'routes'), { recursive: true })
-  mkdirSync(join(dir, 'public'), { recursive: true })
-
-  write(dir, 'package.json', packageJson(name))
-  write(dir, 'tsconfig.json', tsConfig())
-  write(dir, 'davaux.config.ts', davauxConfig())
-  write(dir, 'biome.json', biomeConfig())
-  write(dir, 'src/routes/_layout.tsx', layout(title))
-  write(dir, 'src/routes/index.page.tsx', indexPage(title))
-
-  console.log(`\n  Created project: ${name}\n`)
-  console.log('  Next steps:\n')
-  console.log(`    cd ${name}`)
-  console.log('    npm install')
-  console.log('    npm run dev\n')
-}
-
-function write(dir: string, file: string, content: string) {
-  writeFileSync(join(dir, file), content, 'utf8')
-}
-
-function packageJson(name: string) {
-  return (
-    JSON.stringify(
-      {
-        name,
-        version: '0.1.0',
-        type: 'module',
-        scripts: {
-          dev: 'davaux dev',
-          build: 'davaux build',
-          start: 'davaux start',
-        },
-        dependencies: {
-          davaux: 'latest',
-        },
-        devDependencies: {
-          '@biomejs/biome': 'latest',
-          '@types/node': 'latest',
-        },
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function tsConfig() {
-  return (
-    JSON.stringify(
-      {
-        compilerOptions: {
-          target: 'ESNext',
-          module: 'NodeNext',
-          moduleResolution: 'NodeNext',
-          jsx: 'react-jsx',
-          jsxImportSource: 'davaux',
-          strict: true,
-          lib: ['ESNext', 'DOM'],
-          allowImportingTsExtensions: true,
-          noEmit: true,
-          skipLibCheck: true,
-          types: ['node', 'davaux/env'],
-        },
-        include: ['src/**/*'],
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function davauxConfig() {
-  return `import { defineConfig } from 'davaux/config'
-
-export default defineConfig({
-  server: {
-    port: 3000,
-    hostname: 'localhost',
-  },
-})
-`
-}
-
-function biomeConfig() {
-  return (
-    JSON.stringify(
-      {
-        $schema: 'https://biomejs.dev/schemas/2.4.15/schema.json',
-        assist: { actions: { source: { organizeImports: 'on' } } },
-        linter: {
-          enabled: true,
-          rules: {
-            recommended: true,
-            correctness: {
-              noUnusedVariables: 'error',
-              noUnusedImports: 'error',
-            },
-            style: {
-              noNonNullAssertion: 'warn',
-            },
-          },
-        },
-        formatter: {
-          enabled: true,
-          indentStyle: 'space',
-          indentWidth: 2,
-          lineWidth: 100,
-        },
-        javascript: {
-          formatter: {
-            quoteStyle: 'single',
-            trailingCommas: 'all',
-            semicolons: 'asNeeded',
-          },
-        },
-        css: {
-          formatter: {
-            enabled: true,
-            quoteStyle: 'single',
-          },
-        },
-        files: {
-          includes: ['src/**'],
-        },
-      },
-      null,
-      2,
-    ) + '\n'
-  )
-}
-
-function layout(title: string) {
-  return `import { defineLayout } from 'davaux'
-
-export default defineLayout(({ children, ctx }) => (
-  <html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>{ctx.head.title ?? '${title}'}</title>
-      {ctx.head.description && <meta name="description" content={ctx.head.description} />}
-      {Object.entries(ctx.head.meta).map(([name, content]) => (
-        <meta name={name} content={content} />
-      ))}
-      {ctx.head.stylesheets.map((href) => (
-        <link rel="stylesheet" href={href} />
-      ))}
-    </head>
-    <body>
-      {children as unknown as string}
-      {ctx.head.scripts.map((src) => (
-        <script type="module" src={src}></script>
-      ))}
-    </body>
-  </html>
-))
-`
-}
-
-function indexPage(title: string) {
-  return `import { definePage } from 'davaux'
-
-export default definePage((ctx) => {
-  ctx.head.title = '${title}'
-  return <h1>Welcome to ${title}</h1>
-})
-`
-}

package/src/dev/blueprints.ts

@@ -1,75 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import { extname, join } from 'node:path'
-import { renderToHtml } from '../oml/render.js'
-import type { OmlBlueprint, OmlPropSchema, OmlPropType } from '../oml/types.js'
-import { parseOmlBlueprint } from '../oml/types.js'
-
-export type BlueprintEntry = {
-  id: string
-  name: string
-  props: Record<string, OmlPropSchema>
-  previewHtml: string
-  jsxSnippet: string
-  imports: Record<string, string>
-}
-
-function collectJsonFiles(dir: string, out: string[]): void {
-  if (!existsSync(dir)) return
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry)
-    if (statSync(full).isDirectory()) {
-      collectJsonFiles(full, out)
-    } else if (extname(entry) === '.json') {
-      out.push(full)
-    }
-  }
-}
-
-function propPlaceholder(schema: OmlPropSchema): string {
-  if (schema.default !== undefined) {
-    const d = schema.default
-    if (typeof d === 'string') return `"${d}"`
-    return `{${JSON.stringify(d)}}`
-  }
-  const placeholders: Record<OmlPropType, string> = {
-    string: '"example"',
-    number: '{0}',
-    boolean: '{false}',
-    function: '{() => {}}',
-    node: '"content"',
-    array: '{[]}',
-  }
-  return placeholders[schema.type] ?? '"example"'
-}
-
-function toUsageJsx(bp: OmlBlueprint): string {
-  const entries = Object.entries(bp.props)
-  if (entries.length === 0) return `<${bp.name} />`
-  const lines = entries.map(([name, schema]) => `  ${name}=${propPlaceholder(schema)}`)
-  return `<${bp.name}\n${lines.join('\n')}\n/>`
-}
-
-export function scanBlueprints(cwd: string): BlueprintEntry[] {
-  const files: string[] = []
-  collectJsonFiles(join(cwd, 'src', 'blueprints'), files)
-  collectJsonFiles(join(cwd, 'src', 'components'), files)
-
-  const results: BlueprintEntry[] = []
-  for (const filePath of files) {
-    try {
-      const raw = JSON.parse(readFileSync(filePath, 'utf-8'))
-      const bp = parseOmlBlueprint(raw)
-      results.push({
-        id: bp.id,
-        name: bp.name,
-        props: bp.props,
-        previewHtml: bp.output ? renderToHtml(bp.output) : '',
-        jsxSnippet: toUsageJsx(bp),
-        imports: bp.imports ?? {},
-      })
-    } catch {
-      // Skip files that aren't valid blueprints
-    }
-  }
-  return results
-}

package/src/dev/components.ts

@@ -1,108 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
-import { basename, extname, join, relative } from 'node:path'
-import type { OmlPropSchema, OmlPropType } from '../oml/types.js'
-
-export type ComponentEntry = {
-  name: string
-  file: string
-  importPath: string
-  props: Record<string, OmlPropSchema>
-  hasBlueprintAlready: boolean
-}
-
-function mapTsType(rawType: string): OmlPropType {
-  const t = rawType
-    .trim()
-    .replace(/\s*[|&]\s*(undefined|null)$/g, '')
-    .trim()
-  if (t === 'string') return 'string'
-  if (t === 'number') return 'number'
-  if (t === 'boolean') return 'boolean'
-  if (/ReactNode|JSX\.Element|React\.ReactNode|OmlNode|OmlChild|VNode/.test(t)) return 'node'
-  if (/Array<|[[\]]/.test(t)) return 'array'
-  if (/=>/.test(t) || t === 'Function' || t.startsWith('(')) return 'function'
-  return 'string'
-}
-
-function extractProps(source: string): Record<string, OmlPropSchema> {
-  const props: Record<string, OmlPropSchema> = {}
-  const m = source.match(/(?:interface\s+Props|type\s+Props\s*=)\s*\{([\s\S]*?)\}/)
-  if (!m) return props
-  for (const line of m[1].split('\n')) {
-    const pm = line.match(/^\s*([a-zA-Z_$][a-zA-Z0-9_$]*)(\?)?\s*:\s*([^;,\n]+)/)
-    if (!pm) continue
-    const name = pm[1]
-    if (name === 'children') continue
-    props[name] = { type: mapTsType(pm[3].trim()), required: pm[2] !== '?' }
-  }
-  return props
-}
-
-function collectComponentFiles(dir: string, out: string[]): void {
-  if (!existsSync(dir)) return
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry)
-    if (statSync(full).isDirectory()) {
-      collectComponentFiles(full, out)
-    } else if (['.tsx', '.ts', '.jsx', '.js'].includes(extname(entry)) && /^[A-Z]/.test(entry)) {
-      out.push(full)
-    }
-  }
-}
-
-export function scanComponents(dir: string, cwd: string, blueprintsDir: string): ComponentEntry[] {
-  const files: string[] = []
-  collectComponentFiles(dir, files)
-  const routesDir = join(cwd, 'src', 'routes')
-  return files.map((filePath) => {
-    const name = basename(filePath, extname(filePath))
-    let props: Record<string, OmlPropSchema> = {}
-    try {
-      props = extractProps(readFileSync(filePath, 'utf-8'))
-    } catch {}
-    const noExt = filePath.replace(/\.(tsx?|jsx?)$/, '')
-    const rel = relative(routesDir, noExt)
-    const importPath = rel.startsWith('.') ? rel : `../${rel}`
-    return {
-      name,
-      file: relative(cwd, filePath),
-      importPath,
-      props,
-      hasBlueprintAlready: existsSync(join(blueprintsDir, `${name}.oml.json`)),
-    }
-  })
-}
-
-export function updateBlueprint(
-  id: string,
-  name: string,
-  props: Record<string, OmlPropSchema>,
-  blueprintsDir: string,
-): { saved: boolean; error?: string } {
-  const filePath = join(blueprintsDir, `${id}.oml.json`)
-  try {
-    let existing: Record<string, unknown> = {}
-    if (existsSync(filePath)) existing = JSON.parse(readFileSync(filePath, 'utf-8'))
-    writeFileSync(filePath, JSON.stringify({ ...existing, id, name, props }, null, 2), 'utf-8')
-    return { saved: true }
-  } catch (e) {
-    return { saved: false, error: String(e) }
-  }
-}
-
-export function saveBlueprint(
-  name: string,
-  props: Record<string, OmlPropSchema>,
-  imports: Record<string, string>,
-  blueprintsDir: string,
-): { saved: boolean; file?: string; error?: string } {
-  try {
-    if (!existsSync(blueprintsDir)) mkdirSync(blueprintsDir, { recursive: true })
-    const bp = { id: name, name, props, return: null, imports }
-    const filePath = join(blueprintsDir, `${name}.oml.json`)
-    writeFileSync(filePath, JSON.stringify(bp, null, 2), 'utf-8')
-    return { saved: true, file: filePath }
-  } catch (e) {
-    return { saved: false, error: String(e) }
-  }
-}