chokibasic 1.1.11 → 1.2.0

package/index.d.ts

@@ -1,5 +1,23 @@
-
 declare namespace chokibasic {
+  // --- NOUVEAUX TYPES POUR buildConf ---
+
+  /** 
+   * Callback pour buildConf. 
+   * Reçoit le contenu brut (Buffer) et le chemin relatif du fichier.
+   * Doit retourner la nouvelle valeur (string, objet, etc.) qui remplacera le chemin dans le JSON final.
+   */
+  export type BuildConfCallback = (content: Buffer, relPath: string) => any | Promise<any>;
+
+  /** 
+   * Dictionnaire de patterns globaux associés à des callbacks de transformation.
+   * Exemple: { "** / *.mid": (buf) => processMidi(buf) }
+   */
+  export interface BuildConfMatchers {
+    [glob: string]: BuildConfCallback;
+  }
+
+  // --- TYPES EXISTANTS ---
+
   export type GlobPattern = string;
 
   export type IgnoreMatcher =
@@ -10,9 +28,7 @@ declare namespace chokibasic {
   export type WatchEventType = "add" | "change" | "unlink" | (string & {});
 
   export interface WatchEvent {
-    /** Type d’évènement (dans le code actuel: surtout "change") */
     type: WatchEventType;
-    /** Chemin relatif à cwd, normalisé POSIX (slash "/") */
     file: string;
   }
 
@@ -21,22 +37,10 @@ declare namespace chokibasic {
   }
 
   export interface WatchRule {
-    /** Nom affiché en debug */
     name?: string;
-
-    /** Globs d’inclusion (ex: "src/styles/ ** / *.scss") */
     patterns: GlobPattern | GlobPattern[];
-
-    /** Ignorés additionnels (globs / regex / function) */
     ignored?: IgnoreMatcher[];
-
-    /** Debounce en ms (défaut: 150) */
     debounceMs?: number;
-
-    /**
-     * Callback appelé avec un batch d’évènements.
-     * Le batch contient des objets { type, file }.
-     */
     callback: (events: WatchEvent[], ctx: WatchRuleContext) => void | Promise<void>;
   }
 
@@ -46,39 +50,18 @@ declare namespace chokibasic {
   }
 
   export interface CreateWatchersOptions {
-    /** Répertoire racine utilisé pour calculer les chemins relatifs */
     cwd?: string;
-
-    /**
-     * Ignorés globaux (appliqués dans queue(), pas via chokidar "ignored")
-     * Défaut: ["** /node_modules/ **","** /.git/ **","** /dist/ **"]
-     */
     globalIgnored?: string[];
-
-    /** chokidar: ignoreInitial */
     ignoreInitial?: boolean;
-
-    /** chokidar: awaitWriteFinish */
     awaitWriteFinish?: boolean | AwaitWriteFinishOptions;
-
-    /** chokidar: usePolling */
     usePolling?: boolean;
-
-    /** chokidar: interval */
     interval?: number;
-
-    /** chokidar: binaryInterval */
     binaryInterval?: number;
-
-    /** Log console */
     debug?: boolean;
-
-    /** 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>;
   }
 
@@ -87,59 +70,61 @@ declare namespace chokibasic {
     skipped: number;
   }
 
-  /** Options forwardées à esbuild.build() */
-  export type BuildJSOptions = Parameters<typeof import("esbuild").build>[0];
+  export interface ExportDistOptions {
+    ignore?: string[];
+    include?: string[];
+    debug?: boolean;
+    filter?: (relPath: string) => boolean;
+  }
 
-  /** Options forwardées à sass.compile() */
+  export type BuildJSOptions = Parameters<typeof import("esbuild").build>[0];
   export type BuildCSSOptions = NonNullable<Parameters<typeof import("sass").compile>[1]>;
 
+  // --- FONCTIONS EXPORTÉES ---
+
   /**
-   * Crée un ou plusieurs watchers (un par règle).
+   * Transforme un fichier YAML en JSON en appliquant des transformations sur les fichiers référencés.
+   * @param src Chemin vers le fichier source YAML.
+   * @param dst Chemin vers le fichier de destination JSON.
+   * @param matchers Dictionnaire de patterns et callbacks de transformation.
    */
+  export function buildConf(
+    src: string,
+    dst: string,
+    matchers?: BuildConfMatchers
+  ): Promise<void>;
+
   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
+    banner?: string | null,
+    options?: ExportDistOptions
   ): 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>;
 }
 
 declare const chokibasic: {
+  buildConf: typeof chokibasic.buildConf; // Ajouté ici aussi
   createWatchers: typeof chokibasic.createWatchers;
   exportDist: typeof chokibasic.exportDist;
   buildCSS: typeof chokibasic.buildCSS;
@@ -149,4 +134,4 @@ declare const chokibasic: {
 };
 
 export = chokibasic;
-export as namespace chokibasic;
+export as namespace chokibasic;

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chokibasic",
-  "version": "1.1.11",
+  "version": "1.2.0",
   "description": "Basic chokidar watcher + pxpros + esbuild + sass + csso helpers",
   "main": "index.js",
   "types": "index.d.ts",
@@ -35,6 +35,8 @@
     "csso": "^5.0.5",
     "esbuild": "^0.28.0",
     "ignore": "^7.0.5",
+    "js-yaml": "^4.1.1",
+    "picomatch": "^4.0.4",
     "pxpros": "^1.1.3",
     "sass": "^1.99.0"
   }

package/readme.md

@@ -9,7 +9,7 @@ Tiny build & watch helpers for simple static projects.
 - `buildJS(entry, outfile, options?)`
 - `buildPHP(file)`
 - `buildSitemap(file)`
-- `exportDist(src, dist, bannerPath?)`
+- `exportDist(src, dist, bannerPath?, options?)`
 
 ---
 

package/src/buildconf.js

@@ -0,0 +1,61 @@
+const fs = require("fs").promises;
+const path = require("path");
+const yaml = require("js-yaml");
+const pm = require("picomatch");
+
+const ROOT = process.cwd();
+
+/**
+ * Parcourt récursivement la configuration et transforme les valeurs
+ * si elles correspondent à un fichier existant et à un pattern défini.
+ */
+async function walkAndTransform(node, matchers) {
+    if (Array.isArray(node)) {
+        return await Promise.all(node.map(item => walkAndTransform(item, matchers)));
+    }
+
+    if (typeof node === 'object' && node !== null) {
+        const newNode = {};
+        for (const [key, value] of Object.entries(node)) {
+            newNode[key] = await walkAndTransform(value, matchers);
+        }
+        return newNode;
+    }
+
+    if (typeof node === 'string') {
+        const fullPath = path.join(ROOT, node);
+        try {
+            const stats = await fs.stat(fullPath);
+            if (stats.isFile()) {
+                for (const [pattern, callback] of Object.entries(matchers)) {
+                    const isMatch = pm(pattern);
+                    if (isMatch(node)) {
+                        const content = await fs.readFile(fullPath);
+                        return await callback(content, node);
+                    }
+                }
+            }
+        } catch (err) {
+        }
+    }
+
+    return node;
+}
+
+/**
+ * Fonction principale buildConf
+ */
+async function buildConf(src, dst, matchers = {}) {
+    try {
+        const fileContents = await fs.readFile(src, 'utf8');
+        const rawData = yaml.load(fileContents);
+        const processedData = await walkAndTransform(rawData, matchers);
+        const jsonContent = JSON.stringify(processedData, null, 2);
+        await fs.writeFile(dst, jsonContent, 'utf8');
+        console.log(`✅ Build de la configuration réussi : ${dst}`);
+    } catch (error) {
+        console.error("❌ Erreur lors du buildConf :", error);
+    }
+}
+
+module.exports = { buildConf };

package/src/export.js

@@ -5,14 +5,14 @@ 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 })));
+	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', {
@@ -26,109 +26,164 @@ function formatFrDate(dateInput = new Date(), timeZone = 'America/Toronto') {
 		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"
+	const weekday = parts.weekday.charAt(0).toUpperCase() + parts.weekday.slice(1);
 	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() {
+async function loadGitignore(src, extraPatterns = []) {
 	const ig = ignore();
 	const giPath = path.join(ROOT, '.gitignore');
+
 	if (fs.existsSync(giPath)) {
 		const txt = await fsprom.readFile(giPath, 'utf8');
-		ig.add(txt);
+
+		// ⚠️ IMPORTANT: on convert les patterns ROOT → relatifs à src
+		const lines = txt.split('\n')
+			.map(l => l.trim())
+			.filter(l => l && !l.startsWith('#'))
+			.map(l => {
+				// enlever "/" initial si présent
+				return l.replace(/^\//, '');
+			});
+
+		ig.add(lines);
 	}
-	// on ignore aussi le dossier dist par sécurité (pas nécessaire mais sain)
+
+	// Toujours ignorer dist (relatif ROOT → on garde tel quel)
 	ig.add('dist/');
-	return ig;
-}
 
-async function rmDir(dir) {
-	await fsprom.rm(dir, { recursive: true, force: true });
-	await fsprom.mkdir(dir, { recursive: true });
+	// 👇 Patterns custom (déjà relatifs à src)
+	if (Array.isArray(extraPatterns)) {
+		ig.add(extraPatterns);
+	}
+
+	return ig;
 }
 
-function shouldExcludeFile(relFromRoot, absPath) {
-	// Exclusions de type/extension
+function shouldExcludeFile(relFromSrc, absPath) {
 	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);
+	const relPosix = norm(relFromSrc);
 
-	// 1) Exclusions via .gitignore
+	// 1) ignore basé sur src
 	if (ig.ignores(relPosix)) return false;
 
-	// 2) Exclusions spécifiques (scss, js non minifiés)
+	// 2) exclusions internes
 	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());
+
+	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);
+		const relFromSrc = path.relative(src, abs);
+		const relPosix = norm(relFromSrc);
 
 		if (de.isDirectory()) {
-			// Si le dossier est ignoré par .gitignore, on ne descend pas
 			if (ig.ignores(relPosix + '/')) continue;
-			if(de.name.startsWith('_')) continue;
+			if (de.name.startsWith('_')) continue;
+
 			await walkAndCopy(abs, src, dest, ig, stats, banner);
-		} else if (de.isFile()) {
+		}
+		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");
+
+				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++;
+			else {
+				stats.skipped++;
+			}
 		}
-		// (symlinks & autres: ignorés)
 	}
 }
 
-
-const exportDist = async (src, dist, banner = null) => {
+const exportDist = async (src, dist, banner = null, options = {}) => {
 	try {
-		const ig = await loadGitignore();
+		const ig = await loadGitignore(src, options.ignore || []);
 
 		await emptyDir(dist);
-		if (!fs.existsSync(src)) throw new error('Folder src is invalid.');
+
+		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);
+		throw new Error(err);
 	}
-}
-
+};
 
-module.exports = { exportDist };
+module.exports = { exportDist };