@moonsjs/vite 0.1.17 → 0.1.18

package/dist/server/index.js

@@ -13,7 +13,7 @@ import {
   DEFAULT_SECURITY_HEADERS,
   sendNodeResponse2,
   installDevMiddleware2
-} from "../index-v5sbd3az.js";
+} from "../index-1ksjfvnz.js";
 
 // src/server/handler.ts
 import {
@@ -93,9 +93,9 @@ function createRequestHandler(options) {
       return apiErrorResponse(new MoonsError({
         code: "E_API_HANDLER_INVALID",
         file: route.file,
-        message: `modul API \`${route.path}\` tidak bisa dimuat`,
-        details: "Peta `loadApi` tidak memuat route ini (build/dev tidak sinkron).",
-        suggestions: ["Jalankan ulang build / restart dev server"]
+        message: `API module \`${route.path}\` could not be loaded`,
+        details: "The `loadApi` map does not contain this route (build/dev out of sync).",
+        suggestions: ["Rebuild / restart the dev server"]
       }), route);
     }
     let mod;
@@ -108,9 +108,9 @@ function createRequestHandler(options) {
       return apiErrorResponse(new MoonsError({
         code: "E_API_HANDLER_INVALID",
         file: route.file,
-        message: "modul API tidak mengekspor objek handler",
-        details: `Modul \`${route.path}\` harus mengekspor handler method.`,
-        suggestions: ["Export `GET`/`POST`/… sebagai fungsi `(args) => Response`"]
+        message: "API module does not export a handler object",
+        details: `Module \`${route.path}\` must export method handlers.`,
+        suggestions: ["Export `GET`/`POST`/… as `(args) => Response` functions"]
       }), route);
     }
     const record = mod;
@@ -137,9 +137,9 @@ function createRequestHandler(options) {
         return apiErrorResponse(new MoonsError({
           code: "E_API_HANDLER_INVALID",
           file: route.file,
-          message: `handler \`${requestMethod}\` tidak mengembalikan \`Response\``,
-          details: "Handler API wajib mengembalikan `new Response(...)`.",
-          suggestions: ["Kembalikan `new Response(body, { status, headers })`"]
+          message: `handler \`${requestMethod}\` did not return a \`Response\``,
+          details: "API handlers must return `new Response(...)`.",
+          suggestions: ["Return `new Response(body, { status, headers })`"]
         }), route);
       }
       if (stripBody) {
@@ -159,11 +159,11 @@ function createRequestHandler(options) {
         const markup = renderToMarkup({ page: key, layouts: [] }, { page: module, layouts: [] }, {}, {});
         return htmlResponse(await shell(markup, payload, request.url), 404);
       } catch (error) {
-        console.error("[moons] gagal merender _404 kustom:", error);
+        console.error("[moons] failed to render custom _404:", error);
       }
     }
     const payload = encodeSsrPayload({ key: "", params: {}, data: {} });
-    const html = await shell("<h1>404</h1><p>Halaman tidak ditemukan.</p>", payload, request.url);
+    const html = await shell("<h1>404</h1><p>Page not found.</p>", payload, request.url);
     return htmlResponse(html, 404);
   }
   async function routeErrorResponse(error, request, resolved) {
@@ -184,7 +184,7 @@ function createRequestHandler(options) {
         const markup = renderToMarkup({ page: key, layouts: [] }, { page: module, layouts: [] }, {}, {}, {}, serialized === undefined ? undefined : reviveError(serialized));
         return htmlResponse(await shell(markup, payload, request.url), 500);
       } catch (renderError) {
-        console.error("[moons] gagal merender _error kustom:", renderError);
+        console.error("[moons] failed to render custom _error:", renderError);
       }
     }
     return internalErrorResponse(error, { log: false });
@@ -198,9 +198,9 @@ function createRequestHandler(options) {
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "middleware direktori tidak bisa dimuat",
-          details: "Peta `loadRoute` tidak memuat `_middleware.ts` ini.",
-          suggestions: ["Restart dev server / jalankan ulang build"]
+          message: "directory middleware could not be loaded",
+          details: "The `loadRoute` map does not contain this `_middleware.ts`.",
+          suggestions: ["Restart the dev server / rebuild"]
         });
       }
       const module = await load();
