@fluixi/start 0.1.0-alpha.73 → 0.1.0-alpha.74

package/dist/handler.mjs

@@ -0,0 +1,150 @@
+// src/handler.ts
+import { createServer as createHttpServer } from "node:http";
+import { stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { join, extname } from "node:path";
+function streamDocument(head, body, tail) {
+  const enc = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        controller.enqueue(enc.encode(head));
+        const reader = body.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          controller.enqueue(value);
+        }
+        controller.enqueue(enc.encode(tail));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+function createRequestHandler(render) {
+  return async (request) => {
+    const url = new URL(request.url);
+    try {
+      const html = await render(url.pathname + url.search, request);
+      return new Response(html, {
+        status: 200,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    } catch (e) {
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+function nodeToRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const url = `http://${host}${req.url ?? "/"}`;
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (Array.isArray(v)) v.forEach((x) => headers.append(k, x));
+    else if (v != null) headers.set(k, v);
+  }
+  const method = req.method ?? "GET";
+  const init = { method, headers };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = req;
+    init.duplex = "half";
+  }
+  return new Request(url, init);
+}
+async function sendResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => res.setHeader(key, value));
+  const body = response.body;
+  if (!body) {
+    res.end(await response.text().catch(() => ""));
+    return;
+  }
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      res.write(value);
+    }
+  } finally {
+    res.end();
+  }
+}
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const response = await handler(nodeToRequest(req));
+    await sendResponse(res, response);
+  };
+}
+function serveNode(handler, opts = {}) {
+  const port = opts.port ?? 3e3;
+  const node = toNodeHandler(handler);
+  const server = createHttpServer((req, res) => {
+    node(req, res).catch((e) => {
+      res.statusCode = 500;
+      res.end(String(e?.stack || e));
+    });
+  });
+  server.listen(
+    port,
+    () => opts.onListen ? opts.onListen(port) : console.log(`  fluixi → http://localhost:${port}`)
+  );
+  return server;
+}
+var MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json"
+};
+function withStaticFiles(handler, dir) {
+  return async (request) => {
+    const { pathname } = new URL(request.url);
+    if (pathname !== "/" && extname(pathname)) {
+      const file = join(dir, decodeURIComponent(pathname));
+      try {
+        const s = await stat(file);
+        if (s.isFile()) {
+          const body = Readable.toWeb(createReadStream(file));
+          return new Response(body, {
+            headers: {
+              "content-type": MIME[extname(file).toLowerCase()] ?? "application/octet-stream",
+              "content-length": String(s.size)
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return handler(request);
+  };
+}
+export {
+  createRequestHandler,
+  nodeToRequest,
+  sendResponse,
+  serveNode,
+  streamDocument,
+  toNodeHandler,
+  withStaticFiles
+};

package/dist/head.cjs

@@ -0,0 +1,25 @@
+/*! @fluixi/start v0.1.0-alpha.74 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/head.ts
+var head_exports = {};
+module.exports = __toCommonJS(head_exports);
+__reExport(head_exports, require("@fluixi/head"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("@fluixi/head")
+});

package/dist/head.mjs

@@ -0,0 +1,4 @@
+/*! @fluixi/start v0.1.0-alpha.74 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/head.ts
+export * from "@fluixi/head";

package/dist/image.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/image.ts
+var image_exports = {};
+__export(image_exports, {
+  createImageHandler: () => createImageHandler,
+  imageLoader: () => imageLoader
+});
+module.exports = __toCommonJS(image_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var DEFAULT_SIZES = [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840];
+var MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml"
+};
+var sharpModule;
+async function loadSharp() {
+  if (sharpModule !== void 0) return sharpModule;
+  try {
+    const name = "sharp";
+    sharpModule = (await import(
+      /* @vite-ignore */
+      name
+    )).default;
+  } catch {
+    sharpModule = null;
+  }
+  return sharpModule;
+}
+var defaultTransform = async (input, { width, quality, format }) => {
+  const sharp = await loadSharp();
+  if (!sharp) return null;
+  const pipe = sharp(input).rotate().resize({ width, withoutEnlargement: true });
+  if (format === "avif") return { data: new Uint8Array(await pipe.avif({ quality }).toBuffer()), contentType: "image/avif" };
+  if (format === "webp") return { data: new Uint8Array(await pipe.webp({ quality }).toBuffer()), contentType: "image/webp" };
+  if (format === "png") return { data: new Uint8Array(await pipe.png().toBuffer()), contentType: "image/png" };
+  return { data: new Uint8Array(await pipe.jpeg({ quality, mozjpeg: true }).toBuffer()), contentType: "image/jpeg" };
+};
+function imageResponse(body, contentType, maxAge) {
+  return new Response(body, {
+    headers: {
+      "content-type": contentType,
+      "cache-control": `public, max-age=${maxAge}, immutable`,
+      vary: "Accept"
+    }
+  });
+}
+function createImageHandler(options = {}) {
+  const root = (0, import_node_path.resolve)(options.root ?? (0, import_node_path.join)(process.cwd(), "public"));
+  const domains = new Set((options.domains ?? []).map((d) => d.toLowerCase()));
+  const sizes = options.sizes ?? DEFAULT_SIZES;
+  const maxQuality = options.quality ?? 80;
+  const maxAge = options.cacheMaxAge ?? 60 * 60 * 24 * 365;
+  const transform = options.transform ?? defaultTransform;
+  const cacheMax = options.cache === false ? 0 : typeof options.cache === "number" ? options.cache : 100;
+  const cache = /* @__PURE__ */ new Map();
+  return async (request) => {
+    const url = new URL(request.url);
+    const src = url.searchParams.get("url") ?? url.searchParams.get("src");
+    const width = Number(url.searchParams.get("w"));
+    const quality = Math.min(Math.max(Number(url.searchParams.get("q")) || maxQuality, 1), 100);
+    if (!src) return new Response('missing "url"', { status: 400 });
+    if (!Number.isInteger(width) || !sizes.includes(width)) return new Response('invalid "w"', { status: 400 });
+    const accept = request.headers.get("accept") ?? "";
+    const format = accept.includes("image/avif") ? "avif" : accept.includes("image/webp") ? "webp" : "original";
+    const key = `${src}|${width}|${quality}|${format}`;
+    const hit = cache.get(key);
+    if (hit) return imageResponse(hit.body, hit.contentType, maxAge);
+    let input;
+    let sourceType;
+    if (/^https?:\/\//i.test(src)) {
+      let host;
+      try {
+        host = new URL(src).hostname.toLowerCase();
+      } catch {
+        return new Response("bad url", { status: 400 });
+      }
+      if (!domains.has(host)) return new Response("domain not allowed", { status: 403 });
+      const res = await fetch(src);
+      if (!res.ok) return new Response("upstream error", { status: 502 });
+      input = new Uint8Array(await res.arrayBuffer());
+      sourceType = res.headers.get("content-type") ?? "application/octet-stream";
+    } else {
+      const filePath = (0, import_node_path.resolve)(root, src.startsWith("/") ? src.slice(1) : src);
+      if (filePath !== root && !filePath.startsWith(root + import_node_path.sep)) return new Response("forbidden", { status: 403 });
+      try {
+        input = new Uint8Array(await (0, import_promises.readFile)(filePath));
+      } catch {
+        return new Response("not found", { status: 404 });
+      }
+      sourceType = MIME[(0, import_node_path.extname)(filePath).toLowerCase()] ?? "application/octet-stream";
+    }
+    if (sourceType === "image/svg+xml" || sourceType === "image/gif") {
+      return imageResponse(input, sourceType, maxAge);
+    }
+    let out = null;
+    try {
+      out = await transform(input, { width, quality, format, contentType: sourceType });
+    } catch {
+      out = null;
+    }
+    const body = out?.data ?? input;
+    const contentType = out?.contentType ?? sourceType;
+    if (cacheMax > 0) {
+      if (cache.size >= cacheMax) cache.delete(cache.keys().next().value);
+      cache.set(key, { body, contentType });
+    }
+    return imageResponse(body, contentType, maxAge);
+  };
+}
+function imageLoader(options = {}) {
+  const path = options.path ?? "/api/image";
+  return ({ src, width, quality }) => {
+    const params = new URLSearchParams({ url: src, w: String(width) });
+    if (quality != null) params.set("q", String(quality));
+    return `${path}?${params.toString()}`;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createImageHandler,
+  imageLoader
+});

package/dist/image.mjs

@@ -0,0 +1,120 @@
+// src/image.ts
+import { readFile } from "node:fs/promises";
+import { resolve as resolvePath, join, extname, sep } from "node:path";
+var DEFAULT_SIZES = [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840];
+var MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml"
+};
+var sharpModule;
+async function loadSharp() {
+  if (sharpModule !== void 0) return sharpModule;
+  try {
+    const name = "sharp";
+    sharpModule = (await import(
+      /* @vite-ignore */
+      name
+    )).default;
+  } catch {
+    sharpModule = null;
+  }
+  return sharpModule;
+}
+var defaultTransform = async (input, { width, quality, format }) => {
+  const sharp = await loadSharp();
+  if (!sharp) return null;
+  const pipe = sharp(input).rotate().resize({ width, withoutEnlargement: true });
+  if (format === "avif") return { data: new Uint8Array(await pipe.avif({ quality }).toBuffer()), contentType: "image/avif" };
+  if (format === "webp") return { data: new Uint8Array(await pipe.webp({ quality }).toBuffer()), contentType: "image/webp" };
+  if (format === "png") return { data: new Uint8Array(await pipe.png().toBuffer()), contentType: "image/png" };
+  return { data: new Uint8Array(await pipe.jpeg({ quality, mozjpeg: true }).toBuffer()), contentType: "image/jpeg" };
+};
+function imageResponse(body, contentType, maxAge) {
+  return new Response(body, {
+    headers: {
+      "content-type": contentType,
+      "cache-control": `public, max-age=${maxAge}, immutable`,
+      vary: "Accept"
+    }
+  });
+}
+function createImageHandler(options = {}) {
+  const root = resolvePath(options.root ?? join(process.cwd(), "public"));
+  const domains = new Set((options.domains ?? []).map((d) => d.toLowerCase()));
+  const sizes = options.sizes ?? DEFAULT_SIZES;
+  const maxQuality = options.quality ?? 80;
+  const maxAge = options.cacheMaxAge ?? 60 * 60 * 24 * 365;
+  const transform = options.transform ?? defaultTransform;
+  const cacheMax = options.cache === false ? 0 : typeof options.cache === "number" ? options.cache : 100;
+  const cache = /* @__PURE__ */ new Map();
+  return async (request) => {
+    const url = new URL(request.url);
+    const src = url.searchParams.get("url") ?? url.searchParams.get("src");
+    const width = Number(url.searchParams.get("w"));
+    const quality = Math.min(Math.max(Number(url.searchParams.get("q")) || maxQuality, 1), 100);
+    if (!src) return new Response('missing "url"', { status: 400 });
+    if (!Number.isInteger(width) || !sizes.includes(width)) return new Response('invalid "w"', { status: 400 });
+    const accept = request.headers.get("accept") ?? "";
+    const format = accept.includes("image/avif") ? "avif" : accept.includes("image/webp") ? "webp" : "original";
+    const key = `${src}|${width}|${quality}|${format}`;
+    const hit = cache.get(key);
+    if (hit) return imageResponse(hit.body, hit.contentType, maxAge);
+    let input;
+    let sourceType;
+    if (/^https?:\/\//i.test(src)) {
+      let host;
+      try {
+        host = new URL(src).hostname.toLowerCase();
+      } catch {
+        return new Response("bad url", { status: 400 });
+      }
+      if (!domains.has(host)) return new Response("domain not allowed", { status: 403 });
+      const res = await fetch(src);
+      if (!res.ok) return new Response("upstream error", { status: 502 });
+      input = new Uint8Array(await res.arrayBuffer());
+      sourceType = res.headers.get("content-type") ?? "application/octet-stream";
+    } else {
+      const filePath = resolvePath(root, src.startsWith("/") ? src.slice(1) : src);
+      if (filePath !== root && !filePath.startsWith(root + sep)) return new Response("forbidden", { status: 403 });
+      try {
+        input = new Uint8Array(await readFile(filePath));
+      } catch {
+        return new Response("not found", { status: 404 });
+      }
+      sourceType = MIME[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+    }
+    if (sourceType === "image/svg+xml" || sourceType === "image/gif") {
+      return imageResponse(input, sourceType, maxAge);
+    }
+    let out = null;
+    try {
+      out = await transform(input, { width, quality, format, contentType: sourceType });
+    } catch {
+      out = null;
+    }
+    const body = out?.data ?? input;
+    const contentType = out?.contentType ?? sourceType;
+    if (cacheMax > 0) {
+      if (cache.size >= cacheMax) cache.delete(cache.keys().next().value);
+      cache.set(key, { body, contentType });
+    }
+    return imageResponse(body, contentType, maxAge);
+  };
+}
+function imageLoader(options = {}) {
+  const path = options.path ?? "/api/image";
+  return ({ src, width, quality }) => {
+    const params = new URLSearchParams({ url: src, w: String(width) });
+    if (quality != null) params.set("q", String(quality));
+    return `${path}?${params.toString()}`;
+  };
+}
+export {
+  createImageHandler,
+  imageLoader
+};