arcway 0.1.0

package/server/pages/discovery.js

@@ -0,0 +1,120 @@
+import { glob } from '../glob.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import {
+  filePathToPattern,
+  compilePattern,
+  sortBySpecificity,
+  matchPattern,
+} from '../router/routes.js';
+function dirDepth(dirPath) {
+  return dirPath === '' ? 0 : dirPath.split(path.sep).length;
+}
+function dirDepthForward(dirPath) {
+  return dirPath === '' ? 0 : dirPath.split('/').length;
+}
+async function discoverSpecialFiles(pagesDir, fileName, extensions) {
+  const pattern = path.join(pagesDir, '**', `${fileName}.{${extensions}}`);
+  const files = await glob(pattern);
+  const result = [];
+  for (const filePath of files) {
+    const dirPath = path.relative(pagesDir, path.dirname(filePath)).replace(/\\/g, '/');
+    result.push({ dirPath, filePath });
+  }
+  result.sort((a, b) => dirDepth(b.dirPath) - dirDepth(a.dirPath));
+  return result;
+}
+function resolveFileChain(pagePattern, items) {
+  const pagePath = pagePattern === '/' ? '' : pagePattern.slice(1);
+  const chain = [];
+  for (const item of items) {
+    if (item.dirPath === '') {
+      chain.push(item);
+      continue;
+    }
+    const prefix = item.dirPath.replace(/\\/g, '/').replace(/\[([^\]]+)\]/g, ':$1');
+    const normalized = pagePath.replace(/\\/g, '/');
+    if (normalized === prefix || normalized.startsWith(prefix + '/')) {
+      chain.push(item);
+    }
+  }
+  chain.sort((a, b) => dirDepthForward(a.dirPath) - dirDepthForward(b.dirPath));
+  return chain;
+}
+async function discoverPages(pagesDir) {
+  const pattern = path.join(pagesDir, '**', '*.{tsx,jsx,ts,js}');
+  const pageFiles = await glob(pattern);
+  const pages = [];
+  for (const filePath of pageFiles) {
+    const fileName = path.basename(filePath);
+    if (fileName.startsWith('_')) continue;
+    const relPath = path.relative(pagesDir, filePath);
+    const urlPattern = filePathToPattern(relPath);
+    const { regex, paramNames, catchAllParam } = compilePattern(urlPattern);
+    pages.push({
+      pattern: urlPattern,
+      regex,
+      paramNames,
+      ...(catchAllParam ? { catchAllParam } : {}),
+      filePath,
+    });
+  }
+  sortBySpecificity(pages);
+  return pages;
+}
+async function discoverLayouts(pagesDir) {
+  return discoverSpecialFiles(pagesDir, '_layout', 'tsx,jsx,ts,js');
+}
+function resolveLayoutChain(pagePattern, layouts) {
+  return resolveFileChain(pagePattern, layouts);
+}
+async function discoverLoadings(pagesDir) {
+  return discoverSpecialFiles(pagesDir, '_loading', 'tsx,jsx,ts,js');
+}
+function resolveLoadingChain(pagePattern, loadings) {
+  return resolveFileChain(pagePattern, loadings);
+}
+async function discoverPageMiddleware(pagesDir) {
+  return discoverSpecialFiles(pagesDir, '_middleware', 'ts,js');
+}
+function resolvePageMiddlewareChain(pagePattern, middlewares) {
+  return resolveFileChain(pagePattern, middlewares);
+}
+async function discoverErrorPages(pagesDir) {
+  const result = {};
+  const errorFiles = await glob(path.join(pagesDir, '_error.{tsx,jsx,ts,js}'));
+  if (errorFiles.length > 0) {
+    result.errorPage = errorFiles[0];
+  }
+  const notFoundFiles = await glob(path.join(pagesDir, '_404.{tsx,jsx,ts,js}'));
+  if (notFoundFiles.length > 0) {
+    result.notFoundPage = notFoundFiles[0];
+  }
+  return result;
+}
+async function discoverStyles(pagesDir) {
+  const stylesPath = path.join(pagesDir, '_styles.css');
+  try {
+    await fs.access(stylesPath);
+    return stylesPath;
+  } catch {
+    return void 0;
+  }
+}
+function matchPage(pages, pathname) {
+  const result = matchPattern(pages, pathname);
+  if (!result) return null;
+  return { page: result.match, params: result.params };
+}
+export {
+  discoverErrorPages,
+  discoverLayouts,
+  discoverLoadings,
+  discoverPageMiddleware,
+  discoverPages,
+  discoverStyles,
+  matchPage,
+  resolveLayoutChain,
+  resolveLoadingChain,
+  resolvePageMiddlewareChain,
+};

