odoro 0.1.0

package/dist/chunk-JMEHF3KN.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import colors from 'picocolors';
+export { default as colors } from 'picocolors';
+
+var TAG = colors.bold(colors.magenta("odoro"));
+function stamp() {
+  return colors.dim((/* @__PURE__ */ new Date()).toLocaleTimeString("fr-FR", { hour12: false }));
+}
+function info(message) {
+  console.log(`${stamp()} ${TAG} ${message}`);
+}
+function success(message) {
+  console.log(`${stamp()} ${TAG} ${colors.green(message)}`);
+}
+function warn(message) {
+  console.warn(`${stamp()} ${TAG} ${colors.yellow(message)}`);
+}
+function error(message, cause) {
+  console.error(`${stamp()} ${TAG} ${colors.red(message)}`);
+  if (cause instanceof Error && cause.stack !== void 0) {
+    console.error(colors.dim(cause.stack));
+  } else if (cause !== void 0) {
+    console.error(colors.dim(String(cause)));
+  }
+}
+function duration(milliseconds) {
+  return milliseconds < 1e3 ? `${Math.round(milliseconds)} ms` : `${(milliseconds / 1e3).toFixed(2)} s`;
+}
+function size(bytes) {
+  if (bytes < 1024) return `${bytes} o`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} Ko`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} Mo`;
+}
+
+export { duration, error, info, size, success, warn };

package/dist/chunk-PEMYUK2D.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { readFile, writeFile, appendFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+function checkDatabaseUrl(value) {
+  const url = value.trim();
+  if (url.length === 0) return "L'URL ne peut pas etre vide.";
+  if (!/^postgres(ql)?:\/\//i.test(url)) {
+    return "Une URL PostgreSQL commence par postgres:// ou postgresql://";
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "Cette chaine n'est pas une URL valide.";
+  }
+  if (parsed.hostname.length === 0) return "Aucun hote dans cette URL.";
+  if (parsed.pathname.replace(/^\//, "").length === 0) {
+    return "Aucun nom de base : ajoutez-le apres le port, par exemple /mon_projet";
+  }
+  if (!/^(localhost|127\.0\.0\.1|\[::1\])$/i.test(parsed.hostname) && parsed.searchParams.get("sslmode") === "disable") {
+    return "sslmode=disable sur une base distante : le trafic passerait en clair.";
+  }
+  return void 0;
+}
+async function writeDatabaseUrl(target, url) {
+  const path = join(target, ".env");
+  const line = `DATABASE_URL=${url}
+`;
+  if (!existsSync(path)) {
+    const example = join(target, ".env.example");
+    const base = existsSync(example) ? await readFile(example, "utf8") : "";
+    await writeFile(path, base.replace(/^DATABASE_URL=.*$/m, line.trimEnd()), "utf8");
+    if (!base.includes("DATABASE_URL=")) await appendFile(path, line, "utf8");
+    return;
+  }
+  const current = await readFile(path, "utf8");
+  await writeFile(
+    path,
+    current.includes("DATABASE_URL=") ? current.replace(/^DATABASE_URL=.*$/m, line.trimEnd()) : current + line,
+    "utf8"
+  );
+}
+async function assertEnvIgnored(target) {
+  const path = join(target, ".gitignore");
+  if (!existsSync(path)) {
+    return "Aucun .gitignore : le fichier .env risque d'etre versionne.";
+  }
+  const content = await readFile(path, "utf8");
+  const ignored = content.split("\n").map((line) => line.trim()).some((line) => line === ".env" || line === ".env*" || line === "*.env");
+  return ignored ? void 0 : ".env ne figure pas dans le .gitignore : vos identifiants risquent d etre versionnes.";
+}
+var PROVIDER_PENDING = [
+  "Le provisionnement passe par @odoro/cloud-sdk, installe a part :",
+  "",
+  "  npm install --save-dev @odoro/cloud-sdk",
+  "  odoro db:login",
+  "  odoro db:create --env production",
+  "",
+  "Il ne vient pas avec odoro : ce binaire est telecharge a chaque creation de projet, et la plupart emploient leur propre base."
+].join("\n");
+
+export { PROVIDER_PENDING, assertEnvIgnored, checkDatabaseUrl, writeDatabaseUrl };

package/dist/chunk-T42X2NJN.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { guessAliasPaths } from './chunk-T6RLHSCW.js';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { pathToFileURL } from 'url';
+import { build } from 'esbuild';
+
+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,
+      // Seul le code du projet est inline ; ses dependances restent externes,
+      // sans quoi il faudrait resoudre tout node_modules pour lire trois lignes.
+      packages: "external"
+    });
+    const code = result.outputFiles[0]?.text;
+    if (code === void 0) {
+      throw new Error(`[odoro] La configuration "${file}" n'a produit aucun code.`);
+    }
+    await writeFile(output, code, "utf8");
+    const module = await import(pathToFileURL(output).href);
+    if (module.default === void 0) {
+      throw new Error(
+        `[odoro] La configuration "${file}" doit avoir un export par defaut.`
+      );
+    }
+    return module.default;
+  } finally {
+    await rm(output, { force: true });
+  }
+}
+async function loadConfig(root, overrides = {}) {
+  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);
+  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 ?? {}
+    },
+    build: {
+      outDir: merged.build?.outDir ?? "dist",
+      minify: merged.build?.minify ?? true,
+      sourcemap: merged.build?.sourcemap ?? true,
+      target: merged.build?.target ?? "es2022"
+    },
+    // Les alias declares dans `tsconfig.json` sont repris d'office. Sans
+    // cela, un projet qui suit `odoro init` — lequel deduit son prefixe du
+    // tsconfig — aurait a redeclarer le meme alias ici pour que le serveur
+    // sache le resoudre. Deux endroits pour la meme verite, et une erreur
+    // qui n'apparait qu'au premier import.
+    //
+    // La configuration l'emporte : c'est elle qu'on ecrit pour corriger un
+    // cas que la deduction n'attrape pas.
+    alias: { ...await guessAliasPaths(projectRoot), ...merged.alias },
+    define: merged.define ?? {},
+    envPrefix: merged.envPrefix ?? "ODORO_",
+    configFile: file
+  };
+}
+
+export { defineConfig, loadConfig };

