vantris 0.2.0 → 0.3.0

package/dist/chunk-OFLPPG2U.js

@@ -1,600 +0,0 @@
-import { pathToFileURL } from 'url';
-import { readFile, stat, mkdir } from 'fs/promises';
-import { relative, isAbsolute, resolve, join, sep, extname } from 'path';
-import { createServer } from 'http';
-import { H3, toNodeHandler, getRequestURL } from 'h3';
-import { WebSocketServer, WebSocket } from 'ws';
-import { transform } from 'esbuild';
-import { watch } from 'chokidar';
-
-// src/shared/constants.ts
-var APP_NAME = "vantris";
-var VERSION = "0.2.0";
-var HTML_ENTRY_FILENAME = "index.html";
-var DEFAULTS = {
-  root: ".",
-  rootDir: "./src",
-  publicDir: "./public",
-  outDir: "./dist"
-};
-var DEV_DEFAULTS = {
-  port: 3e3,
-  host: "localhost"
-};
-var RELOAD_MESSAGE = "reload";
-var CONFIG_FILENAMES = [
-  "vantris.config.ts",
-  "vantris.config.js",
-  "vantris.config.mjs"
-];
-
-// src/shared/errors.ts
-var VantrisError = class extends Error {
-  name = "VantrisError";
-  constructor(message, options) {
-    super(message, options);
-  }
-};
-var ConfigError = class extends VantrisError {
-  name = "ConfigError";
-};
-var HtmlEntryError = class extends VantrisError {
-  name = "HtmlEntryError";
-};
-var NotImplementedError = class extends VantrisError {
-  name = "NotImplementedError";
-};
-function isVantrisError(error) {
-  return error instanceof VantrisError;
-}
-async function isFile(path) {
-  try {
-    return (await stat(path)).isFile();
-  } catch {
-    return false;
-  }
-}
-function readTextFile(path) {
-  return readFile(path, "utf8");
-}
-async function ensureDir(path) {
-  await mkdir(path, { recursive: true });
-}
-function resolveFrom(base, target) {
-  return isAbsolute(target) ? target : resolve(base, target);
-}
-
-// src/config/load.ts
-async function loadConfig(options) {
-  const { cwd, logger } = options;
-  const file = options.configFile ? resolveFrom(cwd, options.configFile) : await findConfigFile(cwd);
-  if (!file) {
-    logger.debug("No config file found; using defaults.");
-    return { config: {}, file: null };
-  }
-  logger.debug(`Loading config from ${file}`);
-  const config = await importConfig(file);
-  return { config, file };
-}
-async function findConfigFile(cwd) {
-  for (const name of CONFIG_FILENAMES) {
-    const candidate = resolveFrom(cwd, name);
-    if (await isFile(candidate)) return candidate;
-  }
-  return null;
-}
-async function importConfig(file) {
-  let mod;
-  try {
-    const url = `${pathToFileURL(file).href}?t=${Date.now()}`;
-    mod = await import(url);
-  } catch (cause) {
-    throw new ConfigError(`Failed to load config file: ${file}`, { cause });
-  }
-  const exported = mod.default;
-  if (exported === void 0) {
-    throw new ConfigError(
-      `Config file "${file}" has no default export. Export your config with \`export default defineConfig({ ... })\`.`
-    );
-  }
-  return normalise(exported, file);
-}
-async function normalise(input, file) {
-  const value = typeof input === "function" ? await input() : input;
-  if (value === null || typeof value !== "object") {
-    throw new ConfigError(
-      `Config file "${file}" must export an object (or a function returning one).`
-    );
-  }
-  return value;
-}
-
-// src/config/resolve.ts
-function resolveConfig(raw, cwd, configFile = null) {
-  const root = resolveFrom(cwd, raw.root ?? DEFAULTS.root);
-  const paths = {
-    root,
-    rootDir: resolveFrom(root, raw.rootDir ?? DEFAULTS.rootDir),
-    publicDir: resolveFrom(root, raw.publicDir ?? DEFAULTS.publicDir),
-    outDir: resolveFrom(root, raw.outDir ?? DEFAULTS.outDir)
-  };
-  const dev2 = {
-    port: raw.dev?.port ?? DEV_DEFAULTS.port,
-    host: raw.dev?.host ?? DEV_DEFAULTS.host
-  };
-  return { raw, paths, dev: dev2, configFile };
-}
-
-// src/html/parse.ts
-var SCRIPT_TAG = /<script\b[^>]*>/gi;
-var TYPE_MODULE = /\btype\s*=\s*["']module["']/i;
-var SRC_ATTR = /\bsrc\s*=\s*["']([^"']+)["']/i;
-function parseHtml(file, html) {
-  const scripts = [];
-  for (const [tag] of html.matchAll(SCRIPT_TAG)) {
-    if (!TYPE_MODULE.test(tag)) continue;
-    const src = SRC_ATTR.exec(tag)?.[1];
-    if (src) scripts.push({ src });
-  }
-  return { file, html, scripts };
-}
-
-// src/html/detect.ts
-async function detectHtmlEntry(root) {
-  const file = resolveFrom(root, HTML_ENTRY_FILENAME);
-  if (!await isFile(file)) return null;
-  const html = await readTextFile(file);
-  return parseHtml(file, html);
-}
-
-// src/html/client.ts
-var DEV_CLIENT_SCRIPT = `<script type="module">
-  // Injected by Vantris dev server \u2014 live reload (full page).
-  const connect = () => {
-    const ws = new WebSocket("ws://" + location.host);
-    ws.addEventListener("message", () => location.reload());
-    // Reconnect if the dev server restarts.
-    ws.addEventListener("close", () => setTimeout(connect, 1000));
-  };
-  connect();
-</script>`;
-function injectDevClient(html) {
-  if (html.includes("</head>")) {
-    return html.replace("</head>", `${DEV_CLIENT_SCRIPT}
-</head>`);
-  }
-  if (html.includes("</body>")) {
-    return html.replace("</body>", `${DEV_CLIENT_SCRIPT}
-</body>`);
-  }
-  return `${html}
-${DEV_CLIENT_SCRIPT}`;
-}
-function createReloadSocket(options) {
-  const { server, logger } = options;
-  const wss = new WebSocketServer({ server });
-  const clients = /* @__PURE__ */ new Set();
-  wss.on("connection", (socket) => {
-    clients.add(socket);
-    socket.on("close", () => clients.delete(socket));
-    socket.on("error", () => clients.delete(socket));
-  });
-  wss.on("error", (error) => {
-    logger.error(`websocket error: ${error.message}`);
-  });
-  return {
-    broadcastReload() {
-      for (const socket of clients) {
-        if (socket.readyState === WebSocket.OPEN) {
-          socket.send(RELOAD_MESSAGE);
-        }
-      }
-    },
-    get clientCount() {
-      return clients.size;
-    },
-    close() {
-      return new Promise((resolveClose) => {
-        for (const socket of clients) socket.terminate();
-        clients.clear();
-        wss.close(() => resolveClose());
-      });
-    }
-  };
-}
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain; charset=utf-8",
-  ".map": "application/json; charset=utf-8"
-};
-var JAVASCRIPT = "text/javascript; charset=utf-8";
-function contentTypeFor(file, transpiled = false) {
-  if (transpiled) return JAVASCRIPT;
-  return MIME_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
-}
-var TRANSPILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".jsx"]);
-function shouldTranspile(file) {
-  return TRANSPILE_EXTENSIONS.has(extname(file).toLowerCase());
-}
-function loaderFor(file) {
-  switch (extname(file).toLowerCase()) {
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    default:
-      return "ts";
-  }
-}
-async function transpile(code, file) {
-  const result = await transform(code, {
-    loader: loaderFor(file),
-    format: "esm",
-    target: "es2022",
-    sourcemap: "inline",
-    sourcefile: file
-  });
-  return result.code;
-}
-
-// src/server/static.ts
-var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs", ".jsx"];
-function createStaticLoader(options) {
-  const root = resolve(options.root);
-  const rootDir = resolve(options.rootDir);
-  const publicDir = resolve(options.publicDir);
-  return async function loadAsset(pathname) {
-    const relative3 = decodeURIComponent(pathname).replace(/^\/+/, "");
-    if (!relative3) return null;
-    const source = await resolveConfined(root, rootDir, relative3);
-    if (source) return readAsset(source);
-    const asset = await resolveConfined(publicDir, publicDir, relative3);
-    if (asset) return readAsset(asset);
-    return null;
-  };
-}
-async function resolveConfined(base, confine, relative3) {
-  const target = resolve(join(base, relative3));
-  if (target !== confine && !target.startsWith(confine + sep)) {
-    return null;
-  }
-  if (await isFile(target)) return target;
-  if (!extname(target)) {
-    for (const ext of RESOLVE_EXTENSIONS) {
-      const candidate = `${target}${ext}`;
-      if (await isFile(candidate)) return candidate;
-    }
-  }
-  return null;
-}
-async function readAsset(file) {
-  const ext = extname(file).toLowerCase();
-  const isHtml = ext === ".html";
-  if (shouldTranspile(file)) {
-    const source = await readFile(file, "utf8");
-    return {
-      body: await transpile(source, file),
-      contentType: contentTypeFor(file, true),
-      isHtml: false
-    };
-  }
-  if (isHtml) {
-    return {
-      body: await readFile(file, "utf8"),
-      contentType: contentTypeFor(file),
-      isHtml: true
-    };
-  }
-  return {
-    body: await readFile(file),
-    contentType: contentTypeFor(file),
-    isHtml: false
-  };
-}
-
-// src/server/index.ts
-var HTML_HEADERS = {
-  "content-type": "text/html; charset=utf-8",
-  "cache-control": "no-cache"
-};
-async function startDevServer(options) {
-  const { ctx, entry } = options;
-  const { paths, dev: dev2 } = ctx.config;
-  const loadAsset = createStaticLoader({
-    root: paths.root,
-    rootDir: paths.rootDir,
-    publicDir: paths.publicDir
-  });
-  const entryFile = entry?.file ?? null;
-  const app = new H3();
-  const handler = async (event) => {
-    const { pathname } = getRequestURL(event);
-    const asset = await loadAsset(pathname);
-    if (asset) {
-      if (asset.isHtml) {
-        return new Response(injectDevClient(asset.body), {
-          headers: HTML_HEADERS
-        });
-      }
-      return new Response(asset.body, {
-        headers: { "content-type": asset.contentType, "cache-control": "no-cache" }
-      });
-    }
-    if (entryFile) {
-      const html = await readFile(entryFile, "utf8");
-      return new Response(injectDevClient(html), { headers: HTML_HEADERS });
-    }
-    return new Response(`404 Not Found: ${pathname}`, {
-      status: 404,
-      headers: { "content-type": "text/plain; charset=utf-8" }
-    });
-  };
-  app.all("/", handler);
-  app.all("/**", handler);
-  const server = createServer(toNodeHandler(app));
-  const reload = createReloadSocket({ server, logger: ctx.logger });
-  await listen(server, dev2.port, dev2.host);
-  const url = `http://${dev2.host}:${dev2.port}/`;
-  return {
-    url,
-    host: dev2.host,
-    port: dev2.port,
-    broadcastReload: () => reload.broadcastReload(),
-    async close() {
-      await reload.close();
-      await new Promise((resolveClose, reject) => {
-        server.close((err) => err ? reject(err) : resolveClose());
-      });
-    }
-  };
-}
-function listen(server, port, host) {
-  return new Promise((resolveListen, reject) => {
-    const onError = (err) => {
-      server.removeListener("error", onError);
-      reject(
-        err.code === "EADDRINUSE" ? new Error(`Port ${port} is already in use.`) : err
-      );
-    };
-    server.once("error", onError);
-    server.listen(port, host, () => {
-      server.removeListener("error", onError);
-      resolveListen();
-    });
-  });
-}
-
-// src/shared/logger.ts
-var prefix = `[${APP_NAME}]`;
-function createLogger(options = {}) {
-  const { verbose = false, sink = console } = options;
-  return {
-    info(message) {
-      sink.log(`${prefix} ${message}`);
-    },
-    warn(message) {
-      sink.warn(`${prefix} ${message}`);
-    },
-    error(message) {
-      sink.error(`${prefix} ${message}`);
-    },
-    debug(message) {
-      if (verbose) sink.log(`${prefix} ${message}`);
-    }
-  };
-}
-
-// src/shared/context.ts
-async function createContext(options) {
-  const { cwd, logger } = options;
-  const loaded = await loadConfig({
-    cwd,
-    logger,
-    ...options.configFile !== void 0 ? { configFile: options.configFile } : {}
-  });
-  const config = resolveConfig(loaded.config, cwd, loaded.file);
-  return { cwd, config, logger };
-}
-function createWatcher(options) {
-  const { dir, logger, onChange } = options;
-  const watcher = watch(dir, {
-    ignoreInitial: true,
-    persistent: true,
-    ignored: (path) => path.includes("node_modules") || /(^|[/\\])\.[^/\\]/.test(path)
-  });
-  const emit = (kind) => (file) => {
-    logger.debug(`watch ${kind}: ${file}`);
-    onChange({ kind, file });
-  };
-  watcher.on("add", emit("add")).on("change", emit("change")).on("unlink", emit("unlink")).on(
-    "error",
-    (error) => logger.error(`watcher error: ${error.message}`)
-  );
-  return {
-    close: () => watcher.close()
-  };
-}
-function rel(ctx, target) {
-  return relative(ctx.config.paths.root, target) || ".";
-}
-async function inspectProject(ctx) {
-  const { paths, configFile } = ctx.config;
-  ctx.logger.info(
-    `config: ${configFile ? rel(ctx, configFile) : "defaults (no config file)"}`
-  );
-  ctx.logger.info(`rootDir:   ${rel(ctx, paths.rootDir)}`);
-  ctx.logger.info(`publicDir: ${rel(ctx, paths.publicDir)}`);
-  ctx.logger.info(`outDir:    ${rel(ctx, paths.outDir)}`);
-  const entry = await detectHtmlEntry(paths.root);
-  if (entry) {
-    ctx.logger.info(`html entry: ${rel(ctx, entry.file)}`);
-  } else {
-    ctx.logger.warn(
-      "no index.html found at the project root; nothing to serve yet."
-    );
-  }
-  return entry;
-}
-async function prepareDirectories(ctx, dirs) {
-  for (const dir of dirs) {
-    await ensureDir(dir);
-    ctx.logger.debug(`prepared directory: ${dir}`);
-  }
-}
-
-// src/commands/dev.ts
-var RELOAD_DEBOUNCE_MS = 50;
-var dev = {
-  name: "dev",
-  description: "Start the development server",
-  async run(ctx) {
-    const { root, rootDir, publicDir } = ctx.config.paths;
-    await prepareDirectories(ctx, [rootDir, publicDir]);
-    const entry = await inspectProject(ctx);
-    const server = await startDevServer({ ctx, entry });
-    ctx.logger.info(`ready \u2014 dev server running at ${server.url}`);
-    let timer;
-    const watcher = createWatcher({
-      dir: rootDir,
-      logger: ctx.logger,
-      onChange: ({ kind, file }) => {
-        ctx.logger.info(`${kind}: ${relative(root, file)} \u2014 reloading`);
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(() => server.broadcastReload(), RELOAD_DEBOUNCE_MS);
-      }
-    });
-    await waitForShutdown();
-    ctx.logger.info("shutting down\u2026");
-    if (timer) clearTimeout(timer);
-    await watcher.close();
-    await server.close();
-  }
-};
-function waitForShutdown() {
-  return new Promise((resolve3) => {
-    const onSignal = () => {
-      process.removeListener("SIGINT", onSignal);
-      process.removeListener("SIGTERM", onSignal);
-      resolve3();
-    };
-    process.once("SIGINT", onSignal);
-    process.once("SIGTERM", onSignal);
-  });
-}
-
-// src/build/index.ts
-async function runBuild(options) {
-  const { ctx } = options;
-  ctx.logger.info(
-    "build is not implemented in v0.1.0 (planned: Rolldown + esbuild)."
-  );
-}
-
-// src/commands/build.ts
-var build = {
-  name: "build",
-  description: "Build the project for production",
-  async run(ctx) {
-    const { rootDir, publicDir, outDir } = ctx.config.paths;
-    await prepareDirectories(ctx, [rootDir, publicDir, outDir]);
-    await inspectProject(ctx);
-    await runBuild({ ctx});
-  }
-};
-
-// src/preview/index.ts
-async function runPreview(options) {
-  const { ctx } = options;
-  ctx.logger.info(
-    "preview is not implemented in v0.1.0 (planned: static server over outDir)."
-  );
-}
-
-// src/commands/preview.ts
-var preview = {
-  name: "preview",
-  description: "Locally preview a production build",
-  async run(ctx) {
-    await prepareDirectories(ctx, [ctx.config.paths.outDir]);
-    await inspectProject(ctx);
-    await runPreview({ ctx });
-  }
-};
-
-// src/commands/index.ts
-var commands = {
-  [dev.name]: dev,
-  [build.name]: build,
-  [preview.name]: preview
-};
-
-// src/cli/help.ts
-function helpText() {
-  const lines = [
-    `${APP_NAME} v${VERSION} \u2014 a modern bundler for JavaScript/TypeScript`,
-    "",
-    "Usage:",
-    `  ${APP_NAME} <command> [options]`,
-    "",
-    "Commands:"
-  ];
-  const width = Math.max(...Object.keys(commands).map((n) => n.length));
-  for (const command of Object.values(commands)) {
-    lines.push(`  ${command.name.padEnd(width)}  ${command.description}`);
-  }
-  lines.push(
-    "",
-    "Options:",
-    "  -h, --help     Show this help",
-    "  -v, --version  Show the version number"
-  );
-  return lines.join("\n");
-}
-function versionText() {
-  return `${APP_NAME} v${VERSION}`;
-}
-
-// src/cli/run.ts
-async function run(argv, options = {}) {
-  const verbose = argv.includes("--verbose") || argv.includes("--debug");
-  const logger = options.logger ?? createLogger({ verbose });
-  const cwd = options.cwd ?? process.cwd();
-  const [first, ...rest] = argv.filter((arg) => !isGlobalFlag(arg));
-  if (!first || first === "--help" || first === "-h" || first === "help") {
-    logger.info(helpText());
-    return 0 /* Ok */;
-  }
-  if (first === "--version" || first === "-v") {
-    logger.info(versionText());
-    return 0 /* Ok */;
-  }
-  const command = commands[first];
-  if (!command) {
-    logger.error(`Unknown command: "${first}"`);
-    logger.info(helpText());
-    return 1 /* Error */;
-  }
-  const ctx = await createContext({ cwd, logger });
-  await command.run(ctx, rest);
-  return 0 /* Ok */;
-}
-function isGlobalFlag(arg) {
-  return arg === "--verbose" || arg === "--debug";
-}
-
-export { ConfigError, DEV_CLIENT_SCRIPT, HtmlEntryError, NotImplementedError, VERSION, VantrisError, commands, createContext, createLogger, createWatcher, detectHtmlEntry, injectDevClient, isVantrisError, loadConfig, parseHtml, resolveConfig, run, startDevServer };
-//# sourceMappingURL=chunk-OFLPPG2U.js.map
-//# sourceMappingURL=chunk-OFLPPG2U.js.map