odoro 1.0.8 → 2.0.0

package/dist/chunk-WWTDEV4Y.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { existsSync, statSync, readdirSync } from 'fs';
+import { resolve, dirname, extname, relative, join } from 'path';
+import { readFile } from 'fs/promises';
+import { build } from 'esbuild';
+
+// src/plugins.ts
+async function transformWith(plugins, code, context) {
+  let current = code;
+  let touched = false;
+  for (const plugin of plugins) {
+    if (plugin.transform === void 0) continue;
+    try {
+      const rendered = await plugin.transform(current, context);
+      if (rendered === null || rendered === void 0) continue;
+      current = rendered;
+      touched = true;
+    } catch (cause) {
+      throw new Error(
+        `[odoro] Plugin "${plugin.name}" failed on ${context.id}: ` + (cause instanceof Error ? cause.message : String(cause)),
+        { cause }
+      );
+    }
+  }
+  return touched ? current : void 0;
+}
+async function transformHtmlWith(plugins, html, context) {
+  let current = html;
+  for (const plugin of plugins) {
+    if (plugin.transformIndexHtml === void 0) continue;
+    try {
+      current = await plugin.transformIndexHtml(current, context);
+    } catch (cause) {
+      throw new Error(
+        `[odoro] Plugin "${plugin.name}" failed on the document: ` + (cause instanceof Error ? cause.message : String(cause)),
+        { cause }
+      );
+    }
+  }
+  return current;
+}
+function esbuildPluginsFrom(plugins) {
+  return plugins.flatMap((plugin) => plugin.esbuild ?? []);
+}
+
+// src/shared/listen.ts
+var ATTEMPTS = 10;
+async function listen(server, port, host, attempts = ATTEMPTS) {
+  for (let offset = 0; offset < attempts; offset += 1) {
+    const candidate = port + offset;
+    const taken = await new Promise((resolve3, reject) => {
+      const onError = (cause) => {
+        server.removeListener("listening", onListening);
+        if (cause.code === "EADDRINUSE") {
+          resolve3(true);
+          return;
+        }
+        reject(cause);
+      };
+      const onListening = () => {
+        server.removeListener("error", onError);
+        resolve3(false);
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(candidate, host);
+    });
+    if (!taken) {
+      const address = server.address();
+      const obtained = typeof address === "object" && address !== null ? address.port : candidate;
+      return offset === 0 ? { port: obtained } : { port: obtained, requested: port };
+    }
+  }
+  throw new Error(
+    `[odoro] No free port between ${String(port)} and ${String(port + attempts - 1)}.`
+  );
+}
+function openBrowser(url) {
+  const [command, ...arguments_] = process.platform === "win32" ? (
+    // `start` is a built-in command: it goes through the interpreter. The
+    // empty title that follows is mandatory, otherwise a quoted address
+    // would be taken for the window title.
+    ["cmd", "/c", "start", '""', url.replace(/&/g, "^&")]
+  ) : process.platform === "darwin" ? ["open", url] : ["xdg-open", url];
+  if (command === void 0) return;
+  try {
+    const child = spawn(command, arguments_, { stdio: "ignore", detached: true });
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+
+// src/shared/suffixes.ts
+var MARKER = /\?(worker|raw|url)$/;
+function readSuffix(specifier) {
+  const found = MARKER.exec(specifier);
+  const suffix = found?.[1];
+  if (suffix === void 0) return void 0;
+  return {
+    suffix,
+    path: specifier.slice(0, specifier.length - suffix.length - 1)
+  };
+}
+function workerModule(url) {
+  return `const source = ${JSON.stringify(url)}
+
+export default class OdoroWorker extends Worker {
+  constructor(options) {
+    super(source, { type: 'module', ...options })
+  }
+}
+`;
+}
+function textModule(content) {
+  return `export default ${JSON.stringify(content)}
+`;
+}
+function urlModule(url) {
+  return `export default ${JSON.stringify(url)}
+`;
+}
+var IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".odoro"]);
+var SPECIALS = /[.*+?^${}()|[\]\\]/g;
+function toRegex(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const letter = pattern[index];
+    if (letter === void 0) continue;
+    if (letter === "*") {
+      if (pattern[index + 1] === "*") {
+        if (pattern[index + 2] === "/") {
+          source += "(?:.*/)?";
+          index += 2;
+          continue;
+        }
+        source += ".*";
+        index += 1;
+        continue;
+      }
+      source += "[^/]*";
+      continue;
+    }
+    if (letter === "?") {
+      source += "[^/]";
+      continue;
+    }
+    if (letter === "{") {
+      const closing = pattern.indexOf("}", index);
+      if (closing !== -1) {
+        const choices = pattern.slice(index + 1, closing).split(",").map((part) => part.replace(SPECIALS, "\\$&"));
+        source += `(?:${choices.join("|")})`;
+        index = closing;
+        continue;
+      }
+    }
+    source += letter.replace(SPECIALS, "\\$&");
+  }
+  return new RegExp(`^${source}$`);
+}
+function groupEnd(code, opening) {
+  let depth = 0;
+  let quote;
+  for (let index = opening; index < code.length; index += 1) {
+    const letter = code[index];
+    if (quote !== void 0) {
+      if (letter === "\\") index += 1;
+      else if (letter === quote) quote = void 0;
+      continue;
+    }
+    if (letter === '"' || letter === "'" || letter === "`") {
+      quote = letter;
+      continue;
+    }
+    if (letter === "(") depth += 1;
+    else if (letter === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function stringsIn(fragment) {
+  const rendered = [];
+  for (const found of fragment.matchAll(/(['"`])((?:\\.|(?!\1).)*)\1/g)) {
+    const value = found[2];
+    if (value !== void 0) rendered.push(value);
+  }
+  return rendered;
+}
+function patternsIn(code) {
+  const patterns = [];
+  for (const found of code.matchAll(/import\.meta\.glob\s*\(/g)) {
+    const start = found.index;
+    const opening = start + found[0].length - 1;
+    const end = groupEnd(code, opening);
+    if (end === -1) continue;
+    const arguments_ = code.slice(opening + 1, end);
+    const brace = arguments_.indexOf("{");
+    const cut = brace === -1 ? -1 : arguments_.slice(0, brace).lastIndexOf(",");
+    const first = cut === -1 ? arguments_ : arguments_.slice(0, cut);
+    const second = cut === -1 ? "" : arguments_.slice(cut + 1);
+    const all = stringsIn(first);
+    if (all.length === 0) continue;
+    patterns.push({
+      start,
+      end: end + 1,
+      included: all.filter((pattern) => !pattern.startsWith("!")),
+      excluded: all.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1)),
+      options: {
+        eager: /["']?eager["']?\s*:\s*true/.test(second),
+        named: /["']?import["']?\s*:\s*["']([^"']+)["']/.exec(second)?.[1]
+      }
+    });
+  }
+  return patterns;
+}
+function fixedRootOf(pattern) {
+  const fixed = [];
+  for (const segment of pattern.split("/")) {
+    if (/[*?{}[\]]/.test(segment)) break;
+    fixed.push(segment);
+  }
+  return fixed.join("/") || ".";
+}
+function filesUnder(directory) {
+  if (!existsSync(directory) || !statSync(directory).isDirectory()) return [];
+  const rendered = [];
+  const stack = [directory];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) continue;
+    for (const entry of readdirSync(current)) {
+      if (IGNORED.has(entry) || entry.startsWith(".")) continue;
+      const path = join(current, entry);
+      if (statSync(path).isDirectory()) stack.push(path);
+      else rendered.push(path);
+    }
+  }
+  return rendered;
+}
+function toUrlPath(path) {
+  return path.split("\\").join("/");
+}
+function resolvePattern(pattern, file, projectRoot) {
+  const sourceDirectory = dirname(file);
+  const found = /* @__PURE__ */ new Set();
+  for (const included of pattern.included) {
+    const absolute = included.startsWith("/");
+    const base = absolute ? join(projectRoot, fixedRootOf(included.slice(1))) : resolve(sourceDirectory, fixedRootOf(included));
+    const regex = toRegex(included);
+    for (const path of filesUnder(base)) {
+      const relativePath = absolute ? `/${toUrlPath(relative(projectRoot, path))}` : toUrlPath(relative(sourceDirectory, path)).replace(/^(?!\.\.\/)/, "./");
+      if (!regex.test(relativePath)) continue;
+      if (pattern.excluded.some((excluded) => toRegex(excluded).test(relativePath)))
+        continue;
+      if (path === resolve(file)) continue;
+      found.add(relativePath);
+    }
+  }
+  return [...found].sort();
+}
+function hasGlob(code) {
+  return code.includes("import.meta.glob");
+}
+function transformGlob(code, file, projectRoot) {
+  if (!hasGlob(code)) return void 0;
+  const patterns = patternsIn(code);
+  if (patterns.length === 0) return void 0;
+  const prelude = [];
+  const files = [];
+  let rendered = "";
+  let cursor = 0;
+  let counter = 0;
+  for (const pattern of patterns) {
+    const entries = [];
+    for (const path of resolvePattern(pattern, file, projectRoot)) {
+      files.push(resolve(dirname(file), path));
+      const key = JSON.stringify(path);
+      const target = JSON.stringify(path);
+      if (pattern.options.eager) {
+        const alias = `__odoro_glob_${String(counter)}`;
+        counter += 1;
+        prelude.push(`import * as ${alias} from ${target}`);
+        entries.push(
+          `${key}: ${pattern.options.named === void 0 ? alias : `${alias}[${JSON.stringify(pattern.options.named)}]`}`
+        );
+        continue;
+      }
+      const importation = `import(${target})`;
+      entries.push(
+        `${key}: ${pattern.options.named === void 0 ? `() => ${importation}` : `() => ${importation}.then((m) => m[${JSON.stringify(pattern.options.named)}])`}`
+      );
+    }
+    rendered += code.slice(cursor, pattern.start);
+    rendered += entries.length === 0 ? "{}" : `{${entries.join(", ")}}`;
+    cursor = pattern.end;
+  }
+  rendered += code.slice(cursor);
+  return {
+    code: prelude.length === 0 ? rendered : `${prelude.join("\n")}
+${rendered}`,
+    files
+  };
+}
+var LOADERS = {
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".jsx": "jsx",
+  ".mjs": "js",
+  ".cjs": "js"
+};
+function sourcePlugin(options) {
+  const transforms = options.plugins.some((plugin) => plugin.transform !== void 0);
+  return {
+    name: "odoro-source",
+    setup(builder) {
+      builder.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
+        if (args.path.includes("node_modules")) return null;
+        const source = await readFile(args.path, "utf8");
+        let code = source;
+        if (hasGlob(code)) {
+          const resolved = transformGlob(code, args.path, options.root);
+          if (resolved !== void 0) {
+            code = resolved.code;
+            for (const file of resolved.files) options.onMatch?.(file);
+          }
+        }
+        if (transforms) {
+          const rendered = await transformWith(options.plugins, code, {
+            id: args.path,
+            dev: options.dev,
+            ssr: options.ssr ?? false
+          });
+          if (rendered !== void 0) code = rendered;
+        }
+        if (code === source) return null;
+        return { contents: code, loader: LOADERS[extname(args.path).toLowerCase()] };
+      });
+    }
+  };
+}
+var DEPS_PREFIX = "/@deps/";
+var INTERNAL_PREFIX = "/@odoro/";
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+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 suffixed = readSuffix(args.path);
+        if (suffixed !== void 0) {
+          const target = await builder.resolve(applyAlias(suffixed.path, config), {
+            kind: "import-statement",
+            resolveDir: args.resolveDir,
+            importer: args.importer,
+            pluginData: { resolving: true }
+          });
+          if (target.errors.length === 0) {
+            dependencies.add(target.path);
+            return {
+              path: `${fileToUrl(target.path, config.root)}?${suffixed.suffix}`,
+              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 onMatch = (matched) => {
+    dependencies.add(matched);
+  };
+  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),
+      sourcePlugin({
+        root: config.root,
+        plugins: config.plugins,
+        dev: true,
+        onMatch
+      }),
+      ...esbuildPluginsFrom(config.plugins)
+    ]
+  });
+  const code = result.outputFiles[0]?.text;
+  if (code === void 0) {
+    throw new Error(`[odoro] The build of "${file}" produced no code.`);
+  }
+  return { code, dependencies: [...dependencies] };
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED = /* @__PURE__ */ new Set([
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+function wrapJson(json) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch {
+    return 'throw new SyntaxError("unreadable JSON")';
+  }
+  const lines = ["export default " + json.trim()];
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    for (const [key, content] of Object.entries(value)) {
+      if (!IDENTIFIER.test(key) || RESERVED.has(key)) continue;
+      lines.push("export const " + key + " = " + JSON.stringify(content));
+    }
+  }
+  return lines.join("\n");
+}
+var ASSET_DESTINATIONS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "image",
+  "font",
+  "audio",
+  "video",
+  "track",
+  "manifest",
+  "worker",
+  "sharedworker",
+  "serviceworker"
+]);
+function isAssetRequest(headers) {
+  const destination = headers["sec-fetch-dest"];
+  return typeof destination === "string" && ASSET_DESTINATIONS.has(destination);
+}
+function wantsStylesheet(headers, url) {
+  if (url.includes("?direct")) return true;
+  if (headers["sec-fetch-dest"] === "style") return true;
+  const accepted = headers["accept"];
+  return typeof accepted === "string" && accepted.includes("text/css");
+}
+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(() => {
+  // The next stylesheet will recreate the element: removing it avoids stacking
+  // dead rules on every reload.
+  element?.remove()
+})
+`;
+}
+function wrapAsset(url) {
+  return `export default ${JSON.stringify(url)}
+`;
+}
+
+export { ASSET_EXTENSIONS, DEPS_PREFIX, INTERNAL_PREFIX, SOURCE_EXTENSIONS, STYLE_EXTENSIONS, applyAlias, depFileName, esbuildPluginsFrom, fileToUrl, hasExtension, hasGlob, isAssetRequest, isBareSpecifier, listen, openBrowser, readSuffix, sourcePlugin, textModule, transformGlob, transformHtmlWith, transformModule, urlModule, urlToFile, wantsStylesheet, workerModule, wrapAsset, wrapJson, wrapStyle };

package/dist/cli.d.ts

@@ -1,26 +1,25 @@
 /**
- * Entree en ligne de commande du moteur Odoro.
+ * Command line entry of the Odoro engine.
  *
- * 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.
+ * The argument parsing is written by hand: it fits in forty lines, and the
+ * binary is downloaded on every `npm create odoro`, so its weight counts.
  *
  * @module
  */
-/** Arguments analyses. */
+/** Parsed arguments. */
 interface ParsedArgs {
-    /** Sous-commande demandee. */
+    /** Subcommand requested. */
     command: string;
-    /** Arguments positionnels restants. */
+    /** Remaining positional arguments. */
     positional: string[];
-    /** Options nommees. */
+    /** Named options. */
     flags: Record<string, string | boolean>;
 }
 /**
- * Analyse une ligne de commande.
+ * Parses a command line.
  *
- * Reconnait `--option`, `--option=valeur`, `--option valeur`, `--no-option`
- * et les alias courts `-h` et `-v`.
+ * Recognises `--option`, `--option=value`, `--option value`, `--no-option` and
+ * the short aliases `-h` and `-v`.
  *
  * @example
  * parseArgs(['create', 'site', '--template=react-ts', '--no-git'])
@@ -28,9 +27,9 @@ interface ParsedArgs {
  */
 declare function parseArgs(argv: readonly string[]): ParsedArgs;
 /**
- * Point d'entree du binaire.
+ * Entry point of the binary.
  *
- * @returns Le code de sortie du processus.
+ * @returns The exit code of the process.
  *
  * @example
  * const code = await run(['dev', '--port', '3000'])