package/dist/chunk-T6RLHSCW.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { readFile } from 'fs/promises';
+import { join, posix } from 'path';
+
+function stripJsonComments(source) {
+  let output = "";
+  let inString = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index] ?? "";
+    const next = source[index + 1] ?? "";
+    if (inLine) {
+      if (char === "\n") {
+        inLine = false;
+        output += char;
+      }
+      continue;
+    }
+    if (inBlock) {
+      if (char === "*" && next === "/") {
+        inBlock = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      output += char;
+      if (char === "\\") {
+        output += next;
+        index += 1;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLine = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlock = true;
+      index += 1;
+      continue;
+    }
+    output += char;
+  }
+  return output.replace(/,(\s*[}\]])/g, "$1");
+}
+function toDirectory(target, baseUrl) {
+  const withoutStar = target.replace(/\/?\*+$/, "");
+  const cleaned = withoutStar.replace(/^\.\//, "");
+  const base = (baseUrl ?? ".").replace(/^\.\/?/, "");
+  const joined = base === "" ? cleaned : posix.join(base, cleaned);
+  return joined === "" ? "." : joined;
+}
+async function guessAlias(root) {
+  let raw;
+  try {
+    raw = await readFile(join(root, "tsconfig.json"), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(raw));
+  } catch {
+    return null;
+  }
+  const paths = parsed.compilerOptions?.paths;
+  if (paths === void 0) return null;
+  const candidates = [];
+  for (const [pattern, targets] of Object.entries(paths)) {
+    if (!pattern.endsWith("/*")) continue;
+    const target = targets[0];
+    if (target === void 0) continue;
+    candidates.push({
+      prefix: pattern.slice(0, -2),
+      directory: toDirectory(target, parsed.compilerOptions?.baseUrl)
+    });
+  }
+  candidates.sort((a, b) => a.directory.split("/").length - b.directory.split("/").length);
+  return candidates[0] ?? null;
+}
+function defaultAliases(guess) {
+  if (guess === null) {
+    return { import: "src/odoro", directory: "src/odoro" };
+  }
+  return {
+    import: `${guess.prefix}/odoro`,
+    directory: posix.join(guess.directory, "odoro")
+  };
+}
+async function guessAliasPaths(root) {
+  let raw;
+  try {
+    raw = await readFile(join(root, "tsconfig.json"), "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(raw));
+  } catch {
+    return {};
+  }
+  const aliases = {};
+  for (const [pattern, targets] of Object.entries(parsed.compilerOptions?.paths ?? {})) {
+    if (!pattern.endsWith("/*")) continue;
+    const target = targets[0];
+    if (target === void 0) continue;
+    aliases[pattern.slice(0, -2)] = toDirectory(target, parsed.compilerOptions?.baseUrl);
+  }
+  return aliases;
+}
+
+export { defaultAliases, guessAlias, guessAliasPaths };

package/dist/chunk-UGRSODHU.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { extractEntries, applyAlias, isBareSpecifier } from './chunk-G5QXVBYT.js';
+import { info, colors, size, success, duration } from './chunk-JMEHF3KN.js';
+import { existsSync } from 'fs';
+import { readFile, rm, mkdir, writeFile, cp } from 'fs/promises';
+import { join, basename, relative, resolve, sep } from 'path';
+import { build } from 'esbuild';
+
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+function buildEnv(config) {
+  const env = {
+    MODE: "production",
+    DEV: false,
+    PROD: true,
+    BASE_URL: config.base
+  };
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith(config.envPrefix) && value !== void 0) env[key] = value;
+  }
+  return env;
+}
+function outputsForEntry(result, entry, outDir, root) {
+  const toRelative = (file) => toPosix(relative(outDir, resolve(root, file)));
+  for (const [file, meta] of Object.entries(result.metafile.outputs)) {
+    if (meta.entryPoint === void 0) continue;
+    if (resolve(root, meta.entryPoint) !== resolve(entry)) continue;
+    if (!file.endsWith(".js")) continue;
+    return {
+      script: toRelative(file),
+      styles: meta.cssBundle === void 0 ? [] : [toRelative(meta.cssBundle)]
+    };
+  }
+  return { script: void 0, styles: [] };
+}
+async function buildProject(config) {
+  const started = Date.now();
+  const indexFile = join(config.root, "index.html");
+  if (!existsSync(indexFile)) {
+    throw new Error(`[odoro] Aucun "index.html" a la racine du projet (${config.root}).`);
+  }
+  const html = await readFile(indexFile, "utf8");
+  const entries = extractEntries(html, config.root);
+  if (entries.length === 0) {
+    throw new Error(
+      `[odoro] Aucun point d'entree : "index.html" doit contenir un <script type="module" src="...">.`
+    );
+  }
+  await rm(config.outDir, { recursive: true, force: true });
+  await mkdir(config.outDir, { recursive: true });
+  const result = await build({
+    entryPoints: [...entries],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: config.build.target,
+    splitting: true,
+    minify: config.build.minify,
+    sourcemap: config.build.sourcemap,
+    metafile: true,
+    outdir: join(config.outDir, "assets"),
+    absWorkingDir: config.root,
+    publicPath: `${config.base}assets`,
+    // Les empreintes rendent les fichiers immuables : ils peuvent etre mis en
+    // cache indefiniment, et un deploiement n'invalide que ce qui a change.
+    entryNames: "[name]-[hash]",
+    chunkNames: "chunk-[hash]",
+    assetNames: "[name]-[hash]",
+    jsx: "automatic",
+    logLevel: "silent",
+    define: {
+      "import.meta.env": JSON.stringify(buildEnv(config)),
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      ...config.define
+    },
+    loader: {
+      ".svg": "file",
+      ".png": "file",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".gif": "file",
+      ".webp": "file",
+      ".avif": "file",
+      ".ico": "file",
+      ".woff": "file",
+      ".woff2": "file",
+      ".mp4": "file",
+      ".webm": "file"
+    },
+    plugins: [
+      {
+        name: "odoro-alias",
+        setup(builder) {
+          builder.onResolve({ filter: /.*/ }, (args) => {
+            if (args.kind === "entry-point") return null;
+            const aliased = applyAlias(args.path, config);
+            if (aliased === args.path || isBareSpecifier(aliased)) return null;
+            return builder.resolve(aliased, {
+              kind: "import-statement",
+              resolveDir: args.resolveDir,
+              importer: args.importer,
+              pluginData: { aliased: true }
+            });
+          });
+        }
+      }
+    ]
+  });
+  let output = html;
+  for (const entry of entries) {
+    const { script, styles } = outputsForEntry(
+      result,
+      entry,
+      join(config.outDir, "assets"),
+      config.root
+    );
+    if (script === void 0) continue;
+    const original = new RegExp(
+      `<script[^>]*type=["']module["'][^>]*src=["'][^"']*${basename(entry)}["'][^>]*></script>`,
+      "i"
+    );
+    const tags = [
+      ...styles.map(
+        (style) => `<link rel="stylesheet" href="${config.base}assets/${style}">`
+      ),
+      `<script type="module" crossorigin src="${config.base}assets/${script}"></script>`
+    ].join("\n    ");
+    output = output.replace(original, tags);
+  }
+  await writeFile(join(config.outDir, "index.html"), output, "utf8");
+  if (existsSync(config.publicDir)) {
+    await cp(config.publicDir, config.outDir, { recursive: true });
+  }
+  const files = Object.entries(result.metafile.outputs).map(([file, meta]) => ({
+    path: toPosix(relative(config.outDir, resolve(config.root, file))),
+    bytes: meta.bytes
+  })).sort((a, b) => b.bytes - a.bytes);
+  return { outDir: config.outDir, files, elapsed: Date.now() - started };
+}
+function reportBuild(output, root) {
+  const directory = toPosix(relative(root, output.outDir)) || ".";
+  let total = 0;
+  for (const file of output.files) {
+    total += file.bytes;
+    if (file.path.endsWith(".map")) continue;
+    info(
+      `  ${colors.dim(`${directory}/`)}${file.path}  ${colors.dim(size(file.bytes))}`
+    );
+  }
+  success(`compile en ${duration(output.elapsed)} \u2014 ${size(total)} au total`);
+}
+
+export { buildProject, reportBuild };

