// ============ CommonJS (CJS) : historique, utilise par Node.js par defaut ============

// fichier math.js
function additionner(a, b) {
    return a + b;
}
const PI = 3.14159;

module.exports = { additionner, PI };
// ou export individuel :
// exports.additionner = additionner;

// fichier main.js
const { additionner, PI } = require("./math.js");
console.log(additionner(2, 3));

// require() est SYNCHRONE et peut etre appele conditionnellement / dynamiquement
if (process.env.NODE_ENV === "development") {
    const debugTools = require("./debug-tools.js");
}

// ============ ES Modules (ESM) : standard moderne, natif navigateur + Node (via "type": "module") ============

// fichier math.mjs (ou .js avec "type": "module" dans package.json)
export function additionnerESM(a, b) {
    return a + b;
}
export const PI_ESM = 3.14159;

export default function saluer() {          // UN SEUL export default par module
    return "Bonjour";
}

// fichier main.mjs
import saluer, { additionnerESM, PI_ESM } from "./math.mjs";
import * as maths from "./math.mjs";           // importer tout le module comme namespace

console.log(additionnerESM(2, 3));
console.log(maths.PI_ESM);

// Import avec renommage
import { additionnerESM as add } from "./math.mjs";

// Import dynamique : asynchrone, retourne une Promise -- utile pour le code-splitting/lazy loading
async function chargerModuleConditionnellement() {
    if (document.querySelector("#widget-avance")) {
        const { WidgetAvance } = await import("./widget-avance.mjs");
        new WidgetAvance();
    }
}

// --- Différences fondamentales ---
// 1. CJS est synchrone, ESM est concu pour etre asynchrone (import() dynamique)
// 2. ESM est analyse STATIQUEMENT (les imports sont hoisted et fixes) -> permet le tree-shaking
// 3. CJS copie les valeurs exportees au moment du require ; ESM garde des "bindings" LIVE

// Demonstration du "live binding" en ESM :
// fichier compteur.mjs
export let compte = 0;
export function incrementer() {
    compte++;
}
// fichier main.mjs
// import { compte, incrementer } from "./compteur.mjs";
// console.log(compte);   // 0
// incrementer();
// console.log(compte);    // 1 -- la valeur importee reste synchronisee (contrairement a CJS)

// --- Interop : utiliser du CJS depuis de l'ESM (Node.js) ---
// import monModuleCJS from "./legacy-module.cjs";   // fonctionne, avec export default implicite

// --- package.json : declarer le type de module par defaut ---

{
  "name": "mon-projet",
  "type": "module",
  "exports": {
    ".": "./index.mjs",
    "./utils": "./utils.mjs"
  }
}

// --- Tree-shaking : avantage majeur d'ESM pour les bundlers ---
// Comme les imports/exports ESM sont statiques (pas de require() conditionnel),
// un bundler (Webpack, Rollup, esbuild) peut analyser precisement ce qui est REELLEMENT
// utilise et eliminer le code mort a la compilation -- impossible de facon fiable avec CJS.

// import { fonctionUtilisee } from "./grosse-librairie.mjs";
// -> seul le code de "fonctionUtilisee" (et ses dependances) finit dans le bundle final