odoro 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,73 @@
+# odoro
+
+The Odoro engine: a development server with hot reload, a production build, and
+the component registry client.
+
+```sh
+npm create odoro@latest
+```
+
+That single command scaffolds a project and installs everything below. This
+package is what it installs.
+
+## Commands
+
+| Command          | What it does                                              |
+| ---------------- | --------------------------------------------------------- |
+| `odoro dev`      | Development server with hot module replacement.            |
+| `odoro build`    | Production build into `dist/`.                             |
+| `odoro preview`  | Serves `dist/` the way a static host would.                |
+| `odoro create`   | Scaffolds a project — same thing as `npm create odoro`.    |
+| `odoro init`     | Writes `odoro.json` so `odoro add` knows where to write.   |
+| `odoro add <id>` | Copies a registry component into your project.             |
+| `odoro list`     | Prints the registry catalogue.                             |
+| `odoro diff`     | Compares what is installed with what the registry serves.  |
+| `odoro doctor`   | Checks that the project is in a fit state.                 |
+
+Run `odoro --help` for the full list, including the database commands.
+
+## Configuration
+
+```ts
+// odoro.config.ts
+import { defineConfig } from 'odoro'
+
+export default defineConfig({
+  alias: { '@': 'src' },
+  server: { port: 5180 },
+})
+```
+
+## The registry is not a dependency
+
+`odoro add text/count-up` **copies the source into your project**. The code is
+then yours: read it, change it, delete it. Nothing updates behind your back, and
+there is no package to keep in step.
+
+```sh
+odoro add text/count-up
+# + src/odoro/hooks/useInView.ts
+# + src/odoro/text/CountUp.tsx
+```
+
+Entries that need an npm package say so, and `odoro add` tells you which one is
+missing before you find out at build time.
+
+## Hot reload keeps your state
+
+Editing a component swaps its code without unmounting the tree: a counter's
+value, the text in a field, the open tab all survive the edit. A stylesheet is
+swapped without a reload.
+
+A module that exports something other than components reloads the page, and that
+is correct — nothing would let us propagate the change safely.
+
+## Links
+
+- Documentation — <https://odoro.dev/docs>
+- Component registry — <https://odoro.dev/docs/registry>
+- Source — <https://github.com/ODORO-CLI/OdoroKit>
+
+## Licence
+
+UNLICENSED. Copyright (c) BouBouw. See `LICENSE`.

package/dist/cli.js