package/dist/cli.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Entree en ligne de commande du moteur Odoro.
+ *
+ * L'analyse des arguments est ecrite a la main : elle tient en quarante
+ * lignes, et le binaire est telecharge a chaque `npm create odoro`, donc son
+ * poids compte.
+ *
+ * @module
+ */
+/** Arguments analyses. */
+interface ParsedArgs {
+    /** Sous-commande demandee. */
+    command: string;
+    /** Arguments positionnels restants. */
+    positional: string[];
+    /** Options nommees. */
+    flags: Record<string, string | boolean>;
+}
+/**
+ * Analyse une ligne de commande.
+ *
+ * Reconnait `--option`, `--option=valeur`, `--option valeur`, `--no-option`
+ * et les alias courts `-h` et `-v`.
+ *
+ * @example
+ * parseArgs(['create', 'site', '--template=react-ts', '--no-git'])
+ * // { command: 'create', positional: ['site'], flags: { template: 'react-ts', git: false } }
+ */
+declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/**
+ * Point d'entree du binaire.
+ *
+ * @returns Le code de sortie du processus.
+ *
+ * @example
+ * const code = await run(['dev', '--port', '3000'])
+ */
+declare function run(argv: readonly string[]): Promise<number>;
+
+export { type ParsedArgs, parseArgs, run };