@chidchanun/bcp 0.1.0

package/packages/router/src/index.ts

@@ -0,0 +1 @@
+export * from "./advanced-router.js";

package/packages/server/src/compression.ts

@@ -0,0 +1,249 @@
+import type * as http from "node:http";
+import {
+    brotliCompressSync,
+    constants,
+    gzipSync,
+} from "node:zlib";
+
+export type ContentEncoding =
+    | "br"
+    | "gzip"
+    | null;
+
+const MIN_COMPRESSION_BYTES =
+    1024;
+
+export function selectContentEncoding(
+    req: http.IncomingMessage,
+    contentType: string,
+    contentLength: number,
+    available: {
+        br?: boolean;
+        gzip?: boolean;
+    } = {
+        br: true,
+        gzip: true,
+    }
+): ContentEncoding {
+    if (
+        process.env
+            .BCP_COMPRESSION ===
+        "0"
+    ) {
+        return null;
+    }
+
+    if (
+        contentLength <
+            MIN_COMPRESSION_BYTES ||
+        !isCompressibleContentType(
+            contentType
+        )
+    ) {
+        return null;
+    }
+
+    const header =
+        req.headers[
+            "accept-encoding"
+        ];
+
+    const value =
+        Array.isArray(header)
+            ? header.join(",")
+            : header ?? "";
+
+    const brQuality =
+        available.br === false
+            ? 0
+            : getEncodingQuality(
+                value,
+                "br"
+            );
+
+    const gzipQuality =
+        available.gzip === false
+            ? 0
+            : getEncodingQuality(
+                value,
+                "gzip"
+            );
+
+    if (
+        brQuality > 0 &&
+        brQuality >= gzipQuality
+    ) {
+        return "br";
+    }
+
+    if (
+        gzipQuality > 0
+    ) {
+        return "gzip";
+    }
+
+    return null;
+}
+
+export function compressDynamicContent(
+    content: Buffer,
+    encoding: ContentEncoding
+): Buffer {
+    if (
+        encoding === "br"
+    ) {
+        return brotliCompressSync(
+            content,
+            {
+                params: {
+                    [constants.BROTLI_PARAM_QUALITY]:
+                        4,
+                },
+            }
+        );
+    }
+
+    if (
+        encoding === "gzip"
+    ) {
+        return gzipSync(
+            content,
+            {
+                level: 6,
+            }
+        );
+    }
+
+    return content;
+}
+
+export function isCompressibleContentType(
+    contentType: string
+): boolean {
+    const normalized =
+        contentType
+            .split(";", 1)[0]
+            .trim()
+            .toLowerCase();
+
+    return (
+        normalized.startsWith(
+            "text/"
+        ) ||
+        normalized ===
+            "application/javascript" ||
+        normalized ===
+            "application/json" ||
+        normalized ===
+            "application/xml" ||
+        normalized ===
+            "application/manifest+json" ||
+        normalized ===
+            "image/svg+xml"
+    );
+}
+
+export function appendVary(
+    existing: string | undefined,
+    value: string
+): string {
+    if (!existing) {
+        return value;
+    }
+
+    const values =
+        existing
+            .split(",")
+            .map(
+                (item) =>
+                    item.trim()
+            );
+
+    if (
+        values.some(
+            (item) =>
+                item.toLowerCase() ===
+                value.toLowerCase()
+        )
+    ) {
+        return existing;
+    }
+
+    return `${existing}, ${value}`;
+}
+
+function getEncodingQuality(
+    header: string,
+    encoding: string
+): number {
+    let wildcardQuality:
+        number | null =
+        null;
+
+    for (
+        const item
+        of header.split(",")
+    ) {
+        const [
+            tokenPart,
+            ...parameters
+        ] =
+            item.split(";");
+
+        const token =
+            tokenPart
+                .trim()
+                .toLowerCase();
+
+        if (!token) {
+            continue;
+        }
+
+        let quality = 1;
+
+        for (
+            const parameter
+            of parameters
+        ) {
+            const match =
+                /^\s*q\s*=\s*(\d(?:\.\d+)?)\s*$/i.exec(
+                    parameter
+                );
+
+            if (match) {
+                const parsed =
+                    Number(
+                        match[1]
+                    );
+
+                quality =
+                    Number.isFinite(
+                        parsed
+                    )
+                        ? Math.max(
+                            0,
+                            Math.min(
+                                1,
+                                parsed
+                            )
+                        )
+                        : 0;
+            }
+        }
+
+        if (
+            token === encoding
+        ) {
+            return quality;
+        }
+
+        if (
+            token === "*"
+        ) {
+            wildcardQuality =
+                quality;
+        }
+    }
+
+    return wildcardQuality ?? 0;
+}

