npm - hadars - Versions diffs - 0.4.1 → 0.4.2 - Mend

hadars 0.4.1 → 0.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/dist/{chunk-TV37IMRB.js → chunk-2TMQUXFL.js} +10 -10
package/dist/{chunk-2J2L2H3H.js → chunk-NYLXE7T7.js} +6 -6
package/dist/{chunk-OS3V4CPN.js → chunk-OZUZS2PD.js} +4 -4
package/dist/cli.js +462 -496
package/dist/cloudflare.cjs +11 -11
package/dist/cloudflare.js +3 -3
package/dist/index.d.cts +8 -4
package/dist/index.d.ts +8 -4
package/dist/lambda.cjs +11 -11
package/dist/lambda.js +7 -7
package/dist/loader.cjs +90 -54
package/dist/slim-react/index.cjs +13 -13
package/dist/slim-react/index.js +2 -2
package/dist/slim-react/jsx-runtime.cjs +2 -4
package/dist/slim-react/jsx-runtime.js +1 -1
package/dist/ssr-render-worker.js +174 -161
package/dist/ssr-watch.js +40 -74
package/package.json +8 -10
package/cli-lib.ts +0 -676
package/cli.ts +0 -36
package/index.ts +0 -17
package/src/build.ts +0 -805
package/src/cloudflare.ts +0 -140
package/src/index.tsx +0 -41
package/src/lambda.ts +0 -287
package/src/slim-react/context.ts +0 -55
package/src/slim-react/dispatcher.ts +0 -87
package/src/slim-react/hooks.ts +0 -137
package/src/slim-react/index.ts +0 -232
package/src/slim-react/jsx-runtime.ts +0 -7
package/src/slim-react/jsx.ts +0 -53
package/src/slim-react/render.ts +0 -1101
package/src/slim-react/renderContext.ts +0 -294
package/src/slim-react/types.ts +0 -33
package/src/source/context.ts +0 -113
package/src/source/graphiql.ts +0 -101
package/src/source/inference.ts +0 -260
package/src/source/runner.ts +0 -138
package/src/source/store.ts +0 -50
package/src/ssr-render-worker.ts +0 -116
package/src/ssr-watch.ts +0 -62
package/src/static.ts +0 -109
package/src/types/global.d.ts +0 -5
package/src/types/hadars.ts +0 -350
package/src/utils/Head.tsx +0 -462
package/src/utils/clientScript.tsx +0 -71
package/src/utils/cookies.ts +0 -16
package/src/utils/loader.ts +0 -335
package/src/utils/proxyHandler.tsx +0 -104
package/src/utils/request.tsx +0 -9
package/src/utils/response.tsx +0 -141
package/src/utils/rspack.ts +0 -467
package/src/utils/runtime.ts +0 -19
package/src/utils/serve.ts +0 -155
package/src/utils/ssrHandler.ts +0 -239
package/src/utils/staticFile.ts +0 -43
package/src/utils/template.html +0 -11
package/src/utils/upgradeRequest.tsx +0 -19

package/src/utils/ssrHandler.ts DELETED Viewed