@@ -209,8 +209,8 @@ function createRequestHandler(options) {
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "`_middleware.ts` tidak meng-export default fungsi",
-          details: "Middleware direktori mengikuti bentuk `(args) => Promise<Response>`.",
+          message: "`_middleware.ts` does not default-export a function",
+          details: "Directory middleware follows the `(args) => Promise<Response>` shape.",
           suggestions: ["Export default `async ({ req, ctx, next }) => await next()`"]
         });
       }
@@ -226,9 +226,9 @@ function createRequestHandler(options) {
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "middleware API tidak bisa dimuat",
-          details: "Peta `loadApiMiddleware` tidak memuat `_middleware.ts` ini.",
-          suggestions: ["Restart dev server / jalankan ulang build"]
+          message: "API middleware could not be loaded",
+          details: "The `loadApiMiddleware` map does not contain this `_middleware.ts`.",
+          suggestions: ["Restart the dev server / rebuild"]
         });
       }
       const module = await load();
@@ -236,8 +236,8 @@ function createRequestHandler(options) {
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "`_middleware.ts` tidak meng-export default fungsi",
-          details: "Middleware direktori mengikuti bentuk `(args) => Promise<Response>`.",
+          message: "`_middleware.ts` does not default-export a function",
+          details: "Directory middleware follows the `(args) => Promise<Response>` shape.",
           suggestions: ["Export default `async ({ req, ctx, next }) => await next()`"]
         });
       }
@@ -268,7 +268,7 @@ function createRequestHandler(options) {
               return await handleApiRequest(apiMatch.route, apiMatch.params, request, ctx);
             }
             const middlewares = await loadApiDirMiddlewares(apiChain);
-            return await composeMiddleware(middlewares, ctx, () => handleApiRequest(apiMatch.route, apiMatch.params, request, ctx), { code: "E_MIDDLEWARE_INVALID", label: "middleware API" })(request);
+            return await composeMiddleware(middlewares, ctx, () => handleApiRequest(apiMatch.route, apiMatch.params, request, ctx), { code: "E_MIDDLEWARE_INVALID", label: "API middleware" })(request);
           }
         }
         const resolved = resolveRoute(url.pathname, routes);
@@ -281,7 +281,7 @@ function createRequestHandler(options) {
             return await renderRoute(resolved, request, ctx);
           }
           const middlewares = await loadDirMiddlewares(dirChain);
