odoro 0.1.0

package/dist/chunk-G5QXVBYT.js

@@ -0,0 +1,1139 @@
+#!/usr/bin/env node
+import { info, error, success, duration, colors, warn } from './chunk-JMEHF3KN.js';
+import { existsSync, readFileSync, statSync, watch, createReadStream } from 'fs';
+import { readFile, rm, mkdir, writeFile } from 'fs/promises';
+import { createServer, request } from 'http';
+import { resolve, join, dirname, extname, relative } from 'path';
+import { createHash } from 'crypto';
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { build } from 'esbuild';
+import { transformAsync } from '@babel/core';
+import reactRefreshPlugin from 'react-refresh/babel';
+
+// src/dev/client.ts
+var HMR_STREAM_PATH = "/@odoro/hmr";
+var HMR_CLIENT_PATH = "/@odoro/client";
+var HMR_CLIENT_SOURCE = String.raw`
+const OVERLAY_ID = 'odoro-error-overlay'
+
+/** Contextes de rechargement, par URL de module. */
+const contexts = new Map()
+
+/**
+ * Cree le contexte expose a un module via import.meta.hot.
+ * @param {string} url
+ */
+export function createHotContext(url) {
+  const existing = contexts.get(url)
+  if (existing) {
+    // Rechargement du meme module : les rappels de la version precedente sont
+    // executes puis oublies.
+    for (const callback of existing.disposers) {
+      try {
+        callback(existing.data)
+      } catch (cause) {
+        console.error('[odoro] echec du nettoyage de', url, cause)
+      }
+    }
+    existing.disposers = []
+    existing.acceptors = []
+    return existing.api
+  }
+
+  const context = { acceptors: [], disposers: [], data: {} }
+
+  context.api = {
+    get data() {
+      return context.data
+    },
+    accept(callback) {
+      context.acceptors.push(typeof callback === 'function' ? callback : () => {})
+    },
+    dispose(callback) {
+      context.disposers.push(callback)
+    },
+    invalidate() {
+      location.reload()
+    },
+  }
+
+  contexts.set(url, context)
+  return context.api
+}
+
+/**
+ * Recharge un module et notifie ceux qui l'acceptent.
+ * @param {string} url
+ * @param {number} timestamp
+ */
+async function applyUpdate(url, timestamp) {
+  const context = contexts.get(url)
+  if (!context || context.acceptors.length === 0) {
+    location.reload()
+    return
+  }
+
+  const acceptors = [...context.acceptors]
+  try {
+    const module = await import(url + (url.includes('?') ? '&' : '?') + 't=' + timestamp)
+    for (const accept of acceptors) accept(module)
+    console.log('[odoro] mis a jour', url)
+  } catch (cause) {
+    console.error('[odoro] echec de la mise a jour de', url, cause)
+    location.reload()
+  }
+}
+
+/** Retire la surcouche d'erreur si elle est affichee. */
+function clearOverlay() {
+  document.getElementById(OVERLAY_ID)?.remove()
+}
+
+/**
+ * Affiche une erreur de compilation par-dessus la page.
+ * @param {string} message
+ * @param {string | undefined} file
+ */
+function showOverlay(message, file) {
+  clearOverlay()
+  const overlay = document.createElement('div')
+  overlay.id = OVERLAY_ID
+  overlay.setAttribute('role', 'alert')
+  overlay.style.cssText = [
+    'position:fixed',
+    'inset:0',
+    'z-index:2147483647',
+    'padding:2rem',
+    'overflow:auto',
+    'background:rgba(10,10,16,0.94)',
+    'color:#ffd7d7',
+    'font:14px/1.6 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace',
+    'white-space:pre-wrap',
+  ].join(';')
+
+  const title = document.createElement('div')
+  title.textContent = file ? 'Erreur de compilation — ' + file : 'Erreur de compilation'
+  title.style.cssText = 'font-weight:700;margin-bottom:1rem;color:#ff9d9d'
+
+  const body = document.createElement('div')
+  body.textContent = message
+
+  const hint = document.createElement('div')
+  hint.textContent = 'Corrigez le fichier : cette surcouche disparaitra d elle-meme.'
+  hint.style.cssText = 'margin-top:1.5rem;opacity:0.6'
+
+  overlay.append(title, body, hint)
+  document.body.appendChild(overlay)
+}
+
+const source = new EventSource('__HMR_STREAM_PATH__')
+
+source.addEventListener('message', (event) => {
+  const payload = JSON.parse(event.data)
+
+  switch (payload.type) {
+    case 'connected':
+      console.log('[odoro] rechargement a chaud connecte')
+      break
+    case 'update':
+      clearOverlay()
+      for (const update of payload.updates) {
+        void applyUpdate(update.url, update.timestamp)
+      }
+      break
+    case 'full-reload':
+      location.reload()
+      break
+    case 'error':
+      showOverlay(payload.message, payload.file)
+      break
+    default:
+      break
+  }
+})
+
+source.addEventListener('error', () => {
+  // EventSource se reconnecte seul ; on ne signale que la perte prolongee.
+  if (source.readyState === EventSource.CLOSED) {
+    console.warn('[odoro] connexion de rechargement perdue')
+  }
+})
+`.replace("__HMR_STREAM_PATH__", HMR_STREAM_PATH);
+function hotPreamble(url) {
+  return `import { createHotContext as __odoroHot } from ${JSON.stringify(
+    HMR_CLIENT_PATH
+  )}
+import.meta.hot = __odoroHot(${JSON.stringify(url)})
+`;
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "static",
+  "await"
+]);
+function isCommonJsFile(file) {
+  if (file.endsWith(".mjs")) return false;
+  if (file.endsWith(".cjs")) return true;
+  let directory = dirname(file);
+  for (let depth = 0; depth < 20; depth += 1) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        return parsed.type !== "module";
+      } catch {
+        return true;
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return true;
+}
+function inspectDependency(specifier, root) {
+  const plain = { specifier, needsInterop: false, namedExports: [] };
+  const require2 = createRequire(join(root, "index.js"));
+  let resolved;
+  try {
+    resolved = require2.resolve(specifier);
+  } catch {
+    return plain;
+  }
+  if (!isCommonJsFile(resolved)) return plain;
+  let loaded;
+  try {
+    loaded = require2(specifier);
+  } catch {
+    return plain;
+  }
+  if (typeof loaded !== "object" && typeof loaded !== "function") return plain;
+  if (loaded === null) return plain;
+  const namedExports = Object.keys(loaded).filter(
+    (key) => key !== "default" && IDENTIFIER.test(key) && !RESERVED.has(key)
+  );
+  return { specifier, needsInterop: true, namedExports };
+}
+function renderInteropProxy(info2) {
+  const lines = [
+    `import cjs from ${JSON.stringify(info2.specifier)}`,
+    "export default cjs"
+  ];
+  if (info2.namedExports.length > 0) {
+    lines.push(`export const { ${info2.namedExports.join(", ")} } = cjs`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+var DEPS_PREFIX = "/@deps/";
+var INTERNAL_PREFIX = "/@odoro/";
+var STYLE_EXTENSIONS = [".css"];
+var ASSET_EXTENSIONS = [
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".mp4",
+  ".webm"
+];
+function depFileName(specifier) {
+  return `${specifier.replace(/^@/, "").split("/").join("_")}.js`;
+}
+function isBareSpecifier(specifier) {
+  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("\\") && !/^[a-zA-Z]:[\\/]/.test(specifier) && !specifier.startsWith("data:") && !specifier.startsWith("http:") && !specifier.startsWith("https:");
+}
+function hasExtension(path, extensions) {
+  const clean = path.split("?")[0] ?? path;
+  return extensions.some((extension) => clean.toLowerCase().endsWith(extension));
+}
+function fileToUrl(file, root) {
+  const relativePath = relative(root, file).split("\\").join("/");
+  if (!relativePath.startsWith("..")) return `/${relativePath}`;
+  return `/@fs/${file.split("\\").join("/").replace(/^\//, "")}`;
+}
+function urlToFile(url, root) {
+  const path = (url.split("?")[0] ?? url).split("#")[0] ?? url;
+  if (path.startsWith("/@fs/")) {
+    const absolute = path.slice("/@fs/".length);
+    return /^[a-zA-Z]:/.test(absolute) ? absolute : `/${absolute}`;
+  }
+  return resolve(root, `.${path}`);
+}
+function applyAlias(specifier, config) {
+  for (const [prefix, target] of Object.entries(config.alias)) {
+    if (specifier === prefix || specifier.startsWith(`${prefix}/`)) {
+      return resolve(
+        config.root,
+        target,
+        specifier.slice(prefix.length).replace(/^\//, "")
+      );
+    }
+  }
+  return specifier;
+}
+function externalizeImports(config, dependencies) {
+  return {
+    name: "odoro-externalize",
+    setup(builder) {
+      builder.onResolve({ filter: /.*/ }, async (args) => {
+        if (args.kind === "entry-point") return null;
+        if (args.pluginData?.resolving === true) {
+          return null;
+        }
+        if (args.path.startsWith(INTERNAL_PREFIX) || args.path.startsWith(DEPS_PREFIX)) {
+          return { path: args.path, external: true };
+        }
+        const aliased = applyAlias(args.path, config);
+        const isFileLike = hasExtension(aliased, STYLE_EXTENSIONS) || hasExtension(aliased, ASSET_EXTENSIONS);
+        if (isBareSpecifier(aliased) && !isFileLike) {
+          return { path: `${DEPS_PREFIX}${depFileName(aliased)}`, external: true };
+        }
+        const resolved = await builder.resolve(aliased, {
+          kind: "import-statement",
+          resolveDir: args.resolveDir,
+          importer: args.importer,
+          pluginData: { resolving: true }
+        });
+        if (resolved.errors.length > 0) {
+          return { path: args.path, external: true };
+        }
+        dependencies.add(resolved.path);
+        const url = fileToUrl(resolved.path, config.root);
+        return {
+          path: hasExtension(url, ASSET_EXTENSIONS) ? `${url}?import` : url,
+          external: true
+        };
+      });
+    }
+  };
+}
+async function transformModule(file, config, env) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const result = await build({
+    entryPoints: [file],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    sourcemap: "inline",
+    jsx: "automatic",
+    jsxDev: true,
+    logLevel: "silent",
+    absWorkingDir: config.root,
+    define: {
+      "import.meta.env": JSON.stringify(env),
+      "process.env.NODE_ENV": JSON.stringify("development"),
+      ...config.define
+    },
+    plugins: [externalizeImports(config, dependencies)]
+  });
+  const code = result.outputFiles[0]?.text;
+  if (code === void 0) {
+    throw new Error(`[odoro] La compilation de "${file}" n'a produit aucun code.`);
+  }
+  return { code, dependencies: [...dependencies] };
+}
+function wrapStyle(url, css) {
+  return `const id = ${JSON.stringify(`odoro-style:${url}`)}
+const css = ${JSON.stringify(css)}
+
+let element = document.querySelector(\`style[data-odoro-id="\${id}"]\`)
+if (element === null) {
+  element = document.createElement('style')
+  element.setAttribute('data-odoro-id', id)
+  document.head.appendChild(element)
+}
+element.textContent = css
+
+import.meta.hot?.accept()
+import.meta.hot?.dispose(() => {
+  // La feuille suivante recreera l'element : le retirer evite d'empiler les
+  // regles mortes a chaque rechargement.
+  element?.remove()
+})
+`;
+}
+function wrapAsset(url) {
+  return `export default ${JSON.stringify(url)}
+`;
+}
+
+// src/dev/deps.ts
+var MANIFEST = "manifest.json";
+function collectBareImports(config, found) {
+  return {
+    name: "odoro-scan-deps",
+    setup(builder) {
+      builder.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point") return null;
+        const aliased = applyAlias(args.path, config);
+        if (hasExtension(aliased, STYLE_EXTENSIONS) || hasExtension(aliased, ASSET_EXTENSIONS)) {
+          return { path: aliased, external: true };
+        }
+        if (!isBareSpecifier(aliased)) return null;
+        found.add(aliased);
+        return { path: aliased, external: true };
+      });
+    }
+  };
+}
+async function scanDependencies(config, entries) {
+  const found = /* @__PURE__ */ new Set();
+  const existing = entries.filter((entry) => existsSync(entry));
+  if (existing.length === 0) return [];
+  await build({
+    entryPoints: [...existing],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "browser",
+    logLevel: "silent",
+    absWorkingDir: config.root,
+    jsx: "automatic",
+    // Le serveur compile en JSX de developpement : sans ce reglage, le
+    // parcours chercherait `react/jsx-runtime` la ou le navigateur demandera
+    // `react/jsx-dev-runtime`, et la dependance manquerait a l'appel.
+    jsxDev: true,
+    plugins: [collectBareImports(config, found)]
+  });
+  return [...found].sort();
+}
+async function optimizeDeps(config, specifiers, force = false) {
+  const directory = join(config.root, "node_modules", ".odoro", "deps");
+  const sorted = [...specifiers].sort();
+  const hash = createHash("sha256").update(JSON.stringify(sorted)).update(await lockfileFingerprint(config.root)).update(entriesFingerprint(config.root, sorted)).update(engineVersion()).digest("hex").slice(0, 16);
+  const manifestPath = join(directory, MANIFEST);
+  if (!force && existsSync(manifestPath)) {
+    const previous = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (previous.hash === hash) {
+      return { directory, specifiers: previous.specifiers, rebuilt: false };
+    }
+  }
+  await rm(directory, { recursive: true, force: true });
+  await mkdir(directory, { recursive: true });
+  if (sorted.length > 0) {
+    const proxies = join(directory, "proxies");
+    await mkdir(proxies, { recursive: true });
+    const entryPoints = [];
+    for (const specifier of sorted) {
+      const out = depFileName(specifier).replace(/\.js$/, "");
+      const info2 = inspectDependency(specifier, config.root);
+      if (!info2.needsInterop) {
+        entryPoints.push({ in: specifier, out });
+        continue;
+      }
+      const proxy = join(proxies, `${out}.js`);
+      await writeFile(proxy, renderInteropProxy(info2), "utf8");
+      entryPoints.push({ in: proxy, out });
+    }
+    await build({
+      // Les noms de sortie sont imposes : un specificateur a sous-chemin
+      // produirait sinon une arborescence, et deux paquets differents
+      // pourraient se disputer le meme nom de fichier.
+      entryPoints,
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      splitting: true,
+      outdir: directory,
+      absWorkingDir: config.root,
+      logLevel: "silent",
+      define: { "process.env.NODE_ENV": JSON.stringify("development") },
+      loader: { ".woff": "file", ".woff2": "file", ".svg": "dataurl" }
+    });
+    await rm(proxies, { recursive: true, force: true });
+  }
+  const manifest = { hash, specifiers: sorted };
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  return { directory, specifiers: sorted, rebuilt: true };
+}
+var cachedVersion;
+function engineVersion() {
+  if (cachedVersion !== void 0) return cachedVersion;
+  let directory = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed.name === "odoro") {
+          cachedVersion = parsed.version ?? "inconnue";
+          return cachedVersion;
+        }
+      } catch {
+        break;
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  cachedVersion = "inconnue";
+  return cachedVersion;
+}
+function entriesFingerprint(root, specifiers) {
+  const resolver = createRequire(pathToFileURL(join(root, "package.json")));
+  const parts = [];
+  for (const name of packageNames(specifiers)) {
+    parts.push(`${name}:${packageFingerprint(name, resolver)}`);
+  }
+  return parts.join("|");
+}
+function packageNames(specifiers) {
+  const names = /* @__PURE__ */ new Set();
+  for (const specifier of specifiers) {
+    const segments = specifier.split("/");
+    names.add(
+      specifier.startsWith("@") && segments.length > 1 ? `${segments[0] ?? ""}/${segments[1] ?? ""}` : segments[0] ?? specifier
+    );
+  }
+  return [...names].sort();
+}
+function packageFingerprint(name, resolver) {
+  let manifestPath;
+  try {
+    manifestPath = resolver.resolve(`${name}/package.json`);
+  } catch {
+    return "introuvable";
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return "illisible";
+  }
+  const directory = dirname(manifestPath);
+  const targets = /* @__PURE__ */ new Set();
+  const collect = (node) => {
+    if (typeof node === "string") {
+      if (node.startsWith("./")) targets.add(node);
+      return;
+    }
+    if (typeof node === "object" && node !== null) {
+      for (const value of Object.values(node)) collect(value);
+    }
+  };
+  collect(manifest.exports);
+  collect(manifest.main);
+  collect(manifest.module);
+  const parts = [String(statSafe(manifestPath))];
+  for (const target of [...targets].sort()) {
+    parts.push(`${target}:${String(statSafe(join(directory, target)))}`);
+  }
+  return parts.join(",");
+}
+function statSafe(path) {
+  try {
+    const stats = statSync(path);
+    return `${String(stats.mtimeMs)}-${String(stats.size)}`;
+  } catch {
+    return "0";
+  }
+}
+async function lockfileFingerprint(root) {
+  for (const name of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"]) {
+    const file = join(root, name);
+    if (!existsSync(file)) continue;
+    return createHash("sha256").update(await readFile(file)).digest("hex");
+  }
+  return "sans-verrou";
+}
+
+// src/dev/graph.ts
+function detectSelfAccepting(source) {
+  return /import\s*\.\s*meta\s*\.\s*hot\s*\??\s*\.\s*accept\s*\(/.test(source);
+}
+var ModuleGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  /** Recupere un module, ou le cree s'il est inconnu. */
+  ensure(file, url) {
+    const existing = this.nodes.get(file);
+    if (existing !== void 0) return existing;
+    const node = {
+      file,
+      url,
+      importers: /* @__PURE__ */ new Set(),
+      imported: /* @__PURE__ */ new Set(),
+      selfAccepting: false,
+      code: void 0,
+      timestamp: Date.now()
+    };
+    this.nodes.set(file, node);
+    return node;
+  }
+  /** Recupere un module deja connu. */
+  get(file) {
+    return this.nodes.get(file);
+  }
+  /** Nombre de modules connus. */
+  get size() {
+    return this.nodes.size;
+  }
+  /**
+   * Remplace la liste des dependances d'un module, en tenant a jour les
+   * relations inverses.
+   */
+  setDependencies(file, dependencies) {
+    const node = this.nodes.get(file);
+    if (node === void 0) return;
+    for (const previous of node.imported) {
+      if (!dependencies.includes(previous)) {
+        this.nodes.get(previous)?.importers.delete(file);
+      }
+    }
+    node.imported.clear();
+    for (const dependency of dependencies) {
+      node.imported.add(dependency);
+      const target = this.nodes.get(dependency);
+      if (target !== void 0) target.importers.add(file);
+    }
+  }
+  /**
+   * Invalide un module et remonte la chaine de ses importateurs jusqu'a
+   * trouver, sur chaque branche, un module qui accepte les mises a jour.
+   *
+   * @returns Les modules a recharger cote client. Un tableau vide signifie
+   *   qu'aucune frontiere n'accepte la mise a jour : il faut recharger la page.
+   *
+   * @example
+   * const boundaries = graph.invalidate('/projet/src/App.css')
+   */
+  invalidate(file) {
+    const boundaries = [];
+    const seen = /* @__PURE__ */ new Set();
+    const timestamp = Date.now();
+    const walk = (current) => {
+      if (seen.has(current)) return true;
+      seen.add(current);
+      const node = this.nodes.get(current);
+      if (node === void 0) return false;
+      node.code = void 0;
+      node.timestamp = timestamp;
+      if (node.selfAccepting) {
+        boundaries.push(node);
+        return true;
+      }
+      if (node.importers.size === 0) return false;
+      let handled = true;
+      for (const importer of node.importers) {
+        if (!walk(importer)) handled = false;
+      }
+      return handled;
+    };
+    return walk(file) ? boundaries : [];
+  }
+  /** Oublie tous les modules. */
+  clear() {
+    this.nodes.clear();
+  }
+};
+var REFRESH_RUNTIME_PATH = "/@odoro/react-refresh";
+var CANDIDATE_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js", ".mjs"];
+function isRefreshCandidate(file) {
+  const normalized = file.split("\\").join("/");
+  if (normalized.includes("/node_modules/")) return false;
+  return CANDIDATE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+}
+async function applyReactRefresh(code, file) {
+  const result = await transformAsync(code, {
+    filename: file,
+    babelrc: false,
+    configFile: false,
+    // La carte de source produite par la compilation precedente est reprise et
+    // fusionnee : sans cela, les numeros de ligne du debogueur designeraient le
+    // code instrumente plutot que la source.
+    inputSourceMap: true,
+    sourceMaps: "inline",
+    // `skipEnvCheck` leve un garde-fou destine aux configurations globales,
+    // qui refuse la transformation hors de NODE_ENV=development. Ici c'est le
+    // point d'application qui garantit la regle : cette fonction n'est appelee
+    // que par le serveur de developpement, jamais par la compilation de
+    // production. Sans cela, un `NODE_ENV=production odoro dev` — ou une suite
+    // de tests — echouerait au lieu de simplement instrumenter.
+    plugins: [[reactRefreshPlugin, { skipEnvCheck: true }]],
+    parserOpts: { sourceType: "module" }
+  });
+  return result?.code ?? code;
+}
+function hasRegisteredComponent(code) {
+  return code.includes("$RefreshReg$(");
+}
+function refreshPreamble(id) {
+  return `import * as __odoroRefresh from ${JSON.stringify(REFRESH_RUNTIME_PATH)}
+const __odoroPrevReg = window.$RefreshReg$
+const __odoroPrevSig = window.$RefreshSig$
+window.$RefreshReg$ = (type, name) => __odoroRefresh.register(type, ${JSON.stringify(id)} + ' ' + name)
+window.$RefreshSig$ = __odoroRefresh.createSignature
+`;
+}
+function refreshEpilogue(id) {
+  return `
+window.$RefreshReg$ = __odoroPrevReg
+window.$RefreshSig$ = __odoroPrevSig
+
+void import(import.meta.url).then((__odoroCurrent) => {
+  __odoroRefresh.registerExports(${JSON.stringify(id)}, __odoroCurrent)
+  import.meta.hot?.accept((__odoroNext) => {
+    if (!__odoroNext) return
+    const refus = __odoroRefresh.checkBoundary(__odoroCurrent, __odoroNext)
+    if (refus !== null) import.meta.hot.invalidate(refus)
+    else {
+      __odoroRefresh.registerExports(${JSON.stringify(id)}, __odoroNext)
+      __odoroRefresh.enqueueUpdate()
+    }
+  })
+})
+`;
+}
+var REFRESH_RUNTIME_SOURCE = `import runtime from 'react-refresh/runtime'
+
+// Le crochet doit etre installe **avant** que React ne soit charge : c'est par
+// lui que React signale les composants qu'il rend.
+runtime.injectIntoGlobalHook(window)
+
+// Valeurs neutres : un module non instrumente doit pouvoir s'evaluer sans que
+// ces fonctions existent vraiment.
+window.$RefreshReg$ = () => {}
+window.$RefreshSig$ = () => (type) => type
+
+export const register = runtime.register
+export const createSignature = runtime.createSignatureFunctionForTransform
+
+/**
+ * Enregistre les exports d'un module qui ressemblent a des composants.
+ *
+ * L'enregistrement par nom d'export complete celui pose dans le corps du
+ * module : un composant re-exporte depuis un autre fichier n'y apparaitrait
+ * pas.
+ */
+export function registerExports(id, exports) {
+  for (const key of Object.keys(exports)) {
+    const value = exports[key]
+    if (runtime.isLikelyComponentType(value)) {
+      runtime.register(value, id + ' export ' + key)
+    }
+  }
+}
+
+/**
+ * Verifie qu'un module peut etre remplace a chaud.
+ *
+ * @returns null si le remplacement est sur, sinon la raison du refus.
+ */
+export function checkBoundary(previous, next) {
+  const before = Object.keys(previous)
+  const after = Object.keys(next)
+
+  if (after.length === 0) return 'le module n exporte plus rien'
+
+  for (const key of after) {
+    if (!before.includes(key)) return 'nouvel export : ' + key
+  }
+  for (const key of before) {
+    if (!after.includes(key)) return 'export retire : ' + key
+  }
+
+  for (const key of after) {
+    const value = next[key]
+    if (runtime.isLikelyComponentType(value)) continue
+    // Un export qui n'est pas un composant ne peut etre conserve que s'il n'a
+    // pas change : sinon ses consommateurs garderaient l'ancienne valeur.
+    if (previous[key] !== value) return 'export non-composant modifie : ' + key
+  }
+
+  return null
+}
+
+let planned
+const DEBOUNCE = 16
+
+/** Regroupe les mises a jour d'une meme salve en un seul rafraichissement. */
+export function enqueueUpdate() {
+  clearTimeout(planned)
+  planned = setTimeout(() => {
+    planned = undefined
+    runtime.performReactRefresh()
+  }, DEBOUNCE)
+}
+`;
+var REFRESH_HTML_TAG = `<script type="module" src="${REFRESH_RUNTIME_PATH}"></script>`;
+var cachedRuntime;
+async function bundleRefreshRuntime() {
+  if (cachedRuntime !== void 0) return cachedRuntime;
+  const result = await build({
+    stdin: {
+      contents: REFRESH_RUNTIME_SOURCE,
+      resolveDir: dirname(fileURLToPath(import.meta.url)),
+      loader: "js",
+      sourcefile: "odoro-react-refresh.js"
+    },
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    logLevel: "silent",
+    define: { "process.env.NODE_ENV": JSON.stringify("development") }
+  });
+  cachedRuntime = result.outputFiles[0]?.text ?? "";
+  return cachedRuntime;
+}
+
+// src/dev/server.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".txt": "text/plain; charset=utf-8"
+};
+var SCRIPT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+function cleanUrl(url) {
+  return (url.split("?")[0] ?? url).split("#")[0] ?? url;
+}
+function buildEnv(config) {
+  const env = {
+    MODE: "development",
+    DEV: true,
+    PROD: false,
+    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 extractEntries(html, root) {
+  const entries = [];
+  for (const match of html.matchAll(
+    /<script[^>]*type=["']module["'][^>]*src=["']([^"']+)["']/gi
+  )) {
+    const source = match[1];
+    if (source === void 0 || /^https?:/.test(source)) continue;
+    entries.push(resolve(root, source.replace(/^\//, "")));
+  }
+  return entries;
+}
+function injectClient(html) {
+  const tags = [
+    REFRESH_HTML_TAG,
+    `<script type="module" src="${HMR_CLIENT_PATH}"></script>`
+  ].join("\n    ");
+  if (html.includes("</head>")) return html.replace("</head>", `  ${tags}
+</head>`);
+  return `${tags}
+${html}`;
+}
+async function startDevServer(config) {
+  const started = Date.now();
+  const graph = new ModuleGraph();
+  const env = buildEnv(config);
+  const clients = /* @__PURE__ */ new Set();
+  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 refreshRuntime = await bundleRefreshRuntime();
+  const entries = extractEntries(await readFile(indexFile, "utf8"), config.root);
+  const specifiers = await scanDependencies(config, entries);
+  const deps = await optimizeDeps(config, specifiers);
+  if (deps.rebuilt && specifiers.length > 0) {
+    info(`${specifiers.length} dependances pre-compilees`);
+  }
+  const broadcast = (message) => {
+    const payload = `data: ${JSON.stringify(message)}
+
+`;
+    for (const client of clients) client.write(payload);
+  };
+  const send = (response, body, type, status = 200) => {
+    response.writeHead(status, {
+      "Content-Type": type,
+      "Cache-Control": "no-cache"
+    });
+    response.end(body);
+  };
+  const serveScript = async (response, file) => {
+    const url2 = fileToUrl(file, config.root);
+    const node = graph.ensure(file, url2);
+    if (node.code === void 0) {
+      const source = await readFile(file, "utf8");
+      node.selfAccepting = detectSelfAccepting(source);
+      const { code, dependencies } = await transformModule(file, config, env);
+      graph.setDependencies(file, dependencies);
+      for (const dependency of dependencies) {
+        graph.ensure(dependency, fileToUrl(dependency, config.root)).importers.add(file);
+      }
+      let body = code;
+      if (isRefreshCandidate(file)) {
+        const instrumented = await applyReactRefresh(code, file);
+        if (hasRegisteredComponent(instrumented)) {
+          body = refreshPreamble(url2) + instrumented + refreshEpilogue(url2);
+          node.selfAccepting = true;
+        }
+      }
+      node.code = hotPreamble(url2) + body;
+    }
+    send(response, node.code, MIME[".js"]);
+  };
+  const serveStyle = async (response, file, direct) => {
+    const css = await readFile(file, "utf8");
+    if (direct) {
+      send(response, css, MIME[".css"]);
+      return;
+    }
+    const url2 = fileToUrl(file, config.root);
+    const node = graph.ensure(file, url2);
+    node.selfAccepting = true;
+    node.code = hotPreamble(url2) + wrapStyle(url2, css);
+    send(response, node.code, MIME[".js"]);
+  };
+  const serveFile = (response, file) => {
+    const type = MIME[extname(file).toLowerCase()] ?? "application/octet-stream";
+    response.writeHead(200, { "Content-Type": type, "Cache-Control": "no-cache" });
+    createReadStream(file).pipe(response);
+  };
+  const serveHtml = async (response) => {
+    const html = await readFile(indexFile, "utf8");
+    send(response, injectClient(html), MIME[".html"]);
+  };
+  const forward = (incoming, response, target) => {
+    const url2 = new URL(incoming.url ?? "/", target);
+    const proxied = request(
+      {
+        protocol: url2.protocol,
+        hostname: url2.hostname,
+        port: url2.port,
+        path: `${url2.pathname}${url2.search}`,
+        method: incoming.method,
+        headers: { ...incoming.headers, host: url2.host }
+      },
+      (upstream) => {
+        response.writeHead(upstream.statusCode ?? 502, upstream.headers);
+        upstream.pipe(response);
+      }
+    );
+    proxied.on("error", (cause) => {
+      warn(`proxy indisponible : ${target}`);
+      send(response, `Proxy indisponible : ${String(cause)}`, "text/plain", 502);
+    });
+    incoming.pipe(proxied);
+  };
+  const server = createServer((incoming, response) => {
+    void (async () => {
+      const url2 = incoming.url ?? "/";
+      const path = cleanUrl(url2);
+      try {
+        for (const [prefix, target] of Object.entries(config.server.proxy)) {
+          if (path.startsWith(prefix)) {
+            forward(incoming, response, target);
+            return;
+          }
+        }
+        if (path === REFRESH_RUNTIME_PATH) {
+          send(response, refreshRuntime, MIME[".js"] ?? "text/javascript");
+          return;
+        }
+        if (path === HMR_CLIENT_PATH) {
+          send(response, HMR_CLIENT_SOURCE, MIME[".js"] ?? "text/javascript");
+          return;
+        }
+        if (path === HMR_STREAM_PATH) {
+          response.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          response.write(`data: ${JSON.stringify({ type: "connected" })}
+
+`);
+          clients.add(response);
+          incoming.on("close", () => clients.delete(response));
+          return;
+        }
+        if (path.startsWith(DEPS_PREFIX)) {
+          const specifier = path.slice(DEPS_PREFIX.length);
+          const last = specifier.split("/").pop() ?? specifier;
+          const name = last.endsWith(".js") ? last : depFileName(last);
+          const file2 = join(deps.directory, name);
+          if (existsSync(file2)) {
+            serveFile(response, file2);
+            return;
+          }
+          send(
+            response,
+            `throw new Error(${JSON.stringify(
+              `[odoro] Dependance non pre-compilee : "${specifier}". Relancez le serveur.`
+            )})`,
+            MIME[".js"] ?? "text/javascript"
+          );
+          return;
+        }
+        if (path === "/" || path === "/index.html") {
+          await serveHtml(response);
+          return;
+        }
+        if (path.startsWith(INTERNAL_PREFIX)) {
+          send(response, "Introuvable", "text/plain", 404);
+          return;
+        }
+        const file = urlToFile(path, config.root);
+        if (existsSync(file) && statSync(file).isFile()) {
+          if (hasExtension(path, STYLE_EXTENSIONS)) {
+            await serveStyle(response, file, url2.includes("?direct"));
+            return;
+          }
+          if (hasExtension(path, ASSET_EXTENSIONS)) {
+            if (url2.includes("?import")) {
+              send(response, wrapAsset(path), MIME[".js"] ?? "text/javascript");
+            } else {
+              serveFile(response, file);
+            }
+            return;
+          }
+          if (hasExtension(path, SCRIPT_EXTENSIONS)) {
+            await serveScript(response, file);
+            return;
+          }
+          serveFile(response, file);
+          return;
+        }
+        const publicFile = join(config.publicDir, path.replace(/^\//, ""));
+        if (existsSync(publicFile) && statSync(publicFile).isFile()) {
+          serveFile(response, publicFile);
+          return;
+        }
+        if (!extname(path)) {
+          await serveHtml(response);
+          return;
+        }
+        send(response, "Introuvable", "text/plain", 404);
+      } catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        error(`echec du traitement de ${path}`, cause);
+        broadcast({ type: "error", message, file: path });
+        send(response, `Erreur : ${message}`, "text/plain", 500);
+      }
+    })();
+  });
+  let pending;
+  const changed = /* @__PURE__ */ new Set();
+  const watcher = watch(config.root, { recursive: true }, (_event, filename) => {
+    if (filename === null) return;
+    const normalized = filename.split("\\").join("/");
+    if (normalized.includes("node_modules/") || normalized.startsWith(".git/") || normalized.startsWith("dist/")) {
+      return;
+    }
+    changed.add(join(config.root, filename));
+    clearTimeout(pending);
+    pending = setTimeout(() => {
+      const files = [...changed];
+      changed.clear();
+      const updates = [];
+      let reload = false;
+      for (const file of files) {
+        if (file === indexFile) {
+          reload = true;
+          continue;
+        }
+        const boundaries = graph.invalidate(file);
+        if (boundaries.length === 0) {
+          if (graph.get(file) !== void 0) reload = true;
+          continue;
+        }
+        for (const boundary of boundaries) {
+          updates.push({ url: boundary.url, timestamp: boundary.timestamp });
+        }
+      }
+      if (reload) {
+        info("rechargement de la page");
+        broadcast({ type: "full-reload" });
+      } else if (updates.length > 0) {
+        info(
+          `mise a jour a chaud : ${updates.map((update) => update.url).join(", ")}`
+        );
+        broadcast({ type: "update", updates });
+      }
+    }, 40);
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(config.server.port, config.server.host, resolveListen);
+  });
+  const url = `http://${config.server.host}:${config.server.port}${config.base}`;
+  success(`pret en ${duration(Date.now() - started)}`);
+  info(`  ${colors.cyan(url)}`);
+  return {
+    url,
+    async close() {
+      watcher.close();
+      clearTimeout(pending);
+      for (const client of clients) client.end();
+      clients.clear();
+      graph.clear();
+      await new Promise((done) => server.close(() => done()));
+    }
+  };
+}
+
+export { ModuleGraph, applyAlias, depFileName, detectSelfAccepting, extractEntries, injectClient, isBareSpecifier, optimizeDeps, scanDependencies, startDevServer };