odoro 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Configuration du moteur Odoro.
+ *
+ * Le fichier `odoro.config.ts` est compile a la volee puis importe : il peut
+ * donc etre ecrit en TypeScript et utiliser toute la puissance du langage,
+ * sans etape de build prealable.
+ *
+ * @module
+ */
+/** Reglages du serveur de developpement. */
+interface ServerConfig {
+    /** Port d'ecoute. @defaultValue 5180 */
+    port?: number;
+    /** Interface d'ecoute. @defaultValue 'localhost' */
+    host?: string;
+    /**
+     * Redirections de requetes, du prefixe de chemin vers l'origine cible.
+     *
+     * @example
+     * { '/api': 'http://localhost:3001' }
+     */
+    proxy?: Record<string, string>;
+}
+/** Reglages de la compilation de production. */
+interface BuildConfig {
+    /** Dossier de sortie, relatif a la racine. @defaultValue 'dist' */
+    outDir?: string;
+    /** Minifie le code produit. @defaultValue true */
+    minify?: boolean;
+    /** Emet des cartes de source. @defaultValue true */
+    sourcemap?: boolean;
+    /** Cible de compilation. @defaultValue 'es2022' */
+    target?: string;
+}
+/** Configuration d'un projet Odoro. */
+interface OdoroConfig {
+    /** Racine du projet. @defaultValue le dossier courant */
+    root?: string;
+    /** Prefixe des URL publiques. @defaultValue '/' */
+    base?: string;
+    /** Dossier des fichiers copies tels quels. @defaultValue 'public' */
+    publicDir?: string;
+    /** Reglages du serveur de developpement. */
+    server?: ServerConfig;
+    /** Reglages de la compilation de production. */
+    build?: BuildConfig;
+    /**
+     * Alias de chemins d'import, du prefixe vers un chemin relatif a la racine.
+     *
+     * @example
+     * { '@': 'src' }
+     */
+    alias?: Record<string, string>;
+    /** Remplacements textuels appliques a la compilation. */
+    define?: Record<string, string>;
+    /**
+     * Prefixe des variables d'environnement exposees au client via
+     * `import.meta.env`.
+     *
+     * @defaultValue 'ODORO_'
+     */
+    envPrefix?: string;
+}
+/** Configuration une fois les valeurs par defaut appliquees. */
+interface ResolvedConfig {
+    readonly root: string;
+    readonly base: string;
+    readonly publicDir: string;
+    readonly outDir: string;
+    readonly server: Required<Omit<ServerConfig, 'proxy'>> & {
+        proxy: Record<string, string>;
+    };
+    readonly build: Required<BuildConfig>;
+    readonly alias: Record<string, string>;
+    readonly define: Record<string, string>;
+    readonly envPrefix: string;
+    /** Chemin du fichier de configuration effectivement charge, s'il existe. */
+    readonly configFile: string | undefined;
+}
+/**
+ * Identite sur la configuration, presente uniquement pour le typage et
+ * l'autocompletion dans `odoro.config.ts`.
+ *
+ * @example
+ * import { defineConfig } from 'odoro'
+ *
+ * export default defineConfig({
+ *   server: { port: 3000, proxy: { '/api': 'http://localhost:3001' } },
+ * })
+ */
+declare function defineConfig(config: OdoroConfig): OdoroConfig;
+/**
+ * Charge la configuration d'un projet et applique les valeurs par defaut.
+ *
+ * @param root Racine du projet.
+ * @param overrides Reglages issus de la ligne de commande, prioritaires.
+ *
+ * @example
+ * const config = await loadConfig(process.cwd(), { server: { port: 4000 } })
+ */
+declare function loadConfig(root: string, overrides?: OdoroConfig): Promise<ResolvedConfig>;
+
+/**
+ * Serveur de developpement.
+ *
+ * Aucune compilation prealable : le navigateur demande les modules un a un,
+ * en modules natifs, et chacun est compile a la demande puis mis en cache.
+ * Le temps de demarrage ne depend donc pas de la taille du projet, seulement
+ * de la profondeur du premier ecran.
+ *
+ * @module
+ */
+
+/** Serveur de developpement en cours d'execution. */
+interface DevServer {
+    /** Adresse a ouvrir dans un navigateur. */
+    readonly url: string;
+    /** Arrete le serveur et libere les ressources. */
+    close(): Promise<void>;
+}
+/**
+ * Demarre le serveur de developpement.
+ *
+ * @param config Configuration resolue du projet.
+ *
+ * @example
+ * const server = await startDevServer(await loadConfig(process.cwd()))
+ * console.log(server.url)
+ */
+declare function startDevServer(config: ResolvedConfig): Promise<DevServer>;
+
+/**
+ * Compilation de production.
+ *
+ * Le document HTML est le point de depart : ses balises de script en modules
+ * designent les entrees, et il est reecrit a la fin pour pointer vers les
+ * fichiers empreintes.
+ *
+ * @module
+ */
+
+/** Un fichier produit par la compilation. */
+interface BuiltFile {
+    /** Chemin relatif au dossier de sortie. */
+    readonly path: string;
+    /** Taille en octets. */
+    readonly bytes: number;
+}
+/** Resultat d'une compilation de production. */
+interface BuildOutput {
+    /** Dossier de sortie. */
+    readonly outDir: string;
+    /** Fichiers produits, du plus gros au plus petit. */
+    readonly files: readonly BuiltFile[];
+    /** Duree totale, en millisecondes. */
+    readonly elapsed: number;
+}
+/**
+ * Compile un projet pour la production.
+ *
+ * @param config Configuration resolue du projet.
+ *
+ * @example
+ * const output = await buildProject(await loadConfig(process.cwd()))
+ */
+declare function buildProject(config: ResolvedConfig): Promise<BuildOutput>;
+/** Affiche le recapitulatif d'une compilation. */
+declare function reportBuild(output: BuildOutput, root: string): void;
+
+/**
+ * Serveur de previsualisation du build de production.
+ *
+ * Il ne compile rien : il sert le dossier de sortie tel quel, avec le meme
+ * repli d'application monopage qu'un hebergeur statique. C'est le dernier
+ * filet avant un deploiement.
+ *
+ * @module
+ */
+
+/** Serveur de previsualisation en cours d'execution. */
+interface PreviewServer {
+    /** Adresse a ouvrir dans un navigateur. */
+    readonly url: string;
+    /** Arrete le serveur. */
+    close(): Promise<void>;
+}
+/**
+ * Demarre le serveur de previsualisation.
+ *
+ * @param config Configuration resolue du projet.
+ * @param port Port d'ecoute. Par defaut, celui du serveur de developpement
+ *   augmente de un, pour pouvoir faire tourner les deux.
+ *
+ * @example
+ * const preview = await startPreviewServer(config)
+ */
+declare function startPreviewServer(config: ResolvedConfig, port?: number): Promise<PreviewServer>;
+
+/**
+ * Graphe des modules servis.
+ *
+ * Il repond a une seule question, mais la plus importante du developpement a
+ * chaud : quand ce fichier change, que faut-il recharger ?
+ *
+ * @module
+ */
+/** Un module connu du serveur. */
+interface ModuleNode {
+    /** Chemin absolu du fichier. */
+    readonly file: string;
+    /** URL sous laquelle le module est servi. */
+    readonly url: string;
+    /** Modules qui importent celui-ci. */
+    readonly importers: Set<string>;
+    /** Modules importes par celui-ci. */
+    readonly imported: Set<string>;
+    /**
+     * `true` si le module declare accepter ses propres mises a jour via
+     * `import.meta.hot.accept()`.
+     */
+    selfAccepting: boolean;
+    /** Code transforme, ou `undefined` si le module doit etre recompile. */
+    code: string | undefined;
+    /** Horodatage de la derniere invalidation, servant a casser le cache. */
+    timestamp: number;
+}
+/**
+ * Detecte si une source declare accepter ses propres mises a jour.
+ *
+ * L'analyse est volontairement textuelle. Une analyse syntaxique complete
+ * serait plus sure, mais `import.meta.hot.accept` est une formule trop
+ * distinctive pour apparaitre par accident, et le cout d'un faux positif se
+ * limite a une mise a jour la ou un rechargement aurait suffi.
+ *
+ * @example
+ * detectSelfAccepting('import.meta.hot?.accept()') // true
+ */
+declare function detectSelfAccepting(source: string): boolean;
+/** Graphe des modules et de leurs relations d'import. */
+declare class ModuleGraph {
+    private readonly nodes;
+    /** Recupere un module, ou le cree s'il est inconnu. */
+    ensure(file: string, url: string): ModuleNode;
+    /** Recupere un module deja connu. */
+    get(file: string): ModuleNode | undefined;
+    /** Nombre de modules connus. */
+    get size(): number;
+    /**
+     * Remplace la liste des dependances d'un module, en tenant a jour les
+     * relations inverses.
+     */
+    setDependencies(file: string, dependencies: readonly string[]): void;
+    /**
+     * 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: string): ModuleNode[];
+    /** Oublie tous les modules. */
+    clear(): void;
+}
+
+/**
+ * Transformation des modules servis en developpement.
+ *
+ * Le navigateur ne sait lire ni TypeScript, ni JSX, ni les specificateurs
+ * d'import nus (`import React from 'react'`). Chaque module demande est donc
+ * compile a la volee et ses imports sont reecrits en URL que le serveur sait
+ * resoudre.
+ *
+ * La reecriture n'est pas faite a coups d'expressions regulieres — une chaine
+ * de caracteres contenant le mot `import` suffirait a la mettre en defaut.
+ * On s'appuie sur le resolveur du compilateur lui-meme : chaque import est
+ * resolu puis **marque externe**, de sorte que rien n'est inline mais que tous
+ * les chemins ressortent reecrits, avec la meme exactitude qu'une compilation
+ * complete.
+ *
+ * @module
+ */
+
+/**
+ * Nom de fichier compile correspondant a un specificateur de dependance.
+ *
+ * Le nom est **aplati** : c'est ce qui rend l'URL servie exempte de segment de
+ * dossier. Un module servi sous `/@deps/react-dom/client` resoudrait son propre
+ * `import './chunk-X.js'` en `/@deps/react-dom/chunk-X.js`, alors que le
+ * fragment est depose a la racine du cache.
+ *
+ * @example
+ * depFileName('react-dom/client') // 'react-dom_client.js'
+ * depFileName('@scope/paquet')    // 'scope_paquet.js'
+ */
+declare function depFileName(specifier: string): string;
+
+/**
+ * Pre-compilation des dependances.
+ *
+ * Deux raisons la rendent indispensable, et non optionnelle :
+ *
+ * 1. beaucoup de paquets ne sont encore distribues qu'en modules CommonJS, que
+ *    le navigateur ne sait pas charger ;
+ * 2. une dependance eclatee en centaines de petits fichiers declencherait
+ *    autant de requetes au premier chargement.
+ *
+ * Le piege, lui, est ailleurs : si `react` et `react-dom/client` etaient
+ * compiles separement, chacun embarquerait sa copie de React. Deux instances
+ * de React dans une meme page cassent les hooks et les contextes, avec des
+ * symptomes deroutants. Tous les specificateurs sont donc **compiles en une
+ * seule passe**, avec decoupage : le code commun se retrouve dans un fragment
+ * partage, et l'instance reste unique.
+ *
+ * @module
+ */
+
+/** Resultat de la pre-compilation. */
+interface OptimizedDeps {
+    /** Dossier contenant les modules compiles. */
+    readonly directory: string;
+    /** Specificateurs disponibles. */
+    readonly specifiers: readonly string[];
+    /** `true` si une compilation a reellement eu lieu. */
+    readonly rebuilt: boolean;
+}
+/**
+ * Parcourt le code du projet a la recherche des dependances reellement
+ * importees, transitivement.
+ *
+ * Se fonder sur le champ `dependencies` du manifeste ne suffirait pas : une
+ * application importe `react-dom/client`, jamais `react-dom` tout court.
+ *
+ * @param entries Points d'entree du projet, en chemins absolus.
+ *
+ * @example
+ * const specifiers = await scanDependencies(config, ['/projet/src/main.tsx'])
+ */
+declare function scanDependencies(config: ResolvedConfig, entries: readonly string[]): Promise<string[]>;
+/**
+ * Compile un ensemble de specificateurs en une seule passe.
+ *
+ * @param config Configuration resolue du projet.
+ * @param specifiers Specificateurs a compiler.
+ * @param force Recompile meme si le cache semble valide.
+ *
+ * @example
+ * const deps = await optimizeDeps(config, ['react', 'react-dom/client'])
+ */
+declare function optimizeDeps(config: ResolvedConfig, specifiers: readonly string[], force?: boolean): Promise<OptimizedDeps>;
+
+export { type BuildConfig, type BuildOutput, type BuiltFile, type DevServer, ModuleGraph, type ModuleNode, type OdoroConfig, type OptimizedDeps, type PreviewServer, type ResolvedConfig, type ServerConfig, buildProject, defineConfig, depFileName, detectSelfAccepting, loadConfig, optimizeDeps, reportBuild, scanDependencies, startDevServer, startPreviewServer };

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export { defineConfig, loadConfig } from './chunk-T42X2NJN.js';
+import './chunk-T6RLHSCW.js';
+export { buildProject, reportBuild } from './chunk-UGRSODHU.js';
+export { ModuleGraph, depFileName, detectSelfAccepting, optimizeDeps, scanDependencies, startDevServer } from './chunk-G5QXVBYT.js';
+export { startPreviewServer } from './chunk-2YDI5NKV.js';
+import './chunk-JMEHF3KN.js';

