odoro 1.0.9 → 2.0.0

package/dist/chunk-QOVBLN7A.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import { guessAliasPaths } from './chunk-T6RLHSCW.js';
+import { existsSync } from 'fs';
+import { readFile, mkdir, writeFile, rm } from 'fs/promises';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { build } from 'esbuild';
+
+var LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/;
+var REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+function parseEnvDetailed(text) {
+  const values = {};
+  const literals = /* @__PURE__ */ new Set();
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line === void 0) continue;
+    if (line.trim() === "" || line.trimStart().startsWith("#")) continue;
+    const found = LINE.exec(line);
+    const key = found?.[1];
+    if (key === void 0) continue;
+    const raw = (found?.[2] ?? "").trim();
+    const quote = raw[0];
+    if (quote !== '"' && quote !== "'" && quote !== "`") {
+      const comment = raw.search(/\s#/);
+      values[key] = comment === -1 ? raw : raw.slice(0, comment).trimEnd();
+      continue;
+    }
+    let body = raw.slice(1);
+    while (body.length === 0 || !body.endsWith(quote)) {
+      const next = lines[index + 1];
+      if (next === void 0) break;
+      index += 1;
+      body = `${body}
+${next}`;
+    }
+    const content = body.endsWith(quote) ? body.slice(0, -1) : body;
+    if (quote === "'") {
+      values[key] = content;
+      literals.add(key);
+      continue;
+    }
+    values[key] = content.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return { values, literals };
+}
+function expand(values, environment, literals) {
+  const rendered = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (literals.has(key)) {
+      rendered[key] = value;
+      continue;
+    }
+    rendered[key] = value.replace(REFERENCE, (whole, braced, bare) => {
+      const name = braced ?? bare;
+      if (name === void 0) return whole;
+      return rendered[name] ?? values[name] ?? environment[name] ?? "";
+    });
+  }
+  return rendered;
+}
+function envFilesFor(mode) {
+  return [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
+}
+async function loadEnv(directory, mode, prefix) {
+  const stacked = {};
+  const literals = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const name of envFilesFor(mode)) {
+    const path = join(directory, name);
+    if (!existsSync(path)) continue;
+    files.push(name);
+    const read = parseEnvDetailed(await readFile(path, "utf8"));
+    Object.assign(stacked, read.values);
+    for (const key of Object.keys(read.values)) {
+      if (read.literals.has(key)) literals.add(key);
+      else literals.delete(key);
+    }
+  }
+  const all = expand(stacked, process.env, literals);
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && key in all) all[key] = value;
+  }
+  const client = {};
+  for (const [key, value] of Object.entries(all)) {
+    if (key.startsWith(prefix)) client[key] = value;
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && key.startsWith(prefix)) client[key] = value;
+  }
+  return { all, client, files };
+}
+function clientEnv(variables, mode, base) {
+  return {
+    MODE: mode,
+    // `DEV` and `PROD` cannot be deduced from the mode name alone: a `staging`
+    // mode builds as production and must behave like it.
+    DEV: mode === "development",
+    PROD: mode !== "development",
+    BASE_URL: base,
+    ...variables
+  };
+}
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_FILES = ["odoro.config.ts", "odoro.config.js", "odoro.config.mjs"];
+async function importConfigFile(file, root) {
+  const directory = join(root, "node_modules", ".odoro");
+  const output = join(directory, `config.${Date.now().toString(36)}.mjs`);
+  await mkdir(directory, { recursive: true });
+  try {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      write: false,
+      // Only the project code is inlined; its dependencies stay external,
+      // otherwise the whole node_modules would have to be resolved to read
+      // three lines.
+      packages: "external",
+      // `packages: 'external'` is not enough: a `baseUrl` in the
+      // `tsconfig.json` makes bare imports be looked up from the project root,
+      // where `odoro.json` — the registry file — is found before the package.
+      // The import then stops being a package import, the rule above no longer
+      // applies, and the build fails on a `defineConfig` missing from a
+      // configuration file.
+      //
+      // Naming it explicitly puts it out of reach of that resolution. The list
+      // matters for projects already created: they still carry a `baseUrl`, and
+      // their tsconfig cannot be rewritten.
+      external: ["odoro"]
+    });
+    const code = result.outputFiles[0]?.text;
+    if (code === void 0) {
+      throw new Error(`[odoro] Configuration "${file}" produced no code.`);
+    }
+    await writeFile(output, code, "utf8");
+    const module = await import(pathToFileURL(output).href);
+    if (module.default === void 0) {
+      throw new Error(`[odoro] Configuration "${file}" must have a default export.`);
+    }
+    return module.default;
+  } finally {
+    await rm(output, { force: true });
+  }
+}
+function resolvePrerender(requested, root) {
+  if (requested === void 0 || requested === false) return void 0;
+  const raw = requested === true ? {} : Array.isArray(requested) ? { routes: requested } : requested;
+  return {
+    routes: raw.routes ?? [],
+    entry: resolve(root, raw.entry ?? "src/entry-server.tsx")
+  };
+}
+async function loadConfig(root, overrides = {}, defaultMode = "production") {
+  const absoluteRoot = resolve(root);
+  let file;
+  let loaded = {};
+  for (const candidate of CONFIG_FILES) {
+    const path = join(absoluteRoot, candidate);
+    if (existsSync(path)) {
+      file = path;
+      loaded = await importConfigFile(path, absoluteRoot);
+      break;
+    }
+  }
+  const merged = {
+    ...loaded,
+    ...overrides,
+    server: { ...loaded.server, ...overrides.server },
+    build: { ...loaded.build, ...overrides.build },
+    alias: { ...loaded.alias, ...overrides.alias },
+    define: { ...loaded.define, ...overrides.define }
+  };
+  const base = merged.base ?? "/";
+  const projectRoot = merged.root === void 0 ? absoluteRoot : resolve(absoluteRoot, merged.root);
+  const mode = merged.mode ?? defaultMode;
+  const envPrefix = merged.envPrefix ?? "ODORO_";
+  const envDir = merged.envDir === void 0 ? projectRoot : resolve(projectRoot, merged.envDir);
+  const environment = await loadEnv(envDir, mode, envPrefix);
+  for (const [key, value] of Object.entries(environment.all)) {
+    process.env[key] ??= value;
+  }
+  const https = merged.server?.https;
+  return {
+    root: projectRoot,
+    base: base.endsWith("/") ? base : `${base}/`,
+    publicDir: resolve(projectRoot, merged.publicDir ?? "public"),
+    outDir: resolve(projectRoot, merged.build?.outDir ?? "dist"),
+    server: {
+      port: merged.server?.port ?? 5180,
+      host: merged.server?.host ?? "localhost",
+      proxy: merged.server?.proxy ?? {},
+      https: https === void 0 ? void 0 : { ...https },
+      strictPort: merged.server?.strictPort ?? false,
+      open: merged.server?.open ?? false
+    },
+    build: {
+      outDir: merged.build?.outDir ?? "dist",
+      minify: merged.build?.minify ?? true,
+      sourcemap: merged.build?.sourcemap ?? true,
+      target: merged.build?.target ?? "es2022",
+      // On by default: a stylesheet holding every possible class is a
+      // generation accident, not an intention.
+      prune: merged.build?.prune ?? true,
+      safelist: merged.build?.safelist ?? [],
+      // On by default: the manifest only costs a file of a few lines, and
+      // preloading removes a cascade of requests nobody sees on a local machine
+      // and everybody suffers elsewhere.
+      manifest: merged.build?.manifest ?? true,
+      preload: merged.build?.preload ?? true,
+      prerender: resolvePrerender(merged.build?.prerender, projectRoot)
+    },
+    // The aliases declared in `tsconfig.json` are picked up automatically.
+    // Without that, a project following `odoro init` — which infers its prefix
+    // from the tsconfig — would have to redeclare the same alias here for the
+    // server to resolve it. Two places for the same truth, and an error that
+    // only shows up on the first import.
+    //
+    // The configuration wins: it is what you write to fix a case the inference
+    // does not catch.
+    alias: { ...await guessAliasPaths(projectRoot), ...merged.alias },
+    define: merged.define ?? {},
+    envPrefix,
+    envDir,
+    mode,
+    env: environment.all,
+    envClient: clientEnv(
+      environment.client,
+      mode,
+      base.endsWith("/") ? base : `${base}/`
+    ),
+    plugins: merged.plugins ?? [],
+    configFile: file
+  };
+}
+
+export { clientEnv, defineConfig, loadConfig, loadEnv };