hadars 0.1.9 → 0.1.11

package/src/utils/loader.ts

@@ -10,6 +10,12 @@
  *    synchronously on the server, wrapped in Promise.resolve to keep the
  *    API shape identical to the client side.
  *
+ * Transformation strategy:
+ *   Primary  — SWC AST parsing via @swc/core. Handles any valid TS/JS syntax
+ *              including arbitrarily-nested generics, comments, and string
+ *              literals that contain the text "loadModule".
+ *   Fallback — Regex transform used when @swc/core is unavailable.
+ *
  * Example usage:
  *
  *   import { loadModule } from 'hadars';
@@ -21,21 +27,197 @@
  *   const { default: fn } = await loadModule('./heavyUtil');
  */
 
-// Matches: loadModule('./path')
-//          loadModule<SomeType>('./path')   (TypeScript generic, any complexity)
-// Captures group 1 = quote char, group 2 = the module path.
-// The `s` flag lets `.` span newlines so multi-line generics are handled.
-const LOAD_MODULE_RE =
-    /\bloadModule\s*(?:<.*?>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
-
 export default function loader(this: any, source: string): string {
     const isServer = this.target === 'node' || this.target === 'async-node';
+    const resourcePath: string = this.resourcePath ?? this.resource ?? '(unknown)';
+
+    let swc: any;
+    try {
+        swc = require('@swc/core');
+    } catch {
+        return regexTransform.call(this, source, isServer, resourcePath);
+    }
+
+    return swcTransform.call(this, swc, source, isServer, resourcePath);
+}
+
+// ---------------------------------------------------------------------------
+// SWC AST transform
+// ---------------------------------------------------------------------------
+
+function swcTransform(this: any, swc: any, source: string, isServer: boolean, resourcePath: string): string {
+    const isTs = /\.[mc]?tsx?$/.test(resourcePath);
+    const isTsx = /\.(tsx|jsx)$/.test(resourcePath);
+
+    let ast: any;
+    try {
+        ast = swc.parseSync(source, {
+            syntax: isTs ? 'typescript' : 'ecmascript',
+            tsx: isTsx,
+        });
+    } catch {
+        // Unparseable file (e.g., exotic syntax) — fall back to regex
+        return regexTransform.call(this, source, isServer, resourcePath);
+    }
+
+    // SWC spans use 1-based byte offsets into a GLOBAL SourceMap that
+    // accumulates across parseSync calls.
+    //
+    // `ast.span.start` = global position of the FIRST meaningful (non-comment,
+    //   non-whitespace) token.  Subtract the leading non-code bytes to get the
+    //   true global start of byte 0 of this source file.
+    //
+    // We do NOT use `ast.span.end - srcBytes.length` because `ast.span.end`
+    // only reaches the last AST token and does not include trailing whitespace
+    // or newlines — causing a systematic off-by-one for the typical file that
+    // ends with `\n`.
+    const srcBytes = Buffer.from(source, 'utf8');
+    const fileOffset = ast.span.start - countLeadingNonCodeBytes(source);
 
-    return source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) => {
-        if (isServer) {
-            return `Promise.resolve(require(${quote}${modulePath}${quote}))`;
+    const replacements: Array<{ start: number; end: number; replacement: string }> = [];
+
+    walkAst(ast, (node: any) => {
+        if (node.type !== 'CallExpression') return;
+
+        const callee = node.callee;
+        if (!callee || callee.type !== 'Identifier' || callee.value !== 'loadModule') return;
+
+        const args: any[] = node.arguments;
+        if (!args || args.length === 0) return;
+
+        const firstArg = args[0].expression ?? args[0];
+
+        let modulePath: string;
+        let quoteChar: string;
+
+        if (firstArg.type === 'StringLiteral') {
+            modulePath = firstArg.value;
+            // The quote char (' " `) is always ASCII so byte index == char index here.
+            const quoteByteIdx = firstArg.span.start - fileOffset;
+            quoteChar = String.fromCharCode(srcBytes[quoteByteIdx]!);
+        } else if (
+            firstArg.type === 'TemplateLiteral' &&
+            firstArg.expressions.length === 0 &&
+            firstArg.quasis.length === 1
+        ) {
+            // No-interpolation template literal: `./path`
+            modulePath = firstArg.quasis[0].raw;
+            quoteChar = '`';
         } else {
-            return `import(${quote}${modulePath}${quote})`;
+            // Dynamic (non-literal) path — emit a build warning
+            const start0 = node.span.start - fileOffset;
+            const bytesBefore = srcBytes.slice(0, start0);
+            const line = bytesBefore.toString('utf8').split('\n').length;
+            this.emitWarning(
+                new Error(
+                    `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. ` +
+                    `Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+                )
+            );
+            return;
         }
+        const replacement = isServer
+            ? `Promise.resolve(require(${quoteChar}${modulePath}${quoteChar}))`
+            : `import(${quoteChar}${modulePath}${quoteChar})`;
+
+        // Normalise to 0-based local byte offsets for Buffer.slice
+        replacements.push({ start: node.span.start - fileOffset, end: node.span.end - fileOffset, replacement });
     });
+
+    if (replacements.length === 0) return source;
+
+    // Apply replacements from last to first so earlier byte offsets stay valid
+    replacements.sort((a, b) => b.start - a.start);
+
+    let result = srcBytes;
+    for (const { start, end, replacement } of replacements) {
+        result = Buffer.concat([result.slice(0, start), Buffer.from(replacement, 'utf8'), result.slice(end)]);
+    }
+    return result.toString('utf8');
+}
+
+// Minimal recursive AST walker — visits every node depth-first.
+function walkAst(node: any, visit: (n: any) => void): void {
+    if (!node || typeof node !== 'object') return;
+    visit(node);
+    for (const key of Object.keys(node)) {
+        if (key === 'span' || key === 'type' || key === 'ctxt') continue;
+        const val = node[key];
+        if (Array.isArray(val)) {
+            for (const child of val) walkAst(child, visit);
+        } else if (val && typeof val === 'object') {
+            walkAst(val, visit);
+        }
+    }
+}
+
+// Returns the number of leading bytes that are pure whitespace / comments /
+// shebangs — i.e. bytes before the first actual code token.  Used to anchor
+// SWC's accumulated global span offsets back to byte-0 of this source file.
+function countLeadingNonCodeBytes(source: string): number {
+    let i = 0;
+    while (i < source.length) {
+        // Whitespace
+        if (source[i] === ' ' || source[i] === '\t' || source[i] === '\r' || source[i] === '\n') {
+            i++;
+            continue;
+        }
+        // Line comment  //...
+        if (source[i] === '/' && source[i + 1] === '/') {
+            while (i < source.length && source[i] !== '\n') i++;
+            continue;
+        }
+        // Block comment  /* ... */
+        if (source[i] === '/' && source[i + 1] === '*') {
+            i += 2;
+            while (i + 1 < source.length && !(source[i] === '*' && source[i + 1] === '/')) i++;
+            if (i + 1 < source.length) i += 2;
+            continue;
+        }
+        // Shebang  #!...  (only valid at position 0)
+        if (i === 0 && source[i] === '#' && source[i + 1] === '!') {
+            while (i < source.length && source[i] !== '\n') i++;
+            continue;
+        }
+        break;
+    }
+    // SWC spans are UTF-8 byte offsets, but `i` here is a char index.
+    // Return the byte length of the leading non-code prefix.
+    return Buffer.byteLength(source.slice(0, i), 'utf8');
+}
+
+// ---------------------------------------------------------------------------
+// Regex fallback (used when @swc/core is not available)
+// ---------------------------------------------------------------------------
+
+// Matches loadModule('./path') with optional TypeScript generic (up to 2 levels
+// of nesting). Captures: group 1 = quote char, group 2 = module path.
+const LOAD_MODULE_RE =
+    /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
+
+// Matches any remaining loadModule( that was NOT handled by the regex above
+// (i.e. a dynamic / non-literal path argument).
+const DYNAMIC_LOAD_MODULE_RE = /\bloadModule\s*(?:<(?:[^<>]|<[^<>]*>)*>\s*)?\(/g;
+
+function regexTransform(this: any, source: string, isServer: boolean, resourcePath: string): string {
+    const transformed = source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) =>
+        isServer
+            ? `Promise.resolve(require(${quote}${modulePath}${quote}))`
+            : `import(${quote}${modulePath}${quote})`
+    );
+
+    // Warn for any remaining dynamic calls
+    let match: RegExpExecArray | null;
+    DYNAMIC_LOAD_MODULE_RE.lastIndex = 0;
+    while ((match = DYNAMIC_LOAD_MODULE_RE.exec(transformed)) !== null) {
+        const line = transformed.slice(0, match.index).split('\n').length;
+        this.emitWarning(
+            new Error(
+                `[hadars] loadModule() called with a dynamic (non-literal) path at ${resourcePath}:${line}. ` +
+                `Only string-literal paths are transformed by the loader; dynamic calls fall back to runtime import().`
+            )
+        );
+    }
+
+    return transformed;
 }

package/src/utils/response.tsx

@@ -30,49 +30,45 @@ interface ReactResponseOptions {
     }
 }
 
-const getHeadHtml = (seoData: AppHead, renderToStaticMarkup: (el: any) => string): string => {
-    const metaEntries = Object.entries(seoData.meta)
-    const linkEntries = Object.entries(seoData.link)
-    const styleEntries = Object.entries(seoData.style)
-    const scriptEntries = Object.entries(seoData.script)
-
-    return renderToStaticMarkup(
-        <>
-            <title>{seoData.title}</title>
-            {
-            metaEntries.map( ([id, options]) => (
-                <meta
-                    key={id}
-                    id={ id }
-                    { ...options }
-                />
-            ) )
-            }
-            {linkEntries.map( ([id, options]) => (
-                <link
-                    key={id}
-                    id={ id }
-                    { ...options }
-                />
-            ))}
-            {styleEntries.map( ([id, options]) => (
-                <style
-                    key={id}
-                    id={id}
-                    { ...options }
-                />
-            ))}
-            {scriptEntries.map( ([id, options]) => (
-                <script
-                    key={id}
-                    id={id}
-                    { ...options }
-                />
-            ))}
-        </>
-    )
+// ── Head HTML serialisation (no React render needed) ─────────────────────────
+
+const ESC: Record<string, string> = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
+const escAttr = (s: string) => s.replace(/[&<>"]/g, c => ESC[c]);
+const escText = (s: string) => s.replace(/[&<>]/g, c => ESC[c]);
+
+// React prop → HTML attribute name for the subset used in head tags.
+const ATTR: Record<string, string> = {
+    className: 'class', htmlFor: 'for', httpEquiv: 'http-equiv',
+    charSet: 'charset', crossOrigin: 'crossorigin', noModule: 'nomodule',
+    referrerPolicy: 'referrerpolicy', fetchPriority: 'fetchpriority',
+};
+
+function renderHeadTag(tag: string, id: string, opts: Record<string, unknown>, selfClose = false): string {
+    let attrs = ` id="${escAttr(id)}"`;
+    let inner = '';
+    for (const [k, v] of Object.entries(opts)) {
+        if (k === 'key' || k === 'children') continue;
+        if (k === 'dangerouslySetInnerHTML') { inner = (v as any).__html ?? ''; continue; }
+        const attr = ATTR[k] ?? k;
+        if (v === true) attrs += ` ${attr}`;
+        else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
+    }
+    return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
 }
 
+const getHeadHtml = (seoData: AppHead): string => {
+    let html = `<title>${escText(seoData.title ?? '')}</title>`;
+    for (const [id, opts] of Object.entries(seoData.meta))
+        html += renderHeadTag('meta', id, opts as Record<string, unknown>, true);
+    for (const [id, opts] of Object.entries(seoData.link))
+        html += renderHeadTag('link', id, opts as Record<string, unknown>, true);
+    for (const [id, opts] of Object.entries(seoData.style))
+        html += renderHeadTag('style', id, opts as Record<string, unknown>);
+    for (const [id, opts] of Object.entries(seoData.script))
+        html += renderHeadTag('script', id, opts as Record<string, unknown>);
+    return html;
+};
+
 
 export const getReactResponse = async (
     req: HadarsRequest,
@@ -141,20 +137,20 @@ export const getReactResponse = async (
         }
         if (unsuspend.hasPending) await processUnsuspend();
     } while (unsuspend.hasPending && ++iters < 25);
+    if (unsuspend.hasPending) {
+        console.warn('[hadars] SSR render loop hit the 25-iteration cap — some useServerData values may not be resolved. Check for data dependencies that are never fulfilled.');
+    }
 
-    props = getAfterRenderProps ? await getAfterRenderProps(props, html) : props;
-    // Re-render to capture any head changes introduced by getAfterRenderProps.
-    try {
-        (globalThis as any).__hadarsUnsuspend = unsuspend;
-        renderToStaticMarkup(
-            <App {...({
-                ...props,
-                location: req.location,
-                context,
-            })} />
-        );
-    } finally {
-        (globalThis as any).__hadarsUnsuspend = null;
+    if (getAfterRenderProps) {
+        props = await getAfterRenderProps(props, html);
+        // Re-render only when getAfterRenderProps is present — it may mutate
+        // props that affect head tags, so we need another pass to capture them.
+        try {
+            (globalThis as any).__hadarsUnsuspend = unsuspend;
+            renderToStaticMarkup(<App {...({ ...props, location: req.location, context })} />);
+        } finally {
+            (globalThis as any).__hadarsUnsuspend = null;
+        }
     }
 
     // Serialize resolved useServerData() values for client hydration.
@@ -188,7 +184,7 @@ export const getReactResponse = async (
     return {
         ReactPage,
         status: context.head.status,
-        headHtml: getHeadHtml(context.head, renderToStaticMarkup),
+        headHtml: getHeadHtml(context.head),
         renderPayload: {
             appProps: { ...props, location: req.location, context } as Record<string, unknown>,
             clientProps: clientProps as Record<string, unknown>,

package/src/utils/serve.ts

@@ -46,12 +46,52 @@ const noopCtx: ServerContext = { upgrade: () => false };
  * The `fetchHandler` may return `undefined` to signal that the response was
  * handled out-of-band (e.g. a Bun WebSocket upgrade).
  */
+const COMPRESSIBLE_RE = /\b(?:text\/|application\/(?:json|javascript|xml)|image\/svg\+xml)/;
+
+function withCompression(handler: FetchHandler): FetchHandler {
+    return async (req, ctx) => {
+        const res = await handler(req, ctx);
+        if (!res?.body) return res;
+        if (!COMPRESSIBLE_RE.test(res.headers.get('Content-Type') ?? '')) return res;
+        if (res.headers.has('Content-Encoding')) return res; // already compressed
+
+        const accept = req.headers.get('Accept-Encoding') ?? '';
+        const encoding = accept.includes('br') ? 'br' : accept.includes('gzip') ? 'gzip' : null;
+        if (!encoding) return res;
+
+        try {
+            const compressed = res.body.pipeThrough(new (globalThis as any).CompressionStream(encoding));
+            const headers = new Headers(res.headers);
+            headers.set('Content-Encoding', encoding);
+            headers.delete('Content-Length');
+            return new Response(compressed, { status: res.status, statusText: res.statusText, headers });
+        } catch {
+            return res;
+        }
+    };
+}
+
+function withRequestLogging(handler: FetchHandler): FetchHandler {
+    return async (req, ctx) => {
+        const start = performance.now();
+        const res = await handler(req, ctx);
+        const ms = Math.round(performance.now() - start);
+        const status = res?.status ?? 404;
+        const path = new URL(req.url).pathname;
+        console.log(`[hadars] ${req.method} ${path} ${status} ${ms}ms`);
+        return res;
+    };
+}
+
 export async function serve(
     port: number,
     fetchHandler: FetchHandler,
     /** Bun WebSocketHandler — ignored on Deno and Node.js. */
     websocket?: unknown,
 ): Promise<void> {
+    fetchHandler = withCompression(fetchHandler);
+    fetchHandler = withRequestLogging(fetchHandler);
+
     // ── Bun ────────────────────────────────────────────────────────────────
     if (isBun) {
         (globalThis as any).Bun.serve({

package/src/utils/loadModule.ts

@@ -1,4 +0,0 @@
-export const loadModule = <T>(path: string): T => {
-    return import(path) as unknown as T;
-    // throw new Error('loadModule should be transformed by loader')
-}