package/dist/package-AUINPBEX.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// package.json
+var package_default = {
+  name: "odoro",
+  version: "0.1.0",
+  type: "module",
+  license: "UNLICENSED",
+  author: "BouBouw",
+  description: "Moteur de developpement et echafaudage Odoro : odoro create, dev, build, preview.",
+  engines: {
+    node: ">=20"
+  },
+  bin: {
+    odoro: "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "templates",
+    "client.d.ts"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./client": {
+      types: "./client.d.ts"
+    },
+    "./cli": {
+      types: "./dist/cli.d.ts",
+      import: "./dist/cli.js"
+    },
+    "./registry": {
+      types: "./dist/registry/index.d.ts",
+      import: "./dist/registry/index.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "pnpm run build"
+  },
+  dependencies: {
+    "@babel/core": "^8.0.1",
+    "@clack/prompts": "^0.11.0",
+    esbuild: "^0.28.2",
+    picocolors: "^1.1.1",
+    "react-refresh": "^0.18.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.18.8",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3",
+    vitest: "^3.2.4",
+    zod: "^4.5.1"
+  }
+};
+
+export { package_default as default };

package/dist/preview-LOAO5Y6V.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export { startPreviewServer } from './chunk-2YDI5NKV.js';
+import './chunk-JMEHF3KN.js';