package/packages/server/src/dev-document-metadata.ts

@@ -0,0 +1,154 @@
+import {
+    createMetadataHeadEntries,
+    type ResolvedMetadata,
+} from "../../client/src/metadata.js";
+
+export function applyDevDocumentMetadata(
+    html: string,
+    metadata: ResolvedMetadata
+): string {
+    const title =
+        `<title>${escapeHtmlText(
+            metadata.title
+        )}</title>`;
+
+    let result =
+        /<title\b[^>]*>[\s\S]*?<\/title>/i.test(
+            html
+        )
+            ? html.replace(
+                /<title\b[^>]*>[\s\S]*?<\/title>/i,
+                title
+            )
+            : html.replace(
+                /<\/head>/i,
+                `    ${title}\n  </head>`
+            );
+
+    /*
+     * Keep this transformation idempotent. This lets the outer dev server
+     * remain correct if the inner renderer starts emitting metadata itself
+     * in a future implementation.
+     */
+    result =
+        result.replace(
+            /\s*<(?:meta|link)\b[^>]*\bdata-bcp-metadata=(?:"[^"]*"|'[^']*')[^>]*\/?\s*>/gi,
+            ""
+        );
+
+    const entries =
+        createMetadataHeadEntries(
+            metadata
+        );
+
+    if (
+        entries.length > 0
+    ) {
+        const head =
+            entries
+                .map(
+                    (entry) => {
+                        const attributes = [
+                            [
+                                "data-bcp-metadata",
+                                entry.key,
+                            ] as const,
+                            ...Object.entries(
+                                entry.attributes
+                            ),
+                        ]
+                            .map(
+                                ([name, value]) =>
+                                    `${name}="${escapeHtmlAttribute(
+                                        value
+                                    )}"`
+                            )
+                            .join(" ");
+
+                        return (
+                            entry.tag === "meta"
+                                ? `<meta ${attributes} />`
+                                : `<link ${attributes} />`
+                        );
+                    }
+                )
+                .join("\n    ");
+
+        result =
+            result.replace(
+                /<\/head>/i,
+                `    ${head}\n  </head>`
+            );
+    }
+
+    return attachFrameworkMetadata(
+        result,
+        metadata
+    );
+}
+
+function attachFrameworkMetadata(
+    html: string,
+    metadata: ResolvedMetadata
+): string {
+    return html.replace(
+        /(<script\s+id="__BCP_DATA__"\s+type="application\/json"\s*>)([\s\S]*?)(<\/script>)/i,
+        (
+            match,
+            openTag: string,
+            serialized: string,
+            closeTag: string
+        ) => {
+            try {
+                const data =
+                    JSON.parse(
+                        serialized.trim()
+                    ) as Record<
+                        string,
+                        unknown
+                    >;
+
+                data.metadata =
+                    metadata;
+
+                return (
+                    `${openTag}${serializeJsonForHtml(
+                        data
+                    )}${closeTag}`
+                );
+            } catch {
+                return match;
+            }
+        }
+    );
+}
+
+function serializeJsonForHtml(
+    value: unknown
+): string {
+    return JSON.stringify(
+        value
+    )
+        .replace(/</g, "\\u003c")
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+}
+
+function escapeHtmlText(
+    value: string
+): string {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+
+function escapeHtmlAttribute(
+    value: string
+): string {
+    return escapeHtmlText(
+        value
+    )
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}

package/packages/server/src/dev-hmr.ts

@@ -0,0 +1,225 @@
+import type * as http from "node:http";
+
+export const DEV_EVENTS_PATH =
+    "/_bcp/dev-events";
+
+const ENV_RESTART_COOKIE =
+    "__bcp_env_restart";
+
+export class DevHmrServer {
+    private readonly clients =
+        new Set<
+            http.ServerResponse
+        >();
+
+    connect(
+        req: http.IncomingMessage,
+        res: http.ServerResponse
+    ) {
+        const restartToken =
+            process.env
+                .BCP_DEV_ENV_RESTART ??
+            "0";
+
+        const shouldReload =
+            restartToken !== "0" &&
+            readCookie(
+                req,
+                ENV_RESTART_COOKIE
+            ) !== restartToken;
+
+        const headers:
+            Record<string, string> = {
+            "Content-Type":
+                "text/event-stream; charset=utf-8",
+            "Cache-Control":
+                "no-cache, no-store",
+            Connection:
+                "keep-alive",
+        };
+
+        if (shouldReload) {
+            headers[
+                "Set-Cookie"
+            ] =
+                `${ENV_RESTART_COOKIE}=${encodeURIComponent(restartToken)}; Path=/; SameSite=Lax`;
+        }
+
+        res.writeHead(
+            200,
+            headers
+        );
+
+        res.write(
+            ": bcp-hmr-connected\n\n"
+        );
+
+        this.clients.add(
+            res
+        );
+
+        if (shouldReload) {
+            this.emitTo(
+                res,
+                "reload",
+                {
+                    version:
+                        Date.now(),
+                    reason:
+                        "environment",
+                }
+            );
+        }
+
+        const cleanup =
+            () => {
+                this.clients.delete(
+                    res
+                );
+            };
+
+        req.once(
+            "close",
+            cleanup
+        );
+
+        res.once(
+            "close",
+            cleanup
+        );
+    }
+
+    refresh(
+        version: number,
+        routes: string[]
+    ) {
+        this.emit(
+            "refresh",
+            {
+                version,
+                routes,
+            }
+        );
+    }
+
+    reload(
+        version: number
+    ) {
+        this.emit(
+            "reload",
+            {
+                version,
+            }
+        );
+    }
+
+    close() {
+        for (
+            const client
+            of this.clients
+        ) {
+            client.end();
+        }
+
+        this.clients.clear();
+    }
+
+    private emit(
+        event: string,
+        data: unknown
+    ) {
+        for (
+            const client
+            of this.clients
+        ) {
+            if (
+                client.destroyed ||
+                client.writableEnded
+            ) {
+                this.clients.delete(
+                    client
+                );
+
+                continue;
+            }
+
+            this.emitTo(
+                client,
+                event,
+                data
+            );
+        }
+    }
+
+    private emitTo(
+        client: http.ServerResponse,
+        event: string,
+        data: unknown
+    ): void {
+        const payload =
+            JSON.stringify(
+                data
+            );
+
+        client.write(
+            `event: ${event}\n`
+        );
+
+        client.write(
+            `data: ${payload}\n\n`
+        );
+    }
+}
+
+function readCookie(
+    req: http.IncomingMessage,
+    name: string
+): string | null {
+    const header =
+        req.headers.cookie;
+
+    if (!header) {
+        return null;
+    }
+
+    for (
+        const item
+        of header.split(";")
+    ) {
+        const separator =
+            item.indexOf("=");
+
+        if (separator < 0) {
+            continue;
+        }
+
+        const key =
+            item
+                .slice(
+                    0,
+                    separator
+                )
+                .trim();
+
+        if (key !== name) {
+            continue;
+        }
+
+        const value =
+            item
+                .slice(
+                    separator + 1
+                )
+                .trim();
+
+        try {
+            return decodeURIComponent(
+                value
+            );
+        } catch {
+            return value;
+        }
+    }
+
+    return null;
+}