chokibasic 1.2.0 → 1.2.2

package/package.json

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

package/src/buildconf.js

@@ -1,60 +1,73 @@
-const fs = require("fs").promises;
+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) {
+
+async function getMetadata() {
+    let version = "0.0.0";
+    try {
+        const pkg = JSON.parse(await fs.readFile(path.join(ROOT, "package.json"), "utf8"));
+        version = pkg.version || version;
+    } catch (e) {}
+
+    const now = new Date();
+    const pad = (n) => n.toString().padStart(2, '0');
+    const dateStr = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+
+    return { version, date: dateStr };
+}
+
+
+async function walkAndTransform(node, matchers, metadata) {
     if (Array.isArray(node)) {
-        return await Promise.all(node.map(item => walkAndTransform(item, matchers)));
+        return await Promise.all(node.map(item => walkAndTransform(item, matchers, metadata)));
     }
 
     if (typeof node === 'object' && node !== null) {
         const newNode = {};
         for (const [key, value] of Object.entries(node)) {
-            newNode[key] = await walkAndTransform(value, matchers);
+            newNode[key] = await walkAndTransform(value, matchers, metadata);
         }
         return newNode;
     }
 
     if (typeof node === 'string') {
-        const fullPath = path.join(ROOT, node);
+        let processedString = node
+            .replace(/__VERSION__/g, metadata.version)
+            .replace(/__DATE__/g, metadata.date);
+
+        const fullPath = path.join(ROOT, processedString);
         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)) {
+                    if (pm(pattern)(processedString)) {
                         const content = await fs.readFile(fullPath);
-                        return await callback(content, node);
+                        return await callback(content, processedString);
                     }
                 }
             }
-        } catch (err) {
-        }
+        } catch (err) {}
+        return processedString;
     }
 
     return node;
 }
 
-/**
- * Fonction principale buildConf
- */
+
 async function buildConf(src, dst, matchers = {}) {
     try {
+        const metadata = await getMetadata();
         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}`);
+        const processedData = await walkAndTransform(rawData, matchers, metadata);
+        await fs.writeFile(dst, JSON.stringify(processedData, null, 2), 'utf8');
+        console.log(`✅ JSON generated: ${dst}`);
     } catch (error) {
-        console.error("❌ Erreur lors du buildConf :", error);
+        console.error("❌ Error:", error);
     }
 }
 

package/src/export.js

@@ -41,22 +41,18 @@ async function loadGitignore(src, extraPatterns = []) {
 	if (fs.existsSync(giPath)) {
 		const txt = await fsprom.readFile(giPath, 'utf8');
 
-		// ⚠️ 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);
 	}
 
-	// Toujours ignorer dist (relatif ROOT → on garde tel quel)
 	ig.add('dist/');
 
-	// 👇 Patterns custom (déjà relatifs à src)
 	if (Array.isArray(extraPatterns)) {
 		ig.add(extraPatterns);
 	}
@@ -78,10 +74,8 @@ async function copyFilePreserveTree(absSrc, src, dist, ig) {
 	const relFromSrc = path.relative(src, absSrc);
 	const relPosix = norm(relFromSrc);
 
-	// 1) ignore basé sur src
 	if (ig.ignores(relPosix)) return false;
 
-	// 2) exclusions internes
 	if (shouldExcludeFile(relPosix, absSrc)) return false;
 
 	const absDst = path.join(dist, relFromSrc);
@@ -168,19 +162,11 @@ async function walkAndCopy(dir, src, dest, ig, stats, banner = null) {
 const exportDist = async (src, dist, banner = null, options = {}) => {
 	try {
 		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);
 	}