@junejs/server 0.1.3 → 0.2.1

package/dist/assets.js

@@ -0,0 +1,123 @@
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/assets.ts
+const STALE_TEMP_MS = 36e5;
+const TEMP_PREFIX = ".june-tmp-";
+function assetCache(opts) {
+	const fetcher = opts.fetch ?? fetch;
+	const urlsFor = opts.urls ?? ((ref) => ref.urls);
+	const inflight = /* @__PURE__ */ new Map();
+	let swept;
+	const pathOf = (ref) => join(opts.dir, safeName(ref.name));
+	async function readMatching(ref) {
+		const path = pathOf(ref);
+		let info;
+		try {
+			info = await stat(path);
+		} catch (err) {
+			if (err.code === "ENOENT") return void 0;
+			throw err;
+		}
+		if (!info.isFile()) throw new Error(`${path} is in the way of ${ref.name}: it isn't a file`);
+		if (info.size !== ref.size) return void 0;
+		const bytes = new Uint8Array(await readFile(path));
+		return await sha256(bytes) === ref.sha256 ? bytes : void 0;
+	}
+	async function get(ref) {
+		pathOf(ref);
+		const hit = await readMatching(ref);
+		if (hit) return hit;
+		if (opts.offline) {
+			const state = await stat(pathOf(ref)).then(() => true, () => false) ? `in ${opts.dir} but doesn't match` : `not in ${opts.dir}`;
+			throw new Error(`${ref.name} is ${state}, and this cache is offline: copy the file with sha256 ${ref.sha256} (${ref.size} bytes) to ${pathOf(ref)} — it is at ${ref.urls.join(" or ")}`);
+		}
+		await (swept ??= sweepTemps(opts.dir).catch(() => {}));
+		const bytes = await download(ref, urlsFor(ref), fetcher);
+		await mkdir(opts.dir, { recursive: true });
+		const temp = join(opts.dir, `${TEMP_PREFIX}${crypto.randomUUID()}-${safeName(ref.name)}`);
+		try {
+			await writeFile(temp, bytes);
+			await rename(temp, pathOf(ref));
+		} catch (err) {
+			await rm(temp, { force: true }).catch(() => {});
+			throw err;
+		}
+		return bytes;
+	}
+	const cache = ((ref) => {
+		const key = `${ref.name}\0${ref.sha256}\0${ref.size}`;
+		const running = inflight.get(key);
+		if (running) return running;
+		const p = get(ref).finally(() => inflight.delete(key));
+		inflight.set(key, p);
+		return p;
+	});
+	cache.cached = async (ref) => await readMatching(ref) !== void 0;
+	cache.egress = async (refs) => {
+		if (opts.offline) return [];
+		const missing = (await Promise.all(refs.map(async (r) => await cache.cached(r) ? [] : urlsFor(r)))).flat();
+		return [...new Set(missing.map((u) => new URL(u).host))].map((host) => ({
+			host,
+			sends: "nothing"
+		}));
+	};
+	return cache;
+}
+async function download(ref, urls, fetcher) {
+	const failures = [];
+	for (const url of urls) try {
+		const res = await fetcher(url);
+		if (!res.ok) throw new Error(`HTTP ${res.status}`);
+		const declared = Number(res.headers.get("content-length") ?? NaN);
+		if (declared > ref.size) throw new Error(`${declared} bytes declared, expected ${ref.size}`);
+		const bytes = await readCapped(res, ref.size);
+		const digest = await sha256(bytes);
+		if (bytes.length !== ref.size || digest !== ref.sha256) throw new Error(`got ${bytes.length} bytes with sha256 ${digest}, expected ${ref.size} with ${ref.sha256}`);
+		return bytes;
+	} catch (err) {
+		failures.push(`${url}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	throw new Error(`${ref.name} could not be fetched (${failures.join("; ") || "no URLs"}). To run without the network, copy the file into the cache directory and pass offline: true`);
+}
+async function readCapped(res, size) {
+	if (!res.body) return new Uint8Array(await res.arrayBuffer());
+	const out = new Uint8Array(size + 1);
+	let length = 0;
+	const reader = res.body.getReader();
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (length + value.length >= out.length) {
+			out.set(value.subarray(0, out.length - length), length);
+			length = out.length;
+			await reader.cancel();
+			break;
+		}
+		out.set(value, length);
+		length += value.length;
+	}
+	return out.subarray(0, length);
+}
+async function sha256(bytes) {
+	const digest = await crypto.subtle.digest("SHA-256", bytes);
+	return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function safeName(name) {
+	if (!name || name === "." || name === ".." || /[\\/]/.test(name) || name.startsWith(TEMP_PREFIX)) throw new Error(`unsafe asset name: ${JSON.stringify(name)}`);
+	return name;
+}
+async function sweepTemps(dir) {
+	let names;
+	try {
+		names = await readdir(dir);
+	} catch {
+		return;
+	}
+	const now = Date.now();
+	await Promise.all(names.filter((n) => n.startsWith(TEMP_PREFIX)).map(async (n) => {
+		const s = await stat(join(dir, n)).catch(() => void 0);
+		if (s && now - s.mtimeMs > STALE_TEMP_MS) await rm(join(dir, n), { force: true });
+	}));
+}
+//#endregion
+export { assetCache };

package/dist/blob.d.ts

@@ -1,12 +1,12 @@
 import { BlobFactory } from "@junejs/core/resources";
 //#region src/blob.d.ts
-declare function localBlob(opts?: {
+export declare function localBlob(opts?: {
   dir?: string;
 }): BlobFactory;
 interface R2ObjectBody {
   arrayBuffer(): Promise<ArrayBuffer>;
 }
-interface R2Bucket {
+export interface R2Bucket {
   get(key: string): Promise<R2ObjectBody | null>;
   put(key: string, data: ArrayBuffer | Uint8Array | string): Promise<unknown>;
   delete(key: string): Promise<void>;
@@ -18,6 +18,5 @@ interface R2Bucket {
     }[];
   }>;
 }
-declare function r2(bucket: R2Bucket): BlobFactory;
-//#endregion
-export { R2Bucket, localBlob, r2 };
+export declare function r2(bucket: R2Bucket): BlobFactory;
+//#endregion

package/dist/build.d.ts

@@ -1,41 +1,19 @@
-import { JuneAdapter } from "./adapter.js";
-import { WorkerManifest } from "./worker.js";
-import { JuneConfig } from "@junejs/core/config";
-import { DocumentConfig } from "@junejs/core/document";
+import { a as scanAppRoutes, o as scanRoutes, t as RouteEntry } from "./route-scan-BMbBzPIB.js";
+import { t as generateContent } from "./content-freeze-CyiW2fRK.js";
+import { i as workerName, n as normalizeBase, r as resolveDeployAdapter, t as freezeConfig } from "./config-freeze-r5p-vTWv.js";
+import { n as buildManifest } from "./manifest-CwTT1zVs.js";
 //#region src/build.d.ts
-type BuildResult = {
+export type BuildResult = {
   outFile: string;
   routes: string[];
   dynamicRoutes: string[];
   contentCollections: string[];
   prerendered: string[];
 };
-type RouteEntry = {
-  path: string;
-  file: string;
-  dynamic: boolean;
-  resource?: boolean;
-  generated?: boolean;
-  layouts: string[];
-  loading?: string;
-};
-declare const isBunSpecifier: (id: string) => boolean;
-declare function resolveDeployAdapter(deploy: JuneConfig["deploy"]): JuneAdapter;
-declare function scanRoutes(appDir: string, dir?: string, layouts?: string[], out?: RouteEntry[], loading?: string): Promise<RouteEntry[]>;
-declare function generateContent(appRoot: string): Promise<string[]>;
-declare function freezeConfig(appRoot: string): Promise<{
-  document: DocumentConfig;
-  agent: WorkerManifest["agent"];
-  i18n: WorkerManifest["i18n"];
-  earlyHints: string[];
-  buildExternal: string[];
-}>;
-declare function normalizeBase(base?: string): string;
-declare function workerName(raw: string): string;
-declare function buildManifest(appRoot: string): Promise<WorkerManifest>;
-declare function juneBuild(appRoot: string, options?: {
+export declare const isBunSpecifier: (id: string) => boolean;
+export declare function juneBuild(appRoot: string, options?: {
   outDir?: string;
   external?: string[];
 }): Promise<BuildResult>;
 //#endregion
-export { BuildResult, buildManifest, freezeConfig, generateContent, isBunSpecifier, juneBuild, normalizeBase, resolveDeployAdapter, scanRoutes, workerName };
+export { type RouteEntry, buildManifest, freezeConfig, generateContent, normalizeBase, resolveDeployAdapter, scanAppRoutes, scanRoutes, workerName };