package/server/pages/fonts.js

@@ -0,0 +1,128 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+const MIME_MAP = {
+  '.woff2': 'font/woff2',
+  '.woff': 'font/woff',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+};
+const FORMAT_MAP = {
+  '.woff2': 'woff2',
+  '.woff': 'woff',
+  '.ttf': 'truetype',
+  '.otf': 'opentype',
+};
+const FONT_EXTENSIONS = new Set(Object.keys(MIME_MAP));
+const FORMAT_PRIORITY = {
+  '.woff2': 0,
+  '.woff': 1,
+  '.ttf': 2,
+  '.otf': 3,
+};
+const NAMED_WEIGHTS = {
+  thin: 100,
+  hairline: 100,
+  extralight: 200,
+  ultralight: 200,
+  light: 300,
+  regular: 400,
+  normal: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  bold: 700,
+  extrabold: 800,
+  ultrabold: 800,
+  black: 900,
+  heavy: 900,
+};
+async function scanFontDirectory(srcDir, publicDir) {
+  const dirPath = path.join(publicDir, srcDir);
+  let entries;
+  try {
+    entries = await fs.readdir(dirPath);
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const ext = path.extname(entry).toLowerCase();
+    if (!FONT_EXTENSIONS.has(ext)) continue;
+    const baseName = path.basename(entry, ext).toLowerCase();
+    let weight;
+    const numericWeight = parseInt(baseName, 10);
+    if (!isNaN(numericWeight) && numericWeight >= 1 && numericWeight <= 999) {
+      weight = numericWeight;
+    } else {
+      weight = NAMED_WEIGHTS[baseName];
+    }
+    if (weight === void 0) continue;
+    files.push({
+      weight,
+      ext,
+      relativePath: `${srcDir}/${entry}`,
+    });
+  }
+  files.sort((a, b) => {
+    if (a.weight !== b.weight) return a.weight - b.weight;
+    return (FORMAT_PRIORITY[a.ext] ?? 99) - (FORMAT_PRIORITY[b.ext] ?? 99);
+  });
+  return files;
+}
+function generateFontFaceCss(family, files) {
+  const byWeight = new Map();
+  for (const file of files) {
+    const group = byWeight.get(file.weight) ?? [];
+    group.push(file);
+    byWeight.set(file.weight, group);
+  }
+  const rules = [];
+  for (const [weight, weightFiles] of byWeight) {
+    const sorted = [...weightFiles].sort(
+      (a, b) => (FORMAT_PRIORITY[a.ext] ?? 99) - (FORMAT_PRIORITY[b.ext] ?? 99),
+    );
+    const srcEntries = sorted.map((f) => {
+      const url = f.relativePath.startsWith('/') ? f.relativePath : `/${f.relativePath}`;
+      const format = FORMAT_MAP[f.ext] ?? 'woff2';
+      return `url('${url}') format('${format}')`;
+    });
+    rules.push(
+      `@font-face {
+  font-family: '${family}';
+  src: ${srcEntries.join(',\n    ')};
+  font-weight: ${weight};
+  font-style: normal;
+  font-display: swap;
+}`,
+    );
+  }
+  return rules.join('\n\n');
+}
+async function resolveFonts(configs, publicDir) {
+  const cssBlocks = [];
+  const preloadTags = [];
+  for (const config of configs) {
+    const files = await scanFontDirectory(config.src, publicDir);
+    if (files.length === 0) continue;
+    const css = generateFontFaceCss(config.family, files);
+    if (css) cssBlocks.push(css);
+    if (config.preload && config.preload.length > 0) {
+      const preloadWeights = new Set(config.preload);
+      for (const weight of preloadWeights) {
+        const weightFiles = files.filter((f) => f.weight === weight);
+        if (weightFiles.length === 0) continue;
+        const best = weightFiles[0];
+        const url = best.relativePath.startsWith('/') ? best.relativePath : `/${best.relativePath}`;
+        const type = MIME_MAP[best.ext] ?? 'font/woff2';
+        preloadTags.push(
+          `<link rel="preload" as="font" type="${type}" href="${url}" crossorigin="anonymous" />`,
+        );
+      }
+    }
+  }
+  return {
+    fontFaceCss: cssBlocks.join('\n\n'),
+    preloadHtml: preloadTags.join('\n'),
+  };
+}
+export { generateFontFaceCss, resolveFonts, scanFontDirectory };

