clover caruso
30ad9c27ff
"server side rendering" is a misleading term since it implies there is a server. that isn't neccecarily the case here, since it supports running in the browser. I think "clover engine" is cute, short for "clover html rendering engine". Instead of "server side rendering", it's just rendering. This commit makes things a lot more concise, such as `ssr.ssrAsync` being renamed to `render.async` to play nicely with namespaced imports. `getCurrentRender` and `setCurrentRender` are just `current` and `setCurrent`, and the addon interface has been redesigned to force symbols with a wrapping helper.
110 lines
3.1 KiB
TypeScript
110 lines
3.1 KiB
TypeScript
interface Loaded {
|
|
map: BuiltAssetMap;
|
|
buf: Buffer;
|
|
}
|
|
let assets: Loaded | null = null;
|
|
|
|
export type StaticPageId = string;
|
|
|
|
export async function reload() {
|
|
const [map, buf] = await Promise.all([
|
|
fs.readFile(path.join(import.meta.dirname, "static.json"), "utf8"),
|
|
fs.readFile(path.join(import.meta.dirname, "static.blob")),
|
|
]);
|
|
return (assets = { map: JSON.parse(map), buf });
|
|
}
|
|
|
|
export function reloadSync() {
|
|
const map = fs.readFileSync(
|
|
path.join(import.meta.dirname, "static.json"),
|
|
"utf8",
|
|
);
|
|
const buf = fs.readFileSync(path.join(import.meta.dirname, "static.blob"));
|
|
return (assets = { map: JSON.parse(map), buf });
|
|
}
|
|
|
|
export async function middleware(c: Context, next: Next) {
|
|
if (!assets) await reload();
|
|
const asset = assets!.map[c.req.path];
|
|
if (asset) return assetInner(c, asset, 200);
|
|
return next();
|
|
}
|
|
|
|
export async function notFound(c: Context) {
|
|
if (!assets) await reload();
|
|
let pathname = c.req.path;
|
|
do {
|
|
const asset = assets!.map[pathname + "/404"];
|
|
if (asset) return assetInner(c, asset, 404);
|
|
pathname = pathname.slice(0, pathname.lastIndexOf("/"));
|
|
} while (pathname);
|
|
const asset = assets!.map["/404"];
|
|
if (asset) return assetInner(c, asset, 404);
|
|
return c.text("the 'Not Found' page was not found", 404);
|
|
}
|
|
|
|
export async function serveAsset(
|
|
c: Context,
|
|
id: StaticPageId,
|
|
status: StatusCode,
|
|
) {
|
|
return assetInner(c, (assets ?? (await reload())).map[id], status);
|
|
}
|
|
|
|
export function hasAsset(id: string) {
|
|
return (assets ?? reloadSync()).map[id] !== undefined;
|
|
}
|
|
|
|
export function etagMatches(etag: string, ifNoneMatch: string) {
|
|
return ifNoneMatch === etag || ifNoneMatch.split(/,\s*/).indexOf(etag) > -1;
|
|
}
|
|
|
|
function subarrayAsset([start, end]: BufferView) {
|
|
return assets!.buf.subarray(start, end);
|
|
}
|
|
|
|
function assetInner(c: Context, asset: BuiltAsset, status: StatusCode) {
|
|
const ifnonematch = c.req.header("If-None-Match");
|
|
if (ifnonematch) {
|
|
const etag = asset.headers.ETag;
|
|
if (etagMatches(etag, ifnonematch)) {
|
|
return (c.res = new Response(null, {
|
|
status: 304,
|
|
statusText: "Not Modified",
|
|
headers: {
|
|
ETag: etag,
|
|
},
|
|
}));
|
|
}
|
|
}
|
|
const acceptEncoding = c.req.header("Accept-Encoding") ?? "";
|
|
let body;
|
|
let headers = asset.headers;
|
|
if (acceptEncoding.includes("zstd") && asset.zstd) {
|
|
body = subarrayAsset(asset.zstd);
|
|
headers = {
|
|
...asset.headers,
|
|
"Content-Encoding": "zstd",
|
|
};
|
|
} else if (acceptEncoding.includes("gzip") && asset.gzip) {
|
|
body = subarrayAsset(asset.gzip);
|
|
headers = {
|
|
...asset.headers,
|
|
"Content-Encoding": "gzip",
|
|
};
|
|
} else {
|
|
body = subarrayAsset(asset.raw);
|
|
}
|
|
return (c.res = new Response(body, { headers, status }));
|
|
}
|
|
|
|
process.on("message", (msg: any) => {
|
|
if (msg?.type === "clover.assets.reload") reload();
|
|
});
|
|
|
|
import * as fs from "#sitegen/fs";
|
|
import type { Context, Next } from "hono";
|
|
import type { StatusCode } from "hono/utils/http-status";
|
|
import type { BuiltAsset, BuiltAssetMap, BufferView } from "../incremental.ts";
|
|
import { Buffer } from "node:buffer";
|
|
import * as path from "node:path";
|