@@ -131,7 +131,7 @@ function rootFrom(flags, positional) {
 async function run(argv) {
   const { command, positional, flags } = parseArgs(argv);
   if (flags["version"] === true) {
-    const manifest = await import('./package-6ADADETZ.js');
+    const manifest = await import('./package-VMTZDORI.js');
     console.log(manifest.default.version);
     return 0;
   }
@@ -142,7 +142,7 @@ async function run(argv) {
   switch (command) {
     case "create":
     case "new": {
-      const { createCommand } = await import('./create-IOFAPDBO.js');
+      const { createCommand } = await import('./create-GD6O2TPL.js');
       const options = {};
       if (positional[0] !== void 0) options.name = positional[0];
       if (typeof flags["template"] === "string") options.template = flags["template"];
@@ -180,7 +180,7 @@ async function run(argv) {
     case "list":
     case "diff":
     case "doctor": {
-      const registry = await import('./commands-PT3NS65O.js');
+      const registry = await import('./commands-AHMXBWQQ.js');
       const options = {
         root: typeof flags["root"] === "string" ? flags["root"] : process.cwd(),
         registry: typeof flags["registry"] === "string" ? flags["registry"] : void 0,

package/dist/{commands-PT3NS65O.js → commands-AHMXBWQQ.js}

@@ -89,9 +89,29 @@ async function saveProject(root, config) {
 
 // src/add/rewrite.ts
 var REGISTRY_TOKEN = "@registre";
-function rewriteImports(source, importPrefix) {
+function estUnAlias(prefix) {
+  return /^[@~#]/.test(prefix);
+}
+function cheminRelatif(depuis, vers) {
+  const segmentsDepuis = depuis.split("/").slice(0, -1);
+  const segmentsVers = vers.split("/");
+  let commun = 0;
+  while (commun < segmentsDepuis.length && commun < segmentsVers.length - 1 && segmentsDepuis[commun] === segmentsVers[commun]) {
+    commun += 1;
+  }
+  const montees = segmentsDepuis.length - commun;
+  const descente = segmentsVers.slice(commun).join("/");
+  return montees === 0 ? `./${descente}` : `${"../".repeat(montees)}${descente}`;
+}
+function rewriteImports(source, importPrefix, target) {
   const prefix = importPrefix.replace(/\/$/, "");
-  return source.split(`${REGISTRY_TOKEN}/`).join(`${prefix}/`);
+  if (estUnAlias(prefix) || target === void 0) {
+    return source.split(`${REGISTRY_TOKEN}/`).join(`${prefix}/`);
+  }
+  return source.replaceAll(
+    new RegExp(`${REGISTRY_TOKEN}/([^'"\\s]+)`, "g"),
+    (_tout, chemin) => cheminRelatif(target, chemin)
+  );
 }
 function usedTokens(source) {
   const pattern = new RegExp(`${REGISTRY_TOKEN}/([\\w./-]+)`, "g");
@@ -134,7 +154,7 @@ async function inspectEntry(root, config, id, upstream) {
       if (source !== void 0) {
         served.set(
           join(config.aliases.directory, file.target).replaceAll("\\", "/"),
-          rewriteImports(source, config.aliases.import)
+          rewriteImports(source, config.aliases.import, file.target)
         );
       }
     }
@@ -401,7 +421,7 @@ async function planInstall(root, config, entries) {
         await planWrite(
           root,
           targetPath(config, file.target),
-          rewriteImports(source, config.aliases.import),
+          rewriteImports(source, config.aliases.import, file.target),
           entry.id
         )
       );
@@ -505,7 +525,7 @@ async function initCommand(options) {
   const suggested = defaultAliases(guess);
   if (guess === null) {
     warn(
-      `Aucun alias trouve dans tsconfig.json : les imports seront ecrits en ${colors.cyan(suggested.import)}.`
+      `Aucun alias trouve dans tsconfig.json : les composants iront dans ${colors.cyan(suggested.directory)}/ et s importeront entre eux en relatif.`
     );
   } else {
     info(

package/dist/{create-IOFAPDBO.js → create-GD6O2TPL.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { writeDatabaseUrl, assertEnvIgnored, PROVIDER_PENDING, checkDatabaseUrl } from './chunk-3SZIN6VG.js';
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { existsSync, statSync, readdirSync, readFileSync } from 'fs';
 import { resolve, basename, dirname, join } from 'path';
 import * as prompts from '@clack/prompts';
@@ -12,35 +12,35 @@ import { fileURLToPath } from 'url';
 var MODULES = [
   {
     id: "libs",
-    label: "Bibliotheques",
-    hint: "style, jetons, interface et animations",
+    label: "Libraries",
+    hint: "styles, tokens, UI and motion",
     defaut: true,
     paquet: "@odoro-cli/libs"
   },
   {
     id: "router",
-    label: "Routeur",
-    hint: "vient avec les bibliotheques \u2014 cable les pages",
+    label: "Router",
+    hint: "ships with the libraries \u2014 wires up the pages",
     defaut: true
   },
   {
     id: "icons",
-    label: "Icones",
-    hint: "cinq familles, importables une a une",
+    label: "Icons",
+    hint: "five families, imported one by one",
     defaut: true,
     paquet: "@odoro-cli/icons"
   },
   {
     id: "engine",
-    label: "Moteur",
-    hint: "WebGL, surfaces et politique de mouvement",
+    label: "Engine",
+    hint: "WebGL, surfaces and motion policy",
     defaut: false,
     paquet: "@odoro-cli/engine"
   },
   {
     id: "registre",
-    label: "Registre de composants",
-    hint: "copies par `odoro add` \u2014 entraine le moteur",
+    label: "Component registry",
+    hint: "copied by `odoro add` \u2014 pulls in the engine",
     defaut: false
   }
 ];
@@ -54,13 +54,13 @@ function resoudre(selection) {
   if (choisis.has("router") && !choisis.has("libs")) {
     choisis.delete("router");
     avertissements.push(
-      "Le routeur vient des bibliotheques (@odoro-cli/libs/router) : sans elles, il est retire."
+      "The router lives in the libraries (@odoro-cli/libs/router) \u2014 without them it is dropped."
     );
   }
   if (choisis.has("registre") && !choisis.has("engine")) {
     choisis.add("engine");
     avertissements.push(
-      "Presque toutes les entrees du registre importent @odoro-cli/engine : le moteur est ajoute."
+      "Almost every registry entry imports @odoro-cli/engine, so the engine was added."
     );
   }
   return { modules: MODULE_IDS.filter((id) => choisis.has(id)), avertissements };
@@ -71,22 +71,26 @@ function paquetsDe(modules) {
     (m) => m.paquet
   );
 }
-function varianteDe(modules) {
+function variantesDe(modules) {
   const choisis = new Set(modules);
-  if (!choisis.has("libs")) return "sans-libs";
-  if (!choisis.has("router")) return "sans-routeur";
-  return void 0;
+  const variantes = [];
+  if (!choisis.has("libs")) variantes.push("sans-libs");
+  else if (!choisis.has("router")) variantes.push("sans-routeur");
+  if (choisis.has("engine")) variantes.push("avec-moteur");
+  return variantes;
 }
 function gardeLesRoutes(modules) {
   return modules.includes("router");
 }
 function lireModules(valeur) {
   const brut = valeur.split(",").map((part) => part.trim()).filter((part) => part !== "");
-  if (brut.length === 1 && brut[0] === "aucun") return { modules: [] };
+  if (brut.length === 1 && (brut[0] === "none" || brut[0] === "aucun")) {
+    return { modules: [] };
+  }
   const inconnu = brut.find((part) => !MODULE_IDS.includes(part));
   if (inconnu !== void 0) {
     return {
-      erreur: `Module inconnu : "${inconnu}". Disponibles : ${MODULE_IDS.join(", ")}, ou "aucun".`
+      erreur: `Unknown module: "${inconnu}". Available: ${MODULE_IDS.join(", ")}, or "none".`
     };
   }
   return { modules: brut };
@@ -230,49 +234,52 @@ async function scaffold(options) {
   const files = [];
   await copyDirectory(source, options.target, files);
   if (!gardeLesRoutes(modules)) {
-    for (const dossier of ["src/routes", "client/src/routes"]) {
-      await rm(join(options.target, dossier), { recursive: true, force: true });
+    for (const fichier of ["src/router.tsx", "client/src/router.tsx"]) {
+      await rm(join(options.target, fichier), { force: true });
     }
   }
-  const variante = varianteDe(modules);
-  const poses = variante === void 0 ? [] : await poserVariante(source, options.target, variante);
+  const poses = [];
+  for (const variante of variantesDe(modules)) {
+    poses.push(...await poserVariante(source, options.target, variante));
+  }
   await renamePackage(
     options.target,
     options.packageName,
     options.version ?? cliVersion(),
     modules
   );
+  const retires = /* @__PURE__ */ new Set(["src/router.tsx", "client/src/router.tsx"]);
   const listes = /* @__PURE__ */ new Set([
-    ...files.filter(
-      (f) => !f.startsWith("src/routes/") && !f.startsWith("client/src/routes/")
-    ),
+    ...files.filter((f) => gardeLesRoutes(modules) || !retires.has(f)),
     ...poses
   ]);
   return { files: [...listes].sort() };
 }
 
 // src/commands/create.ts
+var DERNIERES_LIGNES = 8;
+var LARGEUR_LIGNE = 64;
 var TEMPLATE_LABELS = {
-  "react-ts": "Application monopage \u2014 React, TypeScript, routeur et animations Odoro",
-  "react-ts-server": "Client et serveur \u2014 la meme application, plus un socle @odoro-cli/server modulaire et un Dockerfile"
+  "react-ts": "Single-page app \u2014 React, TypeScript, Odoro router and motion",
+  "react-ts-server": "Client and server \u2014 the same app, plus a modular @odoro-cli/server base and a Dockerfile"
 };
 async function askDatabase() {
   const choice = ensure(
     await prompts.select({
-      message: "Base de donnees",
+      message: "Database",
       initialValue: "url",
       options: [
         {
           value: "provider",
-          label: "Fournisseur Odoro",
-          hint: "provisionnement automatique \u2014 bientot"
+          label: "Odoro provider",
+          hint: "automatic provisioning \u2014 coming soon"
         },
         {
           value: "url",
-          label: "URL PostgreSQL existante",
-          hint: "Neon, Supabase, RDS, la votre"
+          label: "Existing PostgreSQL URL",
+          hint: "Neon, Supabase, RDS, your own"
         },
-        { value: "later", label: "Configurer plus tard", hint: ".env.example seul" }
+        { value: "later", label: "Set up later", hint: ".env.example only" }
       ]
     })
   );
@@ -288,7 +295,7 @@ async function askDatabase() {
   }
   const url = ensure(
     await prompts.text({
-      message: "URL PostgreSQL",
+      message: "PostgreSQL URL",
       placeholder: "postgres://utilisateur:motdepasse@hote:5432/base?sslmode=require",
       validate: (value) => checkDatabaseUrl(value ?? "")
     })
@@ -313,7 +320,7 @@ async function askModules(options) {
   if (options.yes === true) return MODULES_PAR_DEFAUT;
   const choisis = ensure(
     await prompts.multiselect({
-      message: "Que met-on dans le projet ?",
+      message: "What goes in the project?",
       initialValues: [...MODULES_PAR_DEFAUT],
       required: false,
       options: MODULES.map((m) => ({ value: m.id, label: m.label, hint: m.hint }))
@@ -325,9 +332,55 @@ function annoncer(resolution) {
   for (const mot of resolution.avertissements) prompts.log.warn(mot);
   return resolution.modules;
 }
+async function installerDependances(target, manager) {
+  const [commande, ...args] = installCommand(manager).split(" ");
+  if (commande === void 0) return false;
+  const barre = prompts.spinner({ indicator: "timer" });
+  barre.start(`Installing dependencies with ${manager}`);
+  const fin = [];
+  const garder = (bloc) => {
+    for (const ligne of bloc.split("\n")) {
+      const propre = ligne.trim();
+      if (propre === "" || !/[a-z0-9]/i.test(propre)) continue;
+      fin.push(propre);
+      if (fin.length > DERNIERES_LIGNES) fin.shift();
+      barre.message(`${manager} \xB7 ${propre.slice(0, LARGEUR_LIGNE)}`);
+    }
+  };
+  const code = await new Promise((resolve_) => {
+    const processus = spawn(commande, args, {
+      cwd: target,
+      shell: process.platform === "win32"
+    });
+    processus.stdout?.setEncoding("utf8").on("data", garder);
+    processus.stderr?.setEncoding("utf8").on("data", garder);
+    processus.on("error", () => {
+      resolve_(-1);
+    });
+    processus.on("close", (sortie) => {
+      resolve_(sortie ?? -1);
+    });
+  });
+  if (code === 0) {
+    barre.stop(`Dependencies installed with ${manager}`);
+    return true;
+  }
+  barre.stop(`${manager} install failed`, 1);
+  for (const ligne of fin) prompts.log.error(colors.dim(ligne));
+  return false;
+}
+function versionCli() {
+  try {
+    const manifeste = join(dirname(templatesRoot()), "package.json");
+    const { version } = JSON.parse(readFileSync(manifeste, "utf8"));
+    return version;
+  } catch {
+    return "?";
+  }
+}
 function ensure(value) {
   if (prompts.isCancel(value)) {
-    prompts.cancel("Creation annulee.");
+    prompts.cancel("Cancelled.");
     process.exit(0);
   }
   return value;
@@ -336,10 +389,12 @@ async function createCommand(options) {
   const root = templatesRoot();
   const templates = availableTemplates(root);
   const defaultTemplate = templates[0] ?? "react-ts";
-  prompts.intro(colors.bold(colors.magenta(" odoro ")));
+  prompts.intro(
+    `${colors.bgBlue(colors.black(" ODORO "))} ${colors.dim(`v${versionCli()}`)}`
+  );
   const rawName = options.name ?? (options.yes === true ? "odoro-app" : ensure(
     await prompts.text({
-      message: "Nom du projet",
+      message: "Project name",
       placeholder: "mon-site",
       defaultValue: "odoro-app",
       validate: (value) => value === "" ? void 0 : validatePackageName(toPackageName(value))
@@ -357,17 +412,17 @@ async function createCommand(options) {
   if (state === "occupe" && overwrite === void 0) {
     if (options.yes === true) {
       prompts.cancel(
-        `Le dossier "${basename(target)}" n'est pas vide. Precisez --overwrite ou --merge.`
+        `Folder "${basename(target)}" is not empty. Pass --overwrite or --merge.`
       );
       return 1;
     }
     const choice = ensure(
       await prompts.select({
-        message: `Le dossier "${basename(target)}" n'est pas vide.`,
+        message: `Folder "${basename(target)}" is not empty.`,
         options: [
-          { value: "annuler", label: "Annuler" },
-          { value: "fusionner", label: "Fusionner \u2014 ecrase les fichiers de meme nom" },
-          { value: "ecraser", label: "Vider le dossier puis creer le projet" }
+          { value: "annuler", label: "Cancel" },
+          { value: "fusionner", label: "Merge \u2014 overwrites files of the same name" },
+          { value: "ecraser", label: "Empty the folder, then create the project" }
         ]
       })
     );
@@ -390,7 +445,7 @@ async function createCommand(options) {
   ));
   if (!templates.includes(template)) {
     prompts.cancel(
-      `Template inconnu : "${template}". Disponibles : ${templates.join(", ")}.`
+      `Unknown template: "${template}". Available: ${templates.join(", ")}.`
     );
     return 1;
   }
@@ -399,28 +454,28 @@ async function createCommand(options) {
   const detected = detectPackageManager();
   const manager = options.pm ?? (options.yes === true ? detected : ensure(
     await prompts.select({
-      message: "Gestionnaire de paquets",
+      message: "Package manager",
       initialValue: detected,
       options: PACKAGE_MANAGERS.map((name) => ({
         value: name,
         label: name,
-        hint: name === detected ? "detecte" : void 0
+        hint: name === detected ? "detected" : void 0
       }))
     })
   ));
   if (!PACKAGE_MANAGERS.includes(manager)) {
-    prompts.cancel(`Gestionnaire inconnu : "${manager}".`);
+    prompts.cancel(`Unknown package manager: "${manager}".`);
     return 1;
   }
   const database = template === "react-ts-server" && options.yes !== true ? await askDatabase() : void 0;
-  const withGit = options.git ?? (options.yes === true ? true : ensure(await prompts.confirm({ message: "Initialiser un depot git ?" })));
+  const withGit = options.git ?? (options.yes === true ? true : ensure(await prompts.confirm({ message: "Initialize a git repository?" })));
   const withInstall = options.install ?? (options.yes === true ? true : ensure(
     await prompts.confirm({
-      message: `Installer les dependances avec ${manager} ?`
+      message: `Install dependencies with ${manager}?`
     })
   ));
   const spinner2 = prompts.spinner();
-  spinner2.start("Creation du projet");
+  spinner2.start("Writing files");
   const scaffoldOptions = {
     target,
     template,
@@ -430,51 +485,44 @@ async function createCommand(options) {
   if (overwrite !== void 0) scaffoldOptions.overwrite = overwrite;
   scaffoldOptions.modules = modules;
   const { files } = await scaffold(scaffoldOptions);
-  spinner2.stop(`${files.length} fichiers ecrits dans ${colors.cyan(basename(target))}`);
+  spinner2.stop(`${String(files.length)} files written to ${colors.cyan(basename(target))}`);
   if (withGit && !existsSync(resolve(target, ".git"))) {
     try {
       execSync("git init -q", { cwd: target, stdio: "ignore" });
-      prompts.log.success("Depot git initialise.");
+      prompts.log.success("Git repository initialized.");
     } catch {
-      prompts.log.warn("git est introuvable : depot non initialise.");
+      prompts.log.warn("git was not found \u2014 repository not initialized.");
     }
   }
   if (database?.url !== void 0) {
     await writeDatabaseUrl(target, database.url);
-    prompts.log.success("URL de base ecrite dans .env");
+    prompts.log.success("Database URL written to .env");
     const risque = await assertEnvIgnored(target);
     if (risque !== void 0) prompts.log.warn(risque);
   }
   if (database !== void 0) prompts.log.info(database.note);
   if (modules.includes("registre")) {
-    const { initCommand } = await import('./commands-PT3NS65O.js');
+    const { initCommand } = await import('./commands-AHMXBWQQ.js');
     const code = await initCommand({ root: target, yes: true });
     if (code !== 0) {
       prompts.log.warn(
-        "Le registre n a pas pu etre configure. Relancez `odoro init` dans le projet."
+        "The registry could not be configured. Run `odoro init` in the project."
       );
     }
   }
-  if (withInstall) {
-    const install = prompts.spinner();
-    install.start(`Installation avec ${manager}`);
-    try {
-      execSync(installCommand(manager), { cwd: target, stdio: "ignore" });
-      install.stop("Dependances installees.");
-    } catch {
-      install.stop("Installation echouee \u2014 a relancer a la main.");
-    }
-  }
+  const installe = withInstall ? await installerDependances(target, manager) : false;
   const steps = [
     `cd ${basename(target)}`,
-    ...withInstall ? [] : [installCommand(manager)],
+    // Si l'installation a echoue, la commande revient dans les etapes : le
+    // projet est ecrit, il ne lui manque que ses dependances.
+    ...installe ? [] : [installCommand(manager)],
     // `odoro.json` vient d'etre ecrit : ce qui reste a montrer, c'est la
     // commande qui s'en sert.
     ...modules.includes("registre") ? ["odoro add text/count-up"] : [],
     runCommand(manager, "dev")
   ];
-  prompts.note(steps.join("\n"), "Prochaines etapes");
-  prompts.outro(colors.green("Bon developpement."));
+  prompts.note(steps.join("\n"), "Next steps");
+  prompts.outro(colors.green("Happy building."));
   return 0;
 }
 

package/dist/{package-6ADADETZ.js → package-VMTZDORI.js}

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "odoro",
-  version: "1.0.0",
+  version: "1.0.2",
   type: "module",
   license: "UNLICENSED",
   author: "BouBouw",

package/dist/registry/index.d.ts

@@ -94,10 +94,10 @@ declare const baseSchema: z.ZodMiniObject<{
         }>]>>;
         notes: z.ZodMiniOptional<z.ZodMiniString<string>>;
         fallback: z.ZodMiniOptional<z.ZodMiniEnum<{
+            none: "none";
             poster: "poster";
             gradient: "gradient";
             static: "static";
-            none: "none";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -165,10 +165,10 @@ declare const metaSchema: z.ZodMiniObject<{
         }>]>>;
         notes: z.ZodMiniOptional<z.ZodMiniString<string>>;
         fallback: z.ZodMiniOptional<z.ZodMiniEnum<{
+            none: "none";
             poster: "poster";
             gradient: "gradient";
             static: "static";
-            none: "none";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "odoro",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "license": "UNLICENSED",
   "author": "BouBouw",