chokibasic 1.1.2 → 1.1.3

package/index.d.ts

@@ -1,128 +1,152 @@
-// index.d.ts
 
-export type GlobPattern = string;
+declare namespace chokibasic {
+  export type GlobPattern = string;
 
-export type IgnoreMatcher =
-  | string
-  | RegExp
-  | ((relPosixPath: string) => boolean);
+  export type IgnoreMatcher =
+    | string
+    | RegExp
+    | ((relPosixPath: string) => boolean);
 
-export interface WatchEvent {
-  /** Type d’évènement (dans ton code actuel: surtout "change") */
-  type: "add" | "change" | "unlink" | (string & {});
-  /** Chemin relatif à cwd, normalisé en POSIX (slash "/") */
-  file: string;
-}
+  export type WatchEventType = "add" | "change" | "unlink" | (string & {});
 
-export interface WatchRuleContext {
-  rule: WatchRule;
-}
+  export interface WatchEvent {
+    /** Type d’évènement (dans le code actuel: surtout "change") */
+    type: WatchEventType;
+    /** Chemin relatif à cwd, normalisé POSIX (slash "/") */
+    file: string;
+  }
 
-export interface WatchRule {
-  /** Nom affiché en debug */
-  name?: string;
+  export interface WatchRuleContext {
+    rule: WatchRule;
+  }
 
-  /** Globs d’inclusion (ex: "src/styles/ ** / *.scss") */
-  patterns: GlobPattern | GlobPattern[];
+  export interface WatchRule {
+    /** Nom affiché en debug */
+    name?: string;
 
-  /** Ignorés additionnels (globs / regex / function) */
-  ignored?: IgnoreMatcher[];
+    /** Globs d’inclusion (ex: "src/styles/ ** / *.scss") */
+    patterns: GlobPattern | GlobPattern[];
 
-  /** Debounce en ms (défaut: 150) */
-  debounceMs?: number;
+    /** Ignorés additionnels (globs / regex / function) */
+    ignored?: IgnoreMatcher[];
 
-  /**
-   * Callback appelé avec un batch d’évènements.
-   * Le batch contient des objets { type, file }.
-   */
-  callback: (events: WatchEvent[], ctx: WatchRuleContext) => void | Promise<void>;
-}
+    /** Debounce en ms (défaut: 150) */
+    debounceMs?: number;
 
-export interface AwaitWriteFinishOptions {
-  stabilityThreshold?: number;
-  pollInterval?: number;
-}
+    /**
+     * Callback appelé avec un batch d’évènements.
+     * Le batch contient des objets { type, file }.
+     */
+    callback: (events: WatchEvent[], ctx: WatchRuleContext) => void | Promise<void>;
+  }
 
-export interface CreateWatchersOptions {
-  /** Répertoire racine utilisé pour calculer les chemins relatifs */
-  cwd?: string;
+  export interface AwaitWriteFinishOptions {
+    stabilityThreshold?: number;
+    pollInterval?: number;
+  }
 
-  /**
-   * Ignorés globaux (appliqués dans queue(), pas via chokidar "ignored")
-   * Défaut: ["** /node_modules/**","** /.git/ **","** /dist/ **"]
-   */
-  globalIgnored?: string[];
+  export interface CreateWatchersOptions {
+    /** Répertoire racine utilisé pour calculer les chemins relatifs */
+    cwd?: string;
 
-  /** chokidar: ignoreInitial */
-  ignoreInitial?: boolean;
+    /**
+     * Ignorés globaux (appliqués dans queue(), pas via chokidar "ignored")
+     * Défaut: ["** /node_modules/ **","** /.git/ **","** /dist/ **"]
+     */
+    globalIgnored?: string[];
 
-  /** chokidar: awaitWriteFinish */
-  awaitWriteFinish?: boolean | AwaitWriteFinishOptions;
+    /** chokidar: ignoreInitial */
+    ignoreInitial?: boolean;
 
-  /** chokidar: usePolling */
-  usePolling?: boolean;
+    /** chokidar: awaitWriteFinish */
+    awaitWriteFinish?: boolean | AwaitWriteFinishOptions;
 
-  /** chokidar: interval */
-  interval?: number;
+    /** chokidar: usePolling */
+    usePolling?: boolean;
 
-  /** chokidar: binaryInterval */
-  binaryInterval?: number;
+    /** chokidar: interval */
+    interval?: number;
 
-  /** Log console */
-  debug?: boolean;
+    /** chokidar: binaryInterval */
+    binaryInterval?: number;
 
-  /** Permet d’accepter d’autres options sans casser les types */
-  [key: string]: unknown;
-}
+    /** Log console */
+    debug?: boolean;
 
-export interface WatchersController {
-  /** Ferme tous les watchers et annule les timers */
-  close: () => Promise<void>;
-}
+    /** Permet d’accepter d’autres options sans casser les types */
+    [key: string]: unknown;
+  }
+
+  export interface WatchersController {
+    /** Ferme tous les watchers et annule les timers */
+    close: () => Promise<void>;
+  }
+
+  export interface ExportDistStats {
+    copied: number;
+    skipped: number;
+  }
 
-export interface ExportDistStats {
-  copied: number;
-  skipped: number;
+  /** Options forwardées à esbuild.build() */
+  export type BuildJSOptions = Parameters<typeof import("esbuild").build>[0];
+
+  /** Options forwardées à sass.compile() */
+  export type BuildCSSOptions = NonNullable<Parameters<typeof import("sass").compile>[1]>;
+
+  /**
+   * Crée un ou plusieurs watchers (un par règle).
+   */
+  export function createWatchers(
+    rules: WatchRule[],
+    options?: CreateWatchersOptions
+  ): WatchersController;
+
+  /**
+   * Exporte un dossier `src` vers `dist` en respectant .gitignore + exclusions.
+   */
+  export function exportDist(
+    src: string,
+    dist: string,
+    banner?: string | null
+  ): Promise<ExportDistStats>;
+
+  /**
+   * Compile SCSS -> CSS minifié (csso), écrit dans outCssMin.
+   */
+  export function buildCSS(
+    inputScss: string,
+    outCssMin: string,
+    options?: BuildCSSOptions
+  ): Promise<void>;
+
+  /**
+   * Bundle/minify JS via esbuild.
+   */
+  export function buildJS(
+    entry: string,
+    outfile: string,
+    options?: BuildJSOptions
+  ): Promise<void>;
+
+  /**
+   * Rend un fichier via pxpros.render(file).
+   */
+  export function buildPHP(file: string): Promise<void>;
+
+  /**
+   * Génère un sitemap via pxpros.sitemap(file).
+   */
+  export function buildSitemap(file: string): Promise<void>;
 }
 
-/**
- * Crée un ou plusieurs watchers (un par règle).
- */
-export function createWatchers(
-  rules: WatchRule[],
-  options?: CreateWatchersOptions
-): WatchersController;
-
-/**
- * Exporte un dossier `src` vers `dist` en respectant .gitignore + exclusions.
- */
-export function exportDist(
-  src: string,
-  dist: string,
-  banner?: string | null
-): Promise<ExportDistStats>;
-
-/**
- * Compile SCSS -> CSS minifié (csso), écrit dans outCssMin.
- * `options` est forwardé à sass.compile().
- */
-export function buildCSS(
-  inputScss: string,
-  outCssMin: string,
-  options?: Record<string, unknown>
-): Promise<void>;
-
-/**
- * Bundle/minify JS via esbuild.
- * `options` est forwardé à esbuild.build().
- */
-export function buildJS(
-  entry: string,
-  outfile: string,
-  options?: Record<string, unknown>
-): Promise<void>;
-
-/**
- * Rend un fichier via pxpros.render(file).
- */
-export function buildPHP(file: string): Promise<void>;
+declare const chokibasic: {
+  createWatchers: typeof chokibasic.createWatchers;
+  exportDist: typeof chokibasic.exportDist;
+  buildCSS: typeof chokibasic.buildCSS;
+  buildJS: typeof chokibasic.buildJS;
+  buildPHP: typeof chokibasic.buildPHP;
+  buildSitemap: typeof chokibasic.buildSitemap;
+};
+
+export = chokibasic;
+export as namespace chokibasic;

package/index.js

@@ -1 +1,7 @@
-module.exports = require("./src/watcher.js");
+module.exports = {
+	...require("./src/buildjs.js"),
+	...require("./src/buildcss.js"),
+	...require("./src/buildphp.js"),
+	...require("./src/export.js"),
+	...require("./src/watchers.js"),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chokibasic",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Basic chokidar watcher + pxpros + esbuild + sass + csso helpers",
   "main": "index.js",
   "types": "index.d.ts",

package/readme.md

@@ -1,17 +1,29 @@
 # chokibasic
 
-Helpers:
+Tiny build & watch helpers for simple static projects.
+
+## Helpers
+
 - `createWatchers(rules, options)`
-- `buildCSS(inputScss, outCssMin)`
-- `buildJS(entry, outfile)`
+- `buildCSS(inputScss, outCssMin, options?)`
+- `buildJS(entry, outfile, options?)`
+- `buildPHP(file)`
+- `buildSitemap(file)`
+- `exportDist(src, dist, bannerPath?)`
+
+---
 
 ## Install
+
 ```bash
 npm i chokibasic
-```
+````
+
+---
 
-## Usage
-```JS
+## Usage (watch + build) — original example (fixed)
+
+```js
 const { createWatchers, buildCSS, buildJS } = require("chokibasic");
 
 const w = createWatchers(
@@ -39,19 +51,202 @@ const w = createWatchers(
 
 // later: await w.close();
 process.on("SIGINT", async () => {
-	await close();
-	process.exit(0);
+  await w.close();
+  process.exit(0);
 });
+```
+
+---
+
+## API
+
+### `createWatchers(rules, options)`
 
+Creates one watcher per rule using `chokidar`, but with:
+
+* **include filtering** using `rule.patterns` (glob)
+* **ignore filtering** using `options.globalIgnored` + `rule.ignored` (glob/RegExp/function)
+* **debounced batching**: multiple file events are grouped and sent to your callback
+
+Each callback receives:
+
+* `events`: an array like `{ type, file }`
+* `ctx`: `{ rule }`
+
+**Important note (current behavior):**
+In the current code, only `"change"` events are enabled (`add` and `unlink` listeners are commented out).
+
+#### Rule shape
+
+```js
+{
+  name?: string,
+  patterns: string | string[],
+  ignored?: (string | RegExp | ((relPosixPath) => boolean))[],
+  debounceMs?: number, // default 150
+  callback: async (events, ctx) => {}
+}
 ```
 
+#### Options
+
+```js
+{
+  cwd: process.cwd(),
+  globalIgnored: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+
+  // chokidar options used internally:
+  ignoreInitial: true,
+  awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 10 },
+  usePolling: false,
+  interval: 200,
+  binaryInterval: 300,
+
+  debug: true
+}
+```
+
+---
+
+### `buildCSS(inputScss, outCssMin, options?)`
+
+Compiles SCSS using `sass.compile()` and minifies using `csso`.
+
+* Defaults include:
+
+  * `loadPaths: ["<cwd>/node_modules"]`
+  * `style: "compressed"`
+  * no sourcemap
+* `options` is forwarded to `sass.compile()` (and can override defaults).
+
+Example:
+
+```js
+const { buildCSS } = require("chokibasic");
+
+await buildCSS("src/styles/main.scss", "dist/app.min.css", {
+  // any sass.compile options here
+});
+```
+
+---
+
+### `buildJS(entry, outfile, options?)`
+
+Bundles & minifies JS using `esbuild`.
+
+Defaults include:
+
+* `bundle: true`
+* `platform: "browser"`
+* `minify: true`
+* `treeShaking: true`
+* `target: ["es2020"]`
+* `legalComments: "none"`
+
+`options` is forwarded to `esbuild.build()` (and can override defaults).
+
+Example:
+
+```js
+const { buildJS } = require("chokibasic");
+
+await buildJS("src/scripts/main.js", "dist/app.min.js", {
+  // any esbuild.build options here
+});
+```
+
+---
+
+### `buildPHP(file)`
+
+Runs `pxpros.render(file)` and logs generated HTML files.
+
+Example:
+
+```js
+const { buildPHP } = require("chokibasic");
+
+await buildPHP("src/pages/_index.php");
+```
+
+---
+
+### `buildSitemap(file)`
+
+Runs `pxpros.sitemap(file)` and logs generated sitemap XML files.
+
+Example:
+
+```js
+const { buildSitemap } = require("chokibasic");
+
+await buildSitemap("src/pages/_index.php");
+```
+
+---
+
+### `exportDist(src, dist, bannerPath?)`
+
+Copies your `src` folder to `dist`, while:
+
+* respecting `.gitignore` (if present in project root)
+* also ignoring `dist/` for safety
+* skipping:
+
+  * any file/folder starting with `_`
+  * `.scss`
+  * `.js` files that are NOT `.min.js`
+
+Then it can prepend a banner to:
+
+* `.js` and `.css` files using `/*! ... */`
+* `.html` files using `<!-- ... -->`
+
+It also replaces placeholders:
+
+* in `.html`:
+
+  * `###YEAR###` → current year
+  * `###TIMESTAMP###` → unix timestamp (seconds)
+* in `sitemap.xml`:
+
+  * `###TODAY###` → `YYYY-MM-DD`
+* in the banner text:
+
+  * `###DATE###` → formatted date (fr-CA, America/Toronto)
+
+Example:
+
+```js
+const { exportDist } = require("chokibasic");
+
+const stats = await exportDist("src", "dist"); // uses built-in banner.txt
+console.log(stats); // { copied: <number>, skipped: <number> }
+```
+
+With a custom banner file:
+
+```js
+await exportDist("src", "dist", "src/banner.txt");
+```
+
+---
+
 ## Changelog
 
+### Version 1.1.3
+* Complete refactor
+* Fix buildCSS "style: expanded"
+
 ### Version 1.1.2
-- exportDist: Add date remplacement for sitemap.xml
+
+* exportDist: Add date replacement for sitemap.xml
 
 ### Version 1.1.1
-- Update dependancy: pxpros 1.0.4
+
+* Update dependency: pxpros 1.0.4
 
 ### Version 1.1.0
-- Add a sitemap builder with pxpros
+
+* Add a sitemap builder with pxpros

package/src/buildcss.js

@@ -0,0 +1,29 @@
+const sass = require("sass");
+const csso = require("csso");
+const path = require("path");
+const fs = require("node:fs");
+
+const buildCSS = async (inputScss, outCssMin, options = {}) => {
+	// let compiled;
+	try {
+		const compiled = sass.compile(inputScss, {
+			loadPaths: [path.resolve(process.cwd(), "./node_modules")],
+			style: "compressed",
+			sourceMap: false,
+			sourceMapIncludeSources: false,
+			...options
+		});
+		if(options?.style == "expanded"){
+			fs.writeFileSync(outCssMin, compiled.css);
+		} else {
+			const minified = csso.minify(compiled.css, { restructure: false });
+			fs.writeFileSync(outCssMin, minified.css);
+		}
+		console.log(`✅ CSS generated: ${outCssMin}`);
+	} catch (err) {
+		console.error("❌ Sass compile error:");
+		console.error(err?.formatted || err?.message || err);
+	}
+}
+
+module.exports = { buildCSS };

package/src/buildjs.js

@@ -0,0 +1,35 @@
+const esbuild = require("esbuild");
+
+
+const buildJS = async (entry, outfile, options = {}) => {
+	try {
+		await esbuild.build({
+			entryPoints: [entry],
+			outfile,
+			bundle: true,
+			platform: "browser",
+			logLevel: "error",
+			treeShaking: true,
+			minify: true,
+			supported: { "template-literal": false },
+			target: ["es2020"],
+			legalComments: "none",
+			...options
+		});
+		console.log(`✅ JS generated: ${outfile}`);
+	} catch (err) {
+		console.error("❌ esbuild build failed.");
+		if (err?.errors?.length) {
+			const formatted = await esbuild.formatMessages(err.errors, {
+				kind: "error",
+				color: true,
+				terminalWidth: process.stdout.columns || 80,
+			});
+			console.error(formatted.join("\n"));
+		} else {
+			console.error(err);
+		}
+	}
+}
+
+module.exports = { buildJS };

package/src/buildphp.js

@@ -0,0 +1,25 @@
+const pxpros = require("pxpros");
+
+
+const buildPHP = async (file) => {
+	const results = await pxpros.render(file);
+	if(results.success) {
+		results.files.forEach(file => console.log(`✅ HTML generated: ${file}`));
+	} else {
+		console.error("❌ pxpros render failed.");
+		console.error(results.error);
+	}
+}
+
+
+const buildSitemap = async (file) => {
+	const results = await pxpros.sitemap(file);
+	if(results.success) {
+		results.files.forEach(file => console.log(`✅ XML Sitemap generated: ${file}`));
+	} else {
+		console.error("❌ pxpros sitemap creation failed.");
+		console.error(results.error);
+	}
+}
+
+module.exports = { buildPHP, buildSitemap };

package/src/export.js

@@ -0,0 +1,134 @@
+const fsprom = require('fs/promises');
+const ignore = require('ignore');
+const fs = require("node:fs");
+const path = require("path");
+
+const ROOT = process.cwd();
+
+
+async function emptyDir(dir) {
+	await fsprom.mkdir(dir, { recursive: true });
+	const entries = await fsprom.readdir(dir, { withFileTypes: true });
+	await Promise.all(entries.map((e) => fsprom.rm(path.join(dir, e.name), { recursive: true, force: true })));
+}
+
+
+function formatFrDate(dateInput = new Date(), timeZone = 'America/Toronto') {
+	const d = (dateInput instanceof Date) ? dateInput : new Date(dateInput);
+	const fmt = new Intl.DateTimeFormat('fr-CA', {
+		weekday: 'long',
+		day: 'numeric',
+		month: 'long',
+		year: 'numeric',
+		hour: 'numeric',
+		minute: '2-digit',
+		hour12: false,
+		timeZone
+	});
+	const parts = Object.fromEntries(fmt.formatToParts(d).map(p => [p.type, p.value]));
+	const weekday = parts.weekday.charAt(0).toUpperCase() + parts.weekday.slice(1); // "Samedi"
+	return `${weekday} le ${parts.day} ${parts.month} ${parts.year} à ${parts.hour} h ${parts.minute}`;
+}
+
+
+function norm(p) {
+	// normalise en chemin POSIX pour compat .gitignore
+	return p.split(path.sep).join('/');
+}
+
+async function loadGitignore() {
+	const ig = ignore();
+	const giPath = path.join(ROOT, '.gitignore');
+	if (fs.existsSync(giPath)) {
+		const txt = await fsprom.readFile(giPath, 'utf8');
+		ig.add(txt);
+	}
+	// on ignore aussi le dossier dist par sécurité (pas nécessaire mais sain)
+	ig.add('dist/');
+	return ig;
+}
+
+async function rmDir(dir) {
+	await fsprom.rm(dir, { recursive: true, force: true });
+	await fsprom.mkdir(dir, { recursive: true });
+}
+
+function shouldExcludeFile(relFromRoot, absPath) {
+	// Exclusions de type/extension
+	const lower = absPath.toLowerCase();
+	if (path.basename(lower).startsWith('_')) return true;
+	if (lower.endsWith('.scss')) return true;
+	if (lower.endsWith('.js') && !lower.endsWith('.min.js')) return true;
+	return false;
+}
+
+async function copyFilePreserveTree(absSrc, src, dist, ig) {
+	const relFromSrc = path.relative(src, absSrc);
+	const relFromRoot = path.relative(ROOT, absSrc);
+	const relPosix = norm(relFromRoot);
+
+	// 1) Exclusions via .gitignore
+	if (ig.ignores(relPosix)) return false;
+
+	// 2) Exclusions spécifiques (scss, js non minifiés)
+	if (shouldExcludeFile(relPosix, absSrc)) return false;
+
+	const absDst = path.join(dist, relFromSrc);
+	// console.log(absDst);
+	await fsprom.mkdir(path.dirname(absDst), { recursive: true });
+	await fsprom.copyFile(absSrc, absDst);
+	return absDst;
+}
+
+async function walkAndCopy(dir, src, dest, ig, stats, banner = null) {
+	const entries = await fsprom.readdir(dir, { withFileTypes: true });
+	const bannerContent = (await fsprom.readFile(banner || path.join(__dirname, 'banner.txt'), 'utf8')).replace(/###DATE###/, formatFrDate());
+	const today = (d => `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`)(new Date());
+
+	for (const de of entries) {
+		const abs = path.join(dir, de.name);
+		const relFromRoot = path.relative(ROOT, abs);
+		const relPosix = norm(relFromRoot);
+
+		if (de.isDirectory()) {
+			// Si le dossier est ignoré par .gitignore, on ne descend pas
+			if (ig.ignores(relPosix + '/')) continue;
+			if(de.name.startsWith('_')) continue;
+			await walkAndCopy(abs, src, dest, ig, stats, banner);
+		} else if (de.isFile()) {
+			const copied = await copyFilePreserveTree(abs, src, dest, ig);
+			if (copied) {
+				const lower = abs.toLowerCase();
+				if (lower.endsWith('.js')) await fsprom.writeFile(copied, "/*!\n\n" + bannerContent + "\n\n*/\n" + (await fsprom.readFile(copied, 'utf8')), "utf8");
+				else if (lower.endsWith('.css')) await fsprom.writeFile(copied, "/*!\n\n" + bannerContent + "\n\n*/\n" + (await fsprom.readFile(copied, 'utf8')), "utf8");
+				else if (lower.endsWith('.html')) await fsprom.writeFile(copied, "<!--\n\n" + bannerContent + "\n\n\-->\n" + (await fsprom.readFile(copied, 'utf8'))
+					.replaceAll(/###YEAR###/g, (new Date).getFullYear())
+					.replaceAll(/###TIMESTAMP###/g, Math.floor(Date.now() / 1000)), "utf8");
+				else if (lower.endsWith('sitemap.xml')) await fsprom.writeFile(copied, (await fsprom.readFile(copied, 'utf8')).replaceAll(/###TODAY###/g, today), "utf8");
+				stats.copied++;
+			}
+			else stats.skipped++;
+		}
+		// (symlinks & autres: ignorés)
+	}
+}
+
+
+const exportDist = async (src, dist, banner = null) => {
+	try {
+		const ig = await loadGitignore();
+
+		await emptyDir(dist);
+		if (!fs.existsSync(src)) throw new error('Folder src is invalid.');
+
+		const stats = { copied: 0, skipped: 0 };
+		await walkAndCopy(src, src, dist, ig, stats, banner);
+
+		return stats;
+	} catch (err) {
+		throw new error(err);
+	}
+}
+
+
+module.exports = { exportDist };

package/src/watchers.js

@@ -0,0 +1,203 @@
+const path = require("path");
+const chokidar = require("chokidar");
+
+function toPosix(p) {
+	return p.replace(/\\/g, "/");
+}
+
+function normalizePatterns(patterns) {
+	return Array.isArray(patterns) ? patterns : [patterns];
+}
+
+function globBaseDir(glob) {
+	const g = toPosix(glob);
+	const idx = g.search(/[*?\[]/);
+	if (idx === -1) return g;
+	const base = g.slice(0, idx);
+	return base.replace(/\/+$/, "") || ".";
+}
+
+function globToRegExp(glob) {
+	const g = toPosix(glob);
+
+	let re = "^";
+	for (let i = 0; i < g.length; i++) {
+		const c = g[i];
+
+		if (c === "*" && g[i + 1] === "*") {
+			i++;
+			if (g[i + 1] === "/") {
+				i++;
+				re += "(?:.*/)?";
+			} else {
+				re += ".*";
+			}
+			continue;
+		}
+
+		if (c === "*") { re += "[^/]*"; continue; }
+		if (c === "?") { re += "[^/]"; continue; }
+
+		if ("\\.[]{}()+-^$|".includes(c)) re += "\\" + c;
+		else re += c;
+	}
+	re += "$";
+	return new RegExp(re);
+}
+
+function isIgnoredPosix(relPosix, ignoreMatchers) {
+	for (const m of ignoreMatchers) {
+		if (m instanceof RegExp) {
+			if (m.test(relPosix)) return true;
+		} else if (typeof m === "function") {
+			// si l'user fournit une fonction ignorée, on lui passe le rel posix
+			if (m(relPosix)) return true;
+		} else if (typeof m === "string") {
+			// strings glob déjà compilées dans ignoreMatchers (voir compileIgnoreMatchers)
+			// (fallback: on ne devrait pas arriver ici)
+			if (globToRegExp(m).test(relPosix)) return true;
+		}
+	}
+	return false;
+}
+
+function compileIgnoreMatchers(ignoreList) {
+	return (ignoreList || []).map((ig) => {
+		if (ig instanceof RegExp) return ig;
+		if (typeof ig === "function") return ig;
+		// string glob -> RegExp
+		return globToRegExp(ig);
+	});
+}
+
+/**
+ * createWatchers(rules, options)
+ * - Watch les dossiers racines (baseDirs)
+ * - Filtre include via globs (rule.patterns)
+ * - Filtre ignore via globs/regex (globalIgnored + rule.ignored)
+ */
+function createWatchers(rules, options = {}) {
+	const opt = {
+		cwd: process.cwd(),
+
+		// Ignorés globaux (appliqués dans queue() — pas dans chokidar)
+		globalIgnored: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+
+		ignoreInitial: true,
+		awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 10 },
+
+		// Si FS weird (OneDrive, réseau, WSL/Docker bind mount), mets true:
+		usePolling: false,
+		interval: 200,
+		binaryInterval: 300,
+
+		debug: true,
+		...options,
+	};
+
+	const handles = [];
+
+	for (const rule of rules) {
+		if (!rule || typeof rule.callback !== "function") {
+			throw new Error("Each rule must have a callback(events, ctx).");
+		}
+
+		const name = rule.name || "rule";
+		const patterns = normalizePatterns(rule.patterns);
+
+		// include matchers (relatif à cwd, en posix)
+		const includeMatchers = patterns.map(globToRegExp);
+
+		// ignore matchers (relatif à cwd, en posix)
+		const ignoreMatchers = compileIgnoreMatchers([
+			...(opt.globalIgnored || []),
+			...(rule.ignored || []),
+		]);
+
+		// baseDirs à watcher
+		const baseDirs = Array.from(new Set(patterns.map(globBaseDir).map((d) => d || ".")))
+			.map((d) => path.resolve(opt.cwd, d));
+
+		if (opt.debug) {
+			console.log(`\n[${name}] starting watcher`);
+			console.log("  cwd:", opt.cwd);
+			console.log("  patterns:", patterns);
+			console.log("  baseDirs:", baseDirs);
+			console.log("  ignored (applied in queue):", [...(opt.globalIgnored || []), ...(rule.ignored || [])]);
+			console.log("");
+		}
+
+		const pending = new Map();
+		let timer = null;
+		let running = false;
+		let rerun = false;
+
+		const flush = async () => {
+			if (running) { rerun = true; return; }
+			running = true;
+			try {
+				do {
+					rerun = false;
+					const batch = Array.from(pending.values());
+					pending.clear();
+					if (batch.length) await rule.callback(batch, { rule });
+				} while (rerun);
+			} finally {
+				running = false;
+			}
+		};
+
+		const queue = (type, absPath) => {
+			const rel = toPosix(path.relative(opt.cwd, absPath));
+
+			// ignore d'abord
+			if (isIgnoredPosix(rel, ignoreMatchers)) {
+				// if (opt.debug) console.log(`[${name}] ignored`, type, rel);
+				return;
+			}
+
+			// include ensuite
+			const ok = includeMatchers.some((rx) => rx.test(rel));
+			if (!ok) return;
+
+			if (opt.debug) console.log(`[${name}] queue`, type, rel);
+
+			pending.set(`${type}:${rel}`, { type, file: rel });
+			clearTimeout(timer);
+			timer = setTimeout(flush, rule.debounceMs ?? 150);
+		};
+
+		// ⚠️ IMPORTANT: on ne met PAS "ignored" ici
+		const watcher = chokidar.watch(baseDirs, {
+			ignoreInitial: opt.ignoreInitial,
+			awaitWriteFinish: opt.awaitWriteFinish,
+			persistent: true,
+			usePolling: opt.usePolling,
+			interval: opt.interval,
+			binaryInterval: opt.binaryInterval,
+		});
+
+		// watcher.on("ready", () => {
+		// 	console.log(`[${name}] ready`);
+		// });
+
+		// watcher.on("add", (p) => queue("add", p));
+		watcher.on("change", (p) => queue("change", p));
+		// watcher.on("unlink", (p) => queue("unlink", p));
+		watcher.on("error", (err) => console.error(`[${name}] watch error:`, err));
+
+		handles.push({
+			watcher,
+			stopTimers: () => { clearTimeout(timer); pending.clear(); }
+		});
+	}
+
+	return {
+		close: async () => {
+			for (const h of handles) h.stopTimers();
+			await Promise.all(handles.map((h) => h.watcher.close()));
+		},
+	};
+}
+
+module.exports = { createWatchers };

package/src/watcher.js

@@ -1,412 +0,0 @@
-const chokidar = require("chokidar");
-const fs = require("node:fs");
-const fsprom = require('fs/promises');
-const path = require("path");
-const esbuild = require("esbuild");
-const sass = require("sass");
-const csso = require("csso");
-const pxpros = require("pxpros");
-const ignore = require('ignore');
-
-const ROOT = process.cwd();
-
-function toPosix(p) {
-	return p.replace(/\\/g, "/");
-}
-
-function normalizePatterns(patterns) {
-	return Array.isArray(patterns) ? patterns : [patterns];
-}
-
-function globBaseDir(glob) {
-	const g = toPosix(glob);
-	const idx = g.search(/[*?\[]/);
-	if (idx === -1) return g;
-	const base = g.slice(0, idx);
-	return base.replace(/\/+$/, "") || ".";
-}
-
-function globToRegExp(glob) {
-	const g = toPosix(glob);
-
-	let re = "^";
-	for (let i = 0; i < g.length; i++) {
-		const c = g[i];
-
-		if (c === "*" && g[i + 1] === "*") {
-			i++;
-			if (g[i + 1] === "/") {
-				i++;
-				re += "(?:.*/)?";
-			} else {
-				re += ".*";
-			}
-			continue;
-		}
-
-		if (c === "*") { re += "[^/]*"; continue; }
-		if (c === "?") { re += "[^/]"; continue; }
-
-		if ("\\.[]{}()+-^$|".includes(c)) re += "\\" + c;
-		else re += c;
-	}
-	re += "$";
-	return new RegExp(re);
-}
-
-function isIgnoredPosix(relPosix, ignoreMatchers) {
-	for (const m of ignoreMatchers) {
-		if (m instanceof RegExp) {
-			if (m.test(relPosix)) return true;
-		} else if (typeof m === "function") {
-			// si l'user fournit une fonction ignorée, on lui passe le rel posix
-			if (m(relPosix)) return true;
-		} else if (typeof m === "string") {
-			// strings glob déjà compilées dans ignoreMatchers (voir compileIgnoreMatchers)
-			// (fallback: on ne devrait pas arriver ici)
-			if (globToRegExp(m).test(relPosix)) return true;
-		}
-	}
-	return false;
-}
-
-function compileIgnoreMatchers(ignoreList) {
-	return (ignoreList || []).map((ig) => {
-		if (ig instanceof RegExp) return ig;
-		if (typeof ig === "function") return ig;
-		// string glob -> RegExp
-		return globToRegExp(ig);
-	});
-}
-
-/**
- * createWatchers(rules, options)
- * - Watch les dossiers racines (baseDirs)
- * - Filtre include via globs (rule.patterns)
- * - Filtre ignore via globs/regex (globalIgnored + rule.ignored)
- */
-function createWatchers(rules, options = {}) {
-	const opt = {
-		cwd: process.cwd(),
-
-		// Ignorés globaux (appliqués dans queue() — pas dans chokidar)
-		globalIgnored: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
-
-		ignoreInitial: true,
-		awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 10 },
-
-		// Si FS weird (OneDrive, réseau, WSL/Docker bind mount), mets true:
-		usePolling: false,
-		interval: 200,
-		binaryInterval: 300,
-
-		debug: true,
-		...options,
-	};
-
-	const handles = [];
-
-	for (const rule of rules) {
-		if (!rule || typeof rule.callback !== "function") {
-			throw new Error("Each rule must have a callback(events, ctx).");
-		}
-
-		const name = rule.name || "rule";
-		const patterns = normalizePatterns(rule.patterns);
-
-		// include matchers (relatif à cwd, en posix)
-		const includeMatchers = patterns.map(globToRegExp);
-
-		// ignore matchers (relatif à cwd, en posix)
-		const ignoreMatchers = compileIgnoreMatchers([
-			...(opt.globalIgnored || []),
-			...(rule.ignored || []),
-		]);
-
-		// baseDirs à watcher
-		const baseDirs = Array.from(new Set(patterns.map(globBaseDir).map((d) => d || ".")))
-			.map((d) => path.resolve(opt.cwd, d));
-
-		if (opt.debug) {
-			console.log(`\n[${name}] starting watcher`);
-			console.log("  cwd:", opt.cwd);
-			console.log("  patterns:", patterns);
-			console.log("  baseDirs:", baseDirs);
-			console.log("  ignored (applied in queue):", [...(opt.globalIgnored || []), ...(rule.ignored || [])]);
-			console.log("");
-		}
-
-		const pending = new Map();
-		let timer = null;
-		let running = false;
-		let rerun = false;
-
-		const flush = async () => {
-			if (running) { rerun = true; return; }
-			running = true;
-			try {
-				do {
-					rerun = false;
-					const batch = Array.from(pending.values());
-					pending.clear();
-					if (batch.length) await rule.callback(batch, { rule });
-				} while (rerun);
-			} finally {
-				running = false;
-			}
-		};
-
-		const queue = (type, absPath) => {
-			const rel = toPosix(path.relative(opt.cwd, absPath));
-
-			// ignore d'abord
-			if (isIgnoredPosix(rel, ignoreMatchers)) {
-				// if (opt.debug) console.log(`[${name}] ignored`, type, rel);
-				return;
-			}
-
-			// include ensuite
-			const ok = includeMatchers.some((rx) => rx.test(rel));
-			if (!ok) return;
-
-			if (opt.debug) console.log(`[${name}] queue`, type, rel);
-
-			pending.set(`${type}:${rel}`, { type, file: rel });
-			clearTimeout(timer);
-			timer = setTimeout(flush, rule.debounceMs ?? 150);
-		};
-
-		// ⚠️ IMPORTANT: on ne met PAS "ignored" ici
-		const watcher = chokidar.watch(baseDirs, {
-			ignoreInitial: opt.ignoreInitial,
-			awaitWriteFinish: opt.awaitWriteFinish,
-			persistent: true,
-			usePolling: opt.usePolling,
-			interval: opt.interval,
-			binaryInterval: opt.binaryInterval,
-		});
-
-		// watcher.on("ready", () => {
-		// 	console.log(`[${name}] ready`);
-		// });
-
-		// watcher.on("add", (p) => queue("add", p));
-		watcher.on("change", (p) => queue("change", p));
-		// watcher.on("unlink", (p) => queue("unlink", p));
-		watcher.on("error", (err) => console.error(`[${name}] watch error:`, err));
-
-		handles.push({
-			watcher,
-			stopTimers: () => { clearTimeout(timer); pending.clear(); }
-		});
-	}
-
-	return {
-		close: async () => {
-			for (const h of handles) h.stopTimers();
-			await Promise.all(handles.map((h) => h.watcher.close()));
-		},
-	};
-}
-
-
-const buildCSS = async (inputScss, outCssMin, options = {}) => {
-	let compiled;
-	try {
-		compiled = sass.compile(inputScss, {
-			loadPaths: [path.resolve(process.cwd(), "./node_modules")],
-			style: "compressed",
-			sourceMap: false,
-			sourceMapIncludeSources: false,
-			...options
-		});
-		const minified = csso.minify(compiled.css, { restructure: false });
-		fs.writeFileSync(outCssMin, minified.css);
-		console.log(`✅ CSS generated: ${outCssMin}`);
-	} catch (err) {
-		console.error("❌ Sass compile error:");
-		console.error(err?.formatted || err?.message || err);
-	}
-}
-
-
-const buildJS = async (entry, outfile, options = {}) => {
-	try {
-		await esbuild.build({
-			entryPoints: [entry],
-			outfile,
-			bundle: true,
-			platform: "browser",
-			logLevel: "error",
-			treeShaking: true,
-			minify: true,
-			supported: { "template-literal": false },
-			target: ["es2020"],
-			legalComments: "none",
-			...options
-		});
-		console.log(`✅ JS generated: ${outfile}`);
-	} catch (err) {
-		console.error("❌ esbuild build failed.");
-		if (err?.errors?.length) {
-			const formatted = await esbuild.formatMessages(err.errors, {
-				kind: "error",
-				color: true,
-				terminalWidth: process.stdout.columns || 80,
-			});
-			console.error(formatted.join("\n"));
-		} else {
-			console.error(err);
-		}
-	}
-}
-
-
-const buildPHP = async (file) => {
-	const results = await pxpros.render(file);
-	if(results.success) {
-		results.files.forEach(file => console.log(`✅ HTML generated: ${file}`));
-	} else {
-		console.error("❌ pxpros render failed.");
-		console.error(results.error);
-	}
-}
-
-
-const buildSitemap = async (file) => {
-	const results = await pxpros.sitemap(file);
-	if(results.success) {
-		results.files.forEach(file => console.log(`✅ XML Sitemap generated: ${file}`));
-	} else {
-		console.error("❌ pxpros sitemap creation failed.");
-		console.error(results.error);
-	}
-}
-
-
-async function emptyDir(dir) {
-	await fsprom.mkdir(dir, { recursive: true });
-	const entries = await fsprom.readdir(dir, { withFileTypes: true });
-	await Promise.all(entries.map((e) => fsprom.rm(path.join(dir, e.name), { recursive: true, force: true })));
-}
-
-
-function formatFrDate(dateInput = new Date(), timeZone = 'America/Toronto') {
-	const d = (dateInput instanceof Date) ? dateInput : new Date(dateInput);
-	const fmt = new Intl.DateTimeFormat('fr-CA', {
-		weekday: 'long',
-		day: 'numeric',
-		month: 'long',
-		year: 'numeric',
-		hour: 'numeric',
-		minute: '2-digit',
-		hour12: false,
-		timeZone
-	});
-	const parts = Object.fromEntries(fmt.formatToParts(d).map(p => [p.type, p.value]));
-	const weekday = parts.weekday.charAt(0).toUpperCase() + parts.weekday.slice(1); // "Samedi"
-	return `${weekday} le ${parts.day} ${parts.month} ${parts.year} à ${parts.hour} h ${parts.minute}`;
-}
-
-
-function norm(p) {
-	// normalise en chemin POSIX pour compat .gitignore
-	return p.split(path.sep).join('/');
-}
-
-async function loadGitignore() {
-	const ig = ignore();
-	const giPath = path.join(ROOT, '.gitignore');
-	if (fs.existsSync(giPath)) {
-		const txt = await fsprom.readFile(giPath, 'utf8');
-		ig.add(txt);
-	}
-	// on ignore aussi le dossier dist par sécurité (pas nécessaire mais sain)
-	ig.add('dist/');
-	return ig;
-}
-
-async function rmDir(dir) {
-	await fsprom.rm(dir, { recursive: true, force: true });
-	await fsprom.mkdir(dir, { recursive: true });
-}
-
-function shouldExcludeFile(relFromRoot, absPath) {
-	// Exclusions de type/extension
-	const lower = absPath.toLowerCase();
-	if (path.basename(lower).startsWith('_')) return true;
-	if (lower.endsWith('.scss')) return true;
-	if (lower.endsWith('.js') && !lower.endsWith('.min.js')) return true;
-	return false;
-}
-
-async function copyFilePreserveTree(absSrc, src, dist, ig) {
-	const relFromSrc = path.relative(src, absSrc);
-	const relFromRoot = path.relative(ROOT, absSrc);
-	const relPosix = norm(relFromRoot);
-
-	// 1) Exclusions via .gitignore
-	if (ig.ignores(relPosix)) return false;
-
-	// 2) Exclusions spécifiques (scss, js non minifiés)
-	if (shouldExcludeFile(relPosix, absSrc)) return false;
-
-	const absDst = path.join(dist, relFromSrc);
-	// console.log(absDst);
-	await fsprom.mkdir(path.dirname(absDst), { recursive: true });
-	await fsprom.copyFile(absSrc, absDst);
-	return absDst;
-}
-
-async function walkAndCopy(dir, src, dest, ig, stats, banner = null) {
-	const entries = await fsprom.readdir(dir, { withFileTypes: true });
-	const bannerContent = (await fsprom.readFile(banner || path.join(__dirname, 'banner.txt'), 'utf8')).replace(/###DATE###/, formatFrDate());
-	const today = (d => `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`)(new Date());
-
-	for (const de of entries) {
-		const abs = path.join(dir, de.name);
-		const relFromRoot = path.relative(ROOT, abs);
-		const relPosix = norm(relFromRoot);
-
-		if (de.isDirectory()) {
-			// Si le dossier est ignoré par .gitignore, on ne descend pas
-			if (ig.ignores(relPosix + '/')) continue;
-			if(de.name.startsWith('_')) continue;
-			await walkAndCopy(abs, src, dest, ig, stats, banner);
-		} else if (de.isFile()) {
-			const copied = await copyFilePreserveTree(abs, src, dest, ig);
-			if (copied) {
-				const lower = abs.toLowerCase();
-				if (lower.endsWith('.js')) await fsprom.writeFile(copied, "/*!\n\n" + bannerContent + "\n\n*/\n" + (await fsprom.readFile(copied, 'utf8')), "utf8");
-				else if (lower.endsWith('.css')) await fsprom.writeFile(copied, "/*!\n\n" + bannerContent + "\n\n*/\n" + (await fsprom.readFile(copied, 'utf8')), "utf8");
-				else if (lower.endsWith('.html')) await fsprom.writeFile(copied, "<!--\n\n" + bannerContent + "\n\n\-->\n" + (await fsprom.readFile(copied, 'utf8'))
-					.replaceAll(/###YEAR###/g, (new Date).getFullYear())
-					.replaceAll(/###TIMESTAMP###/g, Math.floor(Date.now() / 1000)), "utf8");
-				else if (lower.endsWith('sitemap.xml')) await fsprom.writeFile(copied, (await fsprom.readFile(copied, 'utf8')).replaceAll(/###TODAY###/g, today), "utf8");
-				stats.copied++;
-			}
-			else stats.skipped++;
-		}
-		// (symlinks & autres: ignorés)
-	}
-}
-
-
-const exportDist = async (src, dist, banner = null) => {
-	try {
-		const ig = await loadGitignore();
-
-		await emptyDir(dist);
-		if (!fs.existsSync(src)) throw new error('Folder src is invalid.');
-
-		const stats = { copied: 0, skipped: 0 };
-		await walkAndCopy(src, src, dist, ig, stats, banner);
-
-		return stats;
-	} catch (err) {
-		throw new error(err);
-	}
-}
-
-
-module.exports = { createWatchers, exportDist, buildCSS, buildJS, buildPHP, buildSitemap };