package/server/pages/handler.js

@@ -0,0 +1,276 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { EventEmitter } from 'node:events';
+import { compilePattern, sortBySpecificity, matchPattern } from '../router/routes.js';
+import { parseCookies, resolveSession, flattenHeaders } from '../session/helpers.js';
+import { loadComponent, renderPage, renderErrorPage, syncReactInternals } from './ssr.js';
+import { MIME_TYPES } from './static.js';
+import {
+  renderPage as renderPage2,
+  buildScriptTags as buildScriptTags2,
+  buildCssLinkTag as buildCssLinkTag2,
+  buildFontPreloadTags,
+} from './ssr.js';
+function createPagesHandler(options) {
+  const rootDir = options.rootDir;
+  const outDir = path.resolve(rootDir, options.outDir ?? '.build/pages');
+  const manifestPath = path.join(outDir, 'pages-manifest.json');
+  const sessionConfig = options.session;
+  const appContext = options.appContext ?? null;
+  const devMode = options.devMode ?? false;
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  const projectRequire = createRequire(path.join(options.rootDir, 'package.json'));
+  const projectReactModule = projectRequire('react');
+  const projectReact = {
+    createElement: projectReactModule.createElement,
+    renderToPipeableStream: projectRequire('react-dom/server').renderToPipeableStream,
+  };
+  syncReactInternals(projectReactModule);
+  let manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  let routes = compileRoutes(manifest);
+  let clientManifestJson = buildClientManifestJson(manifest);
+  const componentCache = new Map();
+  let cacheVersion = 0;
+  const reloadEmitter = devMode ? new EventEmitter() : null;
+  if (manifest.entries.length === 0 && !manifest.notFoundBundle && !manifest.errorBundle) {
+    return null;
+  }
+  function reload() {
+    if (!fs.existsSync(manifestPath)) return;
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    routes = compileRoutes(manifest);
+    clientManifestJson = buildClientManifestJson(manifest);
+    componentCache.clear();
+    cacheVersion++;
+  }
+  function emitEvent(event) {
+    if (!reloadEmitter) return;
+    reloadEmitter.emit('update', event);
+  }
+  async function handle(req, res) {
+    const method = req.method ?? 'GET';
+    const url = req.url ?? '/';
+    const pathname = url.split('?')[0];
+    if (method !== 'GET') return false;
+    if (reloadEmitter && pathname === '/__livereload') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+      res.write('data: connected\n\n');
+      const onUpdate = (event) => {
+        res.write(`data: ${JSON.stringify(event)}
+
+`);
+      };
+      reloadEmitter.on('update', onUpdate);
+      req.on('close', () => reloadEmitter.off('update', onUpdate));
+      return true;
+    }
+    const matched = matchPageRoute(routes, pathname);
+    if (!matched) {
+      if (manifest.notFoundBundle) {
+        await renderErrorPage(
+          manifest.notFoundBundle,
+          404,
+          { pathname },
+          outDir,
+          res,
+          componentCache,
+          manifest,
+          cacheVersion,
+          projectReact,
+        );
+        return true;
+      }
+      return false;
+    }
+    if (matched.route.middlewareServerBundles.length > 0) {
+      const middlewareResult = await runPageMiddleware(
+        matched.route,
+        matched.params,
+        pathname,
+        req,
+        outDir,
+        componentCache,
+        cacheVersion,
+        sessionConfig,
+        appContext,
+      );
+      if (middlewareResult) {
+        if (middlewareResult.redirect) {
+          const status2 = middlewareResult.status ?? 302;
+          const headers2 = {
+            Location: middlewareResult.redirect,
+            ...middlewareResult.headers,
+          };
+          res.writeHead(status2, headers2);
+          res.end();
+          return true;
+        }
+        const status = middlewareResult.status ?? 403;
+        const headers = {
+          'Content-Type': 'text/html; charset=utf-8',
+          ...middlewareResult.headers,
+        };
+        res.writeHead(status, headers);
+        res.end(middlewareResult.body ?? `<h1>${status} - Forbidden</h1>`);
+        return true;
+      }
+    }
+    try {
+      await renderPage(
+        matched.route,
+        matched.params,
+        pathname,
+        manifest,
+        clientManifestJson,
+        outDir,
+        res,
+        componentCache,
+        cacheVersion,
+        projectReact,
+        devMode,
+      );
+    } catch (err) {
+      if (manifest.errorBundle && !res.headersSent) {
+        const errorMessage =
+          process.env.NODE_ENV === 'production'
+            ? 'An unexpected error occurred'
+            : err instanceof Error
+              ? err.message
+              : String(err);
+        await renderErrorPage(
+          manifest.errorBundle,
+          500,
+          { error: errorMessage },
+          outDir,
+          res,
+          componentCache,
+          manifest,
+          cacheVersion,
+          projectReact,
+        );
+      } else if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.end('<h1>500 - Internal Server Error</h1>');
+      }
+    }
+    return true;
+  }
+  return {
+    handle,
+    reload,
+    ...(devMode
+      ? {
+          emitEvent,
+          getClientManifestJson: () => clientManifestJson,
+        }
+      : {}),
+  };
+}
+function compileRoutes(manifest) {
+  const routes = manifest.entries.map((entry) => {
+    const { regex, paramNames, catchAllParam } = compilePattern(entry.pattern);
+    return {
+      pattern: entry.pattern,
+      regex,
+      paramNames,
+      ...(catchAllParam ? { catchAllParam } : {}),
+      serverBundle: entry.serverBundle,
+      clientBundle: entry.clientBundle,
+      layoutServerBundles: entry.layoutServerBundles ?? [],
+      middlewareServerBundles: entry.middlewareServerBundles ?? [],
+    };
+  });
+  sortBySpecificity(routes);
+  return routes;
+}
+function matchPageRoute(routes, pathname) {
+  const result = matchPattern(routes, pathname);
+  if (!result) return null;
+  return { route: result.match, params: result.params };
+}
+async function runPageMiddleware(
+  route,
+  params,
+  pathname,
+  req,
+  outDir,
+  componentCache,
+  cacheVersion,
+  sessionConfig,
+  appContext,
+) {
+  const headers = flattenHeaders(req.headers);
+  const cookies = parseCookies(req);
+  const session = await resolveSession(cookies, sessionConfig);
+  const page = {
+    pathname,
+    query: params,
+    headers,
+    cookies,
+    session,
+  };
+  const ctx = appContext
+    ? {
+        page,
+        db: appContext.db,
+        log: appContext.log,
+        events: appContext.events,
+        cache: appContext.cache,
+        queue: appContext.queue,
+        files: appContext.files,
+        mail: appContext.mail,
+      }
+    : { page };
+  for (const bundlePath of route.middlewareServerBundles) {
+    const fullPath = path.join(outDir, bundlePath);
+    const middlewareFn = await loadComponent(
+      fullPath,
+      `middleware:${bundlePath}`,
+      componentCache,
+      cacheVersion,
+    );
+    if (!middlewareFn || typeof middlewareFn !== 'function') {
+      continue;
+    }
+    const result = await middlewareFn(ctx);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
+function buildClientManifestJson(manifest) {
+  const clientManifest = {
+    routes: manifest.entries.map((entry) => {
+      const route = {
+        pattern: entry.pattern,
+        paramNames: entry.paramNames,
+        clientBundle: `/static/${entry.navBundle}`,
+        layoutBundles: (entry.layoutClientBundles ?? []).map((b) => `/static/${b}`),
+        loadingBundles: (entry.loadingClientBundles ?? []).map((b) => `/static/${b}`),
+      };
+      if (entry.catchAllParam) {
+        route.catchAllParam = entry.catchAllParam;
+      }
+      return route;
+    }),
+  };
+  return JSON.stringify(clientManifest).replace(/</g, '\\u003c');
+}
+export {
+  MIME_TYPES,
+  buildClientManifestJson,
+  buildCssLinkTag2 as buildCssLinkTag,
+  buildFontPreloadTags,
+  buildScriptTags2 as buildScriptTags,
+  createPagesHandler,
+  matchPageRoute,
+  renderPage2 as renderPage,
+};

package/server/pages/hmr.js

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import esbuild from 'esbuild';
+function reactRefreshPlugin(rootDir) {
+  const require2 = createRequire(import.meta.url);
+  const refreshBabelPath = require2.resolve('react-refresh/babel');
+  return {
+    name: 'react-refresh',
+    setup(build) {
+      build.onLoad({ filter: /\.(jsx?|tsx)$/ }, async (args) => {
+        if (args.path.includes('node_modules')) return;
+        const source = await fs.readFile(args.path, 'utf-8');
+        let babel;
+        try {
+          babel = await import('@babel/core');
+        } catch {
+          return;
+        }
+        let result;
+        try {
+          result = await babel.transformAsync(source, {
+            filename: args.path,
+            plugins: [refreshBabelPath],
+            parserOpts: {
+              sourceType: 'module',
+              plugins: ['jsx', 'typescript'],
+            },
+            // Don't transform anything else — just add refresh calls
+            presets: [],
+            ast: false,
+            sourceMaps: 'inline',
+            configFile: false,
+            babelrc: false,
+          });
+        } catch {
+          return;
+        }
+        if (!result?.code) return;
+        const moduleId = path.relative(rootDir, args.path).replace(/\\/g, '/');
+        const preamble = [
+          `var $RefreshReg$ = function() {};`,
+          `var $RefreshSig$ = function() { return function(type) { return type; }; };`,
+          `if (typeof window !== 'undefined' && window.__REACT_REFRESH__) {`,
+          `  $RefreshReg$ = function(type, id) {`,
+          `    window.__REACT_REFRESH__.register(type, ${JSON.stringify(moduleId)} + " " + id);`,
+          `  };`,
+          `  $RefreshSig$ = window.__REACT_REFRESH__.createSignatureFunctionForTransform;`,
+          `}`,
+        ].join('\n');
+        return {
+          contents: preamble + '\n' + result.code,
+          loader: args.path.endsWith('.tsx') || args.path.endsWith('.ts') ? 'tsx' : 'jsx',
+        };
+      });
+    },
+  };
+}
+async function buildHmrRuntimeBundle(outDir) {
+  const require2 = createRequire(import.meta.url);
+  const runtimeEntry = require2.resolve('react-refresh/runtime');
+  const hmrDir = path.join(outDir, 'client', 'hmr');
+  await fs.mkdir(hmrDir, { recursive: true });
+  await esbuild.build({
+    entryPoints: [runtimeEntry],
+    outfile: path.join(hmrDir, 'runtime.js'),
+    format: 'esm',
+    platform: 'browser',
+    bundle: true,
+    minify: false,
+    sourcemap: false,
+  });
+}
+function buildHmrScript() {
+  return `<script type="module">
+import RefreshRuntime from '/static/client/hmr/runtime.js';
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = function() {};
+window.$RefreshSig$ = function() { return function(type) { return type; }; };
+window.__REACT_REFRESH__ = RefreshRuntime;
+
+var es = new EventSource('/__livereload');
+es.onmessage = function(e) {
+  if (e.data === 'connected') return;
+  var msg;
+  try { msg = JSON.parse(e.data); } catch { window.location.reload(); return; }
+  if (msg.type === 'reload') {
+    window.location.reload();
+  } else if (msg.type === 'hmr-update') {
+    var imports = msg.modules.map(function(m) {
+      return import('/static/' + m + '?t=' + msg.timestamp);
+    });
+    Promise.all(imports).then(function() {
+      RefreshRuntime.performReactRefresh();
+      if (msg.manifest) {
+        var el = document.getElementById('__app_manifest');
+        if (el) el.textContent = msg.manifest;
+        window.dispatchEvent(new CustomEvent('manifest-update'));
+      }
+    }).catch(function(err) {
+      console.warn('[HMR] Fast Refresh failed, doing full reload', err);
+      window.location.reload();
+    });
+  } else if (msg.type === 'css-update') {
+    var links = document.querySelectorAll('link[rel="stylesheet"][href*="/static/"]');
+    links.forEach(function(link) {
+      link.href = '/static/' + msg.cssBundle + '?t=' + msg.timestamp;
+    });
+  }
+};
+es.onerror = function() {
+  setTimeout(function() { es.close(); }, 5000);
+};
+</script>`;
+}
+function diffClientMetafiles(oldMeta, newMeta, outDir) {
+  const oldOutputs = new Set(Object.keys(oldMeta.outputs));
+  const newOutputs = new Set(Object.keys(newMeta.outputs));
+  const newFiles = [];
+  for (const f of newOutputs) {
+    if (!oldOutputs.has(f) && !f.endsWith('.map')) {
+      newFiles.push(f);
+    }
+  }
+  if (newFiles.length === 0) {
+    return { changedNavBundles: [], changedCssBundle: null, needsFullReload: false };
+  }
+  const getEntryNames = (meta) => {
+    const names = new Set();
+    for (const output of Object.values(meta.outputs)) {
+      if (output.entryPoint) {
+        const base = path.basename(output.entryPoint, path.extname(output.entryPoint));
+        names.add(base);
+      }
+    }
+    return names;
+  };
+  const oldEntries = getEntryNames(oldMeta);
+  const newEntries = getEntryNames(newMeta);
+  let needsFullReload = false;
+  if (oldEntries.size !== newEntries.size) {
+    needsFullReload = true;
+  } else {
+    for (const name of oldEntries) {
+      if (!newEntries.has(name)) {
+        needsFullReload = true;
+        break;
+      }
+    }
+  }
+  const changedNavBundles = [];
+  let changedCssBundle = null;
+  for (const f of newFiles) {
+    const rel = path.relative(outDir, f).replace(/\\/g, '/');
+    if (/^client\/nav_/.test(rel)) {
+      changedNavBundles.push(rel);
+    } else if (rel.endsWith('.css')) {
+      changedCssBundle = rel;
+    }
+  }
+  const hasChangedHydrationBundles = newFiles.some((f) => {
+    const rel = path.relative(outDir, f).replace(/\\/g, '/');
+    return (
+      rel.startsWith('client/') &&
+      !rel.startsWith('client/nav_') &&
+      !rel.startsWith('client/chunks/') &&
+      !rel.endsWith('.css') &&
+      !rel.startsWith('client/hmr/')
+    );
+  });
+  if (hasChangedHydrationBundles && changedNavBundles.length === 0) {
+    needsFullReload = true;
+  }
+  return { changedNavBundles, changedCssBundle, needsFullReload };
+}
+export { buildHmrRuntimeBundle, buildHmrScript, diffClientMetafiles, reactRefreshPlugin };