-          return await composeMiddleware(middlewares, ctx, () => renderRoute(resolved, request, ctx), { code: "E_MIDDLEWARE_INVALID", label: "middleware direktori" })(request);
+          return await composeMiddleware(middlewares, ctx, () => renderRoute(resolved, request, ctx), { code: "E_MIDDLEWARE_INVALID", label: "directory middleware" })(request);
         } catch (error) {
           if (isRedirectSignal(error)) {
             return new Response(null, {
@@ -386,9 +386,9 @@ async function loadModules(keys, loadRoute) {
     if (load === undefined) {
       throw new MoonsError({
         code: "E_INTERNAL",
-        message: `modul route \`${key}\` tidak terdaftar`,
-        details: "Registry route tidak sinkron dengan hasil scan.",
-        suggestions: ["Jalankan ulang `bun run build`, atau restart dev server"]
+        message: `route module \`${key}\` is not registered`,
+        details: "The route registry is out of sync with the scan result.",
+        suggestions: ["Run `bun run build` again, or restart the dev server"]
       });
     }
     return await load();
@@ -403,11 +403,11 @@ async function runRouteMeta(pageModule, pageData, file) {
     throw new MoonsError({
       code: "E_INTERNAL",
       file,
-      message: "export `meta` harus berupa fungsi `({ data }) => RouteMeta`",
-      details: "Bentuk `meta` mengikuti ",
+      message: "export `meta` must be a function `({ data }) => RouteMeta`",
+      details: "The `meta` shape follows `RouteMeta`.",
       suggestions: [
-        'Ubah menjadi `export const meta = ({ data }) => ({ title: "..." })`',
-        "Atau hapus export `meta`"
+        'Change it to `export const meta = ({ data }) => ({ title: "..." })`',
+        "Or remove the `meta` export"
       ]
     });
   }
@@ -416,9 +416,9 @@ async function runRouteMeta(pageModule, pageData, file) {
     throw new MoonsError({
       code: "E_INTERNAL",
       file,
-      message: "`meta()` harus mengembalikan objek RouteMeta",
-      details: "Nilai yang dikembalikan dipakai untuk <title>/description/og.",
-      suggestions: ['Kembalikan objek, mis. `({ title: "Halaman" })`']
+      message: "`meta()` must return a RouteMeta object",
+      details: "The returned value is used for <title>/description/og.",
+      suggestions: ['Return an object, e.g. `({ title: "Home" })`']
     });
   }
   return result;
@@ -427,13 +427,13 @@ function apiErrorResponse(error, route) {
   const isProduction = process.env["NODE_ENV"] === "production";
   if (error instanceof MoonsError) {
     console.error(`[moons] API ${route.path}: ${error.format()}`);
-    return new Response(isProduction ? "Terjadi kesalahan internal." : error.format(), {
+    return new Response(isProduction ? "Internal server error." : error.format(), {
       status: 500,
       headers: { "content-type": "text/plain; charset=utf-8" }
     });
   }
   console.error(`[moons] API ${route.path}:`, error);
-  return new Response(isProduction ? "Terjadi kesalahan internal." : String(error), {
+  return new Response(isProduction ? "Internal server error." : String(error), {
     status: 500,
     headers: { "content-type": "text/plain; charset=utf-8" }
   });
@@ -442,8 +442,8 @@ function internalErrorResponse(error, options = {}) {
   if (options.log !== false) {
     console.error("[moons] request error:", error);
   }
-  const detail = process.env["NODE_ENV"] !== "production" && error instanceof MoonsError ? `<pre>${escapeHtml(error.format())}</pre>` : "<p>Terjadi kesalahan internal.</p>";
-  return htmlResponse(`<!doctype html><html lang="id"><head><meta charset="utf-8"><title>500</title></head><body><h1>500</h1>${detail}</body></html>`, 500);
+  const detail = process.env["NODE_ENV"] !== "production" && error instanceof MoonsError ? `<pre>${escapeHtml(error.format())}</pre>` : "<p>Internal server error.</p>";
+  return htmlResponse(`<!doctype html><html lang="en"><head><meta charset="utf-8"><title>500</title></head><body><h1>500</h1>${detail}</body></html>`, 500);
 }
 function htmlResponse(html, status) {
   return new Response(html, {
@@ -477,7 +477,7 @@ function warnPayloadFindings(payload, scan, warned) {
       continue;
     }
     warned.add(label);
-    console.warn(`[moons] peringatan dev: payload SSR memuat ${label} — jangan mengembalikan rahasia dari loader.`);
+    console.warn(`[moons] dev warning: SSR payload contains ${label} — do not return secrets from loaders.`);
   }
 }
 // src/server/node-server.ts
@@ -517,7 +517,7 @@ async function runRevalidate(options) {
       headers: { "x-moons-prerender": "1" }
     }));
     if (response.status !== 200) {
-      log(`[moons] isr: lewati ${options.pathname} (status ${response.status})`);
+      log(`[moons] isr: skipped ${options.pathname} (status ${response.status})`);
       return;
     }
     const html = await response.text();
@@ -527,7 +527,7 @@ async function runRevalidate(options) {
     });
     if (findings.length > 0) {
       const labels = findings.map((finding) => finding.kind === "canary" ? "canary" : `env(${finding.label})`).join(", ");
-      log(`[moons] isr: TIDAK menulis ${options.pathname} — memuat ${labels}`);
+      log(`[moons] isr: NOT writing ${options.pathname} — contains ${labels}`);
       return;
     }
     if (options.storage !== undefined) {
@@ -535,14 +535,14 @@ async function runRevalidate(options) {
       return;
     }
     if (options.file === undefined) {
-      log(`[moons] isr: lewati ${options.pathname} — tanpa file/storage tujuan`);
+      log(`[moons] isr: skipped ${options.pathname} — no destination file/storage`);
       return;
     }
     const tmp = `${options.file}.tmp-${process.pid}`;
     writeFileSync(tmp, html);
     renameSync(tmp, options.file);
   } catch (error) {
-    log(`[moons] isr: gagal regenerasi ${options.pathname}: ${String(error)}`);
+    log(`[moons] isr: failed to regenerate ${options.pathname}: ${String(error)}`);
   }
 }
 
@@ -562,7 +562,7 @@ function createFileStorage(clientDir) {
     async write(pathname, body) {
       const target = staticFileTarget(clientDir, pathname);
       if (target === null) {
-        throw new Error(`[moons] isr: path tidak valid untuk ditulis: ${pathname}`);
+        throw new Error(`[moons] isr: invalid path to write: ${pathname}`);
       }
       mkdirSync(dirname(target), { recursive: true });
       const tmp = `${target}.tmp-${process.pid}`;
@@ -645,9 +645,9 @@ function installGracefulShutdown(server, options = {}) {
       return;
     }
     shuttingDown = true;
-    log(`[moons] menerima ${signal} — berhenti menerima koneksi, drain...`);
+    log(`[moons] received ${signal} — no longer accepting connections, draining...`);
     const timer = setTimeout(() => {
-      log(`[moons] drain melewati ${timeoutMs}ms — keluar paksa`);
+      log(`[moons] drain exceeded ${timeoutMs}ms — forcing exit`);
       const closeAll = server.closeAllConnections;
       try {
         closeAll?.call(server);
@@ -661,7 +661,7 @@ function installGracefulShutdown(server, options = {}) {
     server.close(async (error) => {
       if (error !== undefined) {
         clearTimeout(timer);
-        log(`[moons] penutupan server gagal: ${error.message}`);
+        log(`[moons] server close failed: ${error.message}`);
         exit(1);
         return;
       }
@@ -670,11 +670,11 @@ function installGracefulShutdown(server, options = {}) {
         try {
           await options.onShutdown();
         } catch (hookError) {
-          log(`[moons] onShutdown gagal: ${String(hookError)}`);
+          log(`[moons] onShutdown failed: ${String(hookError)}`);
         }
       }
       clearTimeout(timer);
-      log("[moons] shutdown selesai (drain penuh)");
+      log("[moons] shutdown complete (full drain)");
       exit(0);
     });
   };
@@ -921,11 +921,11 @@ function rpcBodyTooLargeText(limit, size) {
   const megabytes = (bytes) => (bytes / 1e6).toFixed(1);
   return new MoonsError2({
     code: "E_RPC_BODY_TOO_LARGE",
-    message: size === null ? `body melebihi limit ${megabytes(limit)} MB` : `body ${megabytes(size)} MB melebihi limit ${megabytes(limit)} MB`,
-    details: "Body melebihi `security.bodyLimitBytes`; pembacaan dihentikan di transport sebelum penuh.",
+    message: size === null ? `body exceeds the ${megabytes(limit)} MB limit` : `body ${megabytes(size)} MB exceeds the ${megabytes(limit)} MB limit`,
+    details: "Body exceeds `security.bodyLimitBytes`; reading stops at the transport before the body is fully buffered.",
     suggestions: [
-      "Kurangi ukuran payload, atau",
-      "Naikkan security.bodyLimitBytes jika memang perlu"
+      "Reduce the payload size, or",
+      "Increase security.bodyLimitBytes if you really need to"
     ]
   }).format();
 }
@@ -1030,7 +1030,7 @@ function scheduleRevalidation(input) {
     if (logger !== null) {
       logger({ msg: "isr:revalidate-failed", level: "warn", path: normalized, error: message });
     } else {
-      console.error(`[moons] isr regenerasi gagal (${normalized}): ${message}`);
+      console.error(`[moons] isr regeneration failed (${normalized}): ${message}`);
     }
   });
 }
@@ -1091,7 +1091,7 @@ function createPluginRuntime(options) {
         try {
           await plugin.onShutdown?.(app);
         } catch (error) {
-          log(`[moons] plugin \`${plugin.name}\` gagal saat onShutdown: ${String(error)}`);
+          log(`[moons] plugin \`${plugin.name}\` failed during onShutdown: ${String(error)}`);
         }
       }
     },
@@ -1133,18 +1133,18 @@ async function runPrerender(options) {
         throw new MoonsError3({
           code: "E_ISR_INVALID",
           file: route.file,
-          message: "`revalidate` tidak valid atau dipakai tanpa `prerender = true`",
-          details: "ISR berbasis file: `revalidate` (detik, number >= 0) + `prerender`.",
+          message: "`revalidate` is invalid or used without `prerender = true`",
+          details: "File-based ISR: `revalidate` (seconds, number >= 0) + `prerender`.",
           suggestions: [
-            "Gunakan angka detik, mis. `export const revalidate = 60`",
-            "Tambahkan `export const prerender = true` pada page yang sama"
+            "Use a number of seconds, e.g. `export const revalidate = 60`",
+            "Add `export const prerender = true` to the same page"
           ]
         });
       }
     }
     if (prerender !== true) {
       if (prerender !== undefined && prerender !== false) {
-        throw prerenderError(route, "`prerender` harus boolean (`true`/`false`)");
+        throw prerenderError(route, "`prerender` must be a boolean (`true`/`false`)");
       }
       continue;
     }
@@ -1155,15 +1155,15 @@ async function runPrerender(options) {
         headers: { "x-moons-prerender": "1" }
       }));
       if (response.status === 404) {
-        log(`[moons] prerender: lewati ${pathname} (notFound)`);
+        log(`[moons] prerender: skipped ${pathname} (notFound)`);
         skipped += 1;
         continue;
       }
       if (response.status >= 300 && response.status < 400) {
-        throw prerenderError(route, `\`redirect()\` tidak didukung saat prerender (${pathname})`);
+        throw prerenderError(route, `\`redirect()\` is not supported during prerender (${pathname})`);
       }
       if (response.status !== 200) {
-        throw prerenderError(route, `status ${response.status} saat merender ${pathname}`);
+        throw prerenderError(route, `status ${response.status} while rendering ${pathname}`);
       }
       const html = await response.text();
       assertNoLeak(html, pathname, route.file, options, env);
@@ -1184,7 +1184,7 @@ async function runPrerender(options) {
 `);
   const emitted = emitStaticFiles(options.clientDir, options.staticConfig, entries);
   const extras = [...wrote404 ? [NOT_FOUND_FILE] : [], ...emitted];
-  log(`[moons] prerender selesai: ${written} file${extras.length > 0 ? ` + ${extras.join(" + ")}` : ""} (${skipped} dilewati)`);
+  log(`[moons] prerender done: ${written} file${extras.length > 0 ? ` + ${extras.join(" + ")}` : ""} (${skipped} skipped)`);
   return { written, skipped };
 }
 function emitStaticFiles(clientDir, staticConfig, entries) {
@@ -1249,7 +1249,7 @@ async function renderStaticNotFound(options, env, log) {
     headers: { "x-moons-prerender": "1" }
   }));
   if (response.status !== 404) {
-    log(`[moons] prerender: ${NOT_FOUND_FILE} dilewati (sentinel \`${NOT_FOUND_SENTINEL}\` → ${response.status})`);
+    log(`[moons] prerender: ${NOT_FOUND_FILE} skipped (sentinel \`${NOT_FOUND_SENTINEL}\` → ${response.status})`);
     return null;
   }
   const html = await response.text();
@@ -1268,11 +1268,11 @@ function assertNoLeak(html, pathname, file, options, env) {
   throw new MoonsError3({
     code: "E_PRERENDER_LEAK",
     file,
-    message: `hasil prerender \`${pathname}\` memuat ${labels}`,
-    details: "HTML statis permanen — rahasia yang ter-prerender tidak bisa ditarik kembali.",
+    message: `prerender output \`${pathname}\` contains ${labels}`,
+    details: "Static HTML is permanent — a prerendered secret cannot be retracted.",
     suggestions: [
-      "Jangan mengembalikan nilai env rahasia dari loader yang di-prerender",
-      "Matikan `prerender` untuk route ini atau pindahkan datanya ke serverFn request-time"
+      "Do not return secret env values from a loader that runs at prerender time",
+      "Turn off `prerender` for this route or move the data to a request-time serverFn"
     ]
   });
 }
@@ -1290,35 +1290,35 @@ async function resolvePathnames(route, module) {
     throw new MoonsError3({
       code: "E_PRERENDER_NO_PATHS",
       file: route.file,
-      message: "route dynamic ber-`prerender = true` tanpa `export const paths`",
-      details: "Prerender butuh daftar param untuk merender tiap path.",
+      message: "dynamic route with `prerender = true` without `export const paths`",
+      details: "Prerendering needs a param list to render each path.",
       suggestions: [
-        'Tambahkan `export const paths = () => [{ id: "…" }]`',
-        "Atau hapus `prerender` agar dirender SSR saat request"
+        'Add `export const paths = () => [{ id: "…" }]`',
+        "Or remove `prerender` so the route renders at request time (SSR)"
       ]
     });
   }
   const raw = await paths();
   if (!Array.isArray(raw)) {
-    throw prerenderError(route, "`paths()` harus mengembalikan array");
+    throw prerenderError(route, "`paths()` must return an array");
   }
   const expected = new Set(route.params);
   const result = [];
   for (const item of raw) {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw prerenderError(route, "item `paths()` harus objek param string");
+      throw prerenderError(route, "`paths()` items must be objects with string params");
     }
     const record = item;
     const keys = Object.keys(record);
     for (const name of expected) {
       const value = record[name];
       if (typeof value !== "string" || value.length === 0) {
-        throw prerenderError(route, `param \`${name}\` wajib string non-kosong`);
+        throw prerenderError(route, `param \`${name}\` must be a non-empty string`);
       }
     }
     for (const key of keys) {
       if (!expected.has(key)) {
-        throw prerenderError(route, `param \`${key}\` tidak ada di pola route`);
+        throw prerenderError(route, `param \`${key}\` is not in the route pattern`);
       }
     }
     result.push(buildPathname(route, record));
@@ -1351,7 +1351,7 @@ function buildPathname(route, params) {
 }
 function encodeSegment(route, value) {
   if (value.length === 0 || /^\.+$/.test(value)) {
-    throw prerenderError(route, `nilai param \`${value}\` tidak valid untuk path file`);
+    throw prerenderError(route, `param value \`${value}\` is not valid for a file path`);
   }
   return encodeURIComponent(value);
 }
@@ -1362,9 +1362,9 @@ function outputFile(clientDir, pathname) {
   if (file !== base && !file.startsWith(base + sep2)) {
     throw new MoonsError3({
       code: "E_PRERENDER_INVALID",
-      message: `path prerender keluar dari direktori client (\`${pathname}\`)`,
-      details: "Nama file harus berada di dalam `dist/client`.",
-      suggestions: ["Periksa nilai param `paths` — jangan memakai `..`"]
+      message: `prerender path escapes the client directory (\`${pathname}\`)`,
+      details: "The file name must stay inside `dist/client`.",
+      suggestions: ["Check the `paths` param values — do not use `..`"]
     });
   }
   return file;
@@ -1374,10 +1374,10 @@ function prerenderError(route, message) {
     code: "E_PRERENDER_INVALID",
     file: route.file,
     message,
-    details: "Kontrak prerender mengikuti.",
+    details: "The prerender contract is enforced.",
     suggestions: [
-      "Perbaiki bentuk `paths`/param agar cocok dengan pola route",
-      "Jangan memakai `redirect()` pada route yang di-prerender"
+      "Fix the `paths`/params shape so it matches the route pattern",
+      "Do not use `redirect()` on a prerendered route"
     ]
   });
 }
@@ -1401,4 +1401,4 @@ export {
   toWebRequest2 as toWebRequest
 };
 
-//# debugId=49CA3636C1DE25F564756E2164756E21
+//# debugId=01666BCB63B6268E64756E2164756E21