@@ -1,239 +0,0 @@
-import { parseRequest } from './request';
-import { buildHeadHtml } from './response';
-import type { AppHead, HadarsOptions } from '../types/hadars';
-export const HEAD_MARKER = '<meta name="HADARS_HEAD">';
-export const BODY_MARKER = '<meta name="HADARS_BODY">';
-const encoder = new TextEncoder();
-// ── HTML response assembly ────────────────────────────────────────────────────
-export function buildSsrResponse(
-    head: AppHead,
-    status: number,
-    getAppBody: () => Promise<string>,
-    finalize: () => Promise<{ clientProps: Record<string, unknown> }>,
-    getPrecontentHtml: (headHtml: string) => [string, string] | Promise<[string, string]>,
-): Response {
-    const headHtml = buildHeadHtml(head);
-    const precontentResult = getPrecontentHtml(headHtml);
-    const responseStream = new ReadableStream({
-        async start(controller) {
-            try {
-                // Resolve the template — sync on the hot path (every request after the first).
-                const [precontentHtml, postContent] = precontentResult instanceof Promise
-                    ? await precontentResult
-                    : precontentResult;
-                // Chunk 1 — flush the full <head> shell immediately so the browser
-                // can start loading CSS / fonts / preload hints before the body arrives.
-                controller.enqueue(encoder.encode(precontentHtml));
-                // Chunk 2 — body HTML. getAppBody() triggers the actual renderToString
-                // now that head has been flushed. All data is cached from the preflight
-                // so this pass is fast (no async waits).
-                const bodyHtml = await getAppBody();
-                controller.enqueue(encoder.encode(`<div id="app">${bodyHtml}</div>`));
-                // Chunk 3 — JSON props script + post-content. Separated so the browser
-                // can parse/render the body while getFinalProps is still completing.
-                const { clientProps } = await finalize();
-                const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c');
-                controller.enqueue(encoder.encode(
-                    `<script id="hadars" type="application/json">${scriptContent}</script>` +
-                    postContent,
-                ));
-                controller.close();
-            } catch (err) {
-                // Head chunk may already be sent; signal a stream error so the
-                // connection is closed cleanly rather than hanging.
-                controller.error(err);
-            }
-        },
-    });
-    return new Response(responseStream, {
-        headers: { 'Content-Type': 'text/html; charset=utf-8' },
-        status,
-    });
-}
-/**
- * Like {@link buildSsrResponse} but returns the complete HTML string directly
- * instead of wrapping it in a streaming Response. Use this in environments
- * where streaming is not beneficial (e.g. AWS Lambda) to avoid the
- * ReadableStream allocation and the subsequent `.text()` drain overhead.
- */
-export async function buildSsrHtml(
-    bodyHtml: string,
-    clientProps: Record<string, unknown>,
-    headHtml: string,
-    getPrecontentHtml: (headHtml: string) => [string, string] | Promise<[string, string]>,
-): Promise<string> {
-    const [precontentHtml, postContent] = await Promise.resolve(getPrecontentHtml(headHtml));
-    const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c');
-    return (
-        precontentHtml +
-        `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` +
-        postContent
-    );
-}
-/**
- * Returns a function that parses `out.html` into pre-head, post-head, and
- * post-content segments and caches the result. Call the returned function with
- * the per-request headHtml to produce the full HTML prefix and suffix.
- */
-export const makePrecontentHtmlGetter = (htmlFilePromise: Promise<string>) => {
-    let preHead: string | null = null;
-    let postHead: string | null = null;
-    let postContent: string | null = null;
-    // Parse the template as soon as the file read completes — during the
-    // process's idle time before the first request arrives.  This way the
-    // first real request finds preHead !== null and takes the sync path.
-    const primed = htmlFilePromise.then(html => {
-        const headEnd = html.indexOf(HEAD_MARKER);
-        const contentStart = html.indexOf(BODY_MARKER);
-        preHead = html.slice(0, headEnd);
-        postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
-        postContent = html.slice(contentStart + BODY_MARKER.length);
-    });
-    // Returns synchronously once the template has been loaded and parsed
-    // (every request after the first).  Callers can check `instanceof Promise`
-    // to take a zero-await hot path.
-    return (headHtml: string): [string, string] | Promise<[string, string]> => {
-        if (preHead !== null) {
-            // Hot path — sync return, no Promise allocation.
-            return [preHead + headHtml + postHead!, postContent!];
-        }
-        return primed.then(() => [preHead! + headHtml + postHead!, postContent!]);
-    };
-};
-// ── SSR response cache ────────────────────────────────────────────────────────
-export interface CacheEntry {
-    /** Gzip-compressed response body. */
-    body: Uint8Array;
-    status: number;
-    /** Headers with Content-Encoding: gzip already set. */
-    headers: [string, string][];
-    expiresAt: number | null;
-}
-export type CacheFetchHandler = (req: Request, ctx: any) => Promise<Response | undefined>;
-async function transformStream(
-    data: Uint8Array,
-    stream: { writable: WritableStream; readable: ReadableStream<Uint8Array> },
-): Promise<Uint8Array> {
-    const writer = stream.writable.getWriter();
-    writer.write(data);
-    writer.close();
-    const chunks: Uint8Array[] = [];
-    const reader = stream.readable.getReader();
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        chunks.push(value);
-    }
-    const total = chunks.reduce((n, c) => n + c.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const c of chunks) { out.set(c, offset); offset += c.length; }
-    return out;
-}
-// Use the Web Streams CompressionStream when available (Bun, Deno, Node ≥ 18).
-// Fall back to node:zlib on older Node versions.
-async function zlibGzip(d: Uint8Array): Promise<Uint8Array> {
-    const zlib = await import('node:zlib');
-    const { promisify } = await import('node:util');
-    return promisify(zlib.gzip)(d) as Promise<Uint8Array>;
-}
-async function zlibGunzip(d: Uint8Array): Promise<Uint8Array> {
-    const zlib = await import('node:zlib');
-    const { promisify } = await import('node:util');
-    return promisify(zlib.gunzip)(d) as Promise<Uint8Array>;
-}
-export const gzipCompress = (d: Uint8Array): Promise<Uint8Array> =>
-    (globalThis as any).CompressionStream
-        ? transformStream(d, new (globalThis as any).CompressionStream('gzip'))
-        : zlibGzip(d);
-export const gzipDecompress = (d: Uint8Array): Promise<Uint8Array> =>
-    (globalThis as any).DecompressionStream
-        ? transformStream(d, new (globalThis as any).DecompressionStream('gzip'))
-        : zlibGunzip(d);
-export async function buildCacheEntry(res: Response, ttl: number | undefined): Promise<CacheEntry> {
-    const buf = await res.arrayBuffer();
-    const body = await gzipCompress(new Uint8Array(buf));
-    const headers: [string, string][] = [];
-    res.headers.forEach((v, k) => {
-        if (k.toLowerCase() !== 'content-encoding' && k.toLowerCase() !== 'content-length') {
-            headers.push([k, v]);
-        }
-    });
-    headers.push(['content-encoding', 'gzip']);
-    return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
-}
-export async function serveFromEntry(entry: CacheEntry, req: Request): Promise<Response> {
-    const accept = req.headers.get('Accept-Encoding') ?? '';
-    if (accept.includes('gzip')) {
-        return new Response(entry.body.buffer as ArrayBuffer, { status: entry.status, headers: entry.headers });
-    }
-    const plain = await gzipDecompress(entry.body);
-    const headers = entry.headers.filter(([k]) => k.toLowerCase() !== 'content-encoding');
-    return new Response(plain.buffer as ArrayBuffer, { status: entry.status, headers });
-}
-export function createRenderCache(
-    opts: NonNullable<HadarsOptions['cache']>,
-    handler: CacheFetchHandler,
-): CacheFetchHandler {
-    const store    = new Map<string, CacheEntry>();
-    const inFlight = new Map<string, Promise<CacheEntry | null>>();
-    return async (req, ctx) => {
-        const hadarsReq = parseRequest(req);
-        const cacheOpts = await opts(hadarsReq);
-        const key = cacheOpts?.key ?? null;
-        if (key != null) {
-            const entry = store.get(key);
-            if (entry) {
-                const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
-                if (!expired) return serveFromEntry(entry, req);
-                store.delete(key);
-            }
-            let flight = inFlight.get(key);
-            if (!flight) {
-                const ttl = cacheOpts?.ttl;
-                flight = handler(new Request(req), ctx)
-                    .then(async (res) => {
-                        if (!res || res.status < 200 || res.status >= 300 || res.headers.has('set-cookie')) {
-                            return null;
-                        }
-                        const newEntry = await buildCacheEntry(res, ttl);
-                        store.set(key, newEntry);
-                        return newEntry;
-                    })
-                    .catch(() => null)
-                    .finally(() => inFlight.delete(key));
-                inFlight.set(key, flight);
-            }
-            const newEntry = await flight;
-            if (newEntry) return serveFromEntry(newEntry, req);
-        }
-        return handler(req, ctx);
-    };
-}

package/src/utils/staticFile.ts DELETED Viewed

@@ -1,43 +0,0 @@
-import { readFile } from 'node:fs/promises';
-/** MIME type map keyed by lowercase file extension. */
-const MIME: Record<string, string> = {
-    html: 'text/html; charset=utf-8',
-    htm: 'text/html; charset=utf-8',
-    css: 'text/css',
-    js: 'application/javascript',
-    mjs: 'application/javascript',
-    cjs: 'application/javascript',
-    json: 'application/json',
-    map: 'application/json',
-    png: 'image/png',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-    gif: 'image/gif',
-    webp: 'image/webp',
-    svg: 'image/svg+xml',
-    ico: 'image/x-icon',
-    woff: 'font/woff',
-    woff2: 'font/woff2',
-    ttf: 'font/ttf',
-    otf: 'font/otf',
-    txt: 'text/plain',
-    xml: 'application/xml',
-    pdf: 'application/pdf',
-};
-/**
- * Tries to serve a file at the given absolute path.
- * Returns a Response with the correct Content-Type, or null if the file does
- * not exist or cannot be read.
- */
-export async function tryServeFile(filePath: string): Promise<Response | null> {
-    try {
-        const data = await readFile(filePath);
-        const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
-        const contentType = MIME[ext] ?? 'application/octet-stream';
-        return new Response(data as BodyInit, { headers: { 'Content-Type': contentType } });
-    } catch {
-        return null;
-    }
-}

package/src/utils/template.html DELETED Viewed

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta name="HADARS_HEAD">
-</head>
-<body>
-    <meta name="HADARS_BODY">
-</body>
-</html>

package/src/utils/upgradeRequest.tsx DELETED Viewed

@@ -1,19 +0,0 @@
-import type { ServerContext } from './serve';
-import type { HadarsOptions, HadarsRequest } from "../types/hadars";
-type UpgradeHandle = (req: HadarsRequest, ctx: ServerContext) => boolean;
-export const upgradeHandler = (options: HadarsOptions): UpgradeHandle | null => {
-    const { wsPath = '/ws' } = options;
-    if (options.websocket) {
-        return (req: HadarsRequest, ctx: ServerContext) => {
-            if (req.pathname === wsPath) {
-                return ctx.upgrade(req);
-            }
-            return false;
-        };
-    }
-    return null;
-};