@kirigami/php-prepros 1.1.0 → 1.2.0

package/src/prepros.js

@@ -8,6 +8,7 @@ import { walkFile } from '@kirigami/struct-walker';
 import { getPHPRuntime, getPHPRuntimeWithNetwork } from "@kirigami/php-wasm";
 
 
+const __modules = new Map;
 const __project = process.cwd();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const __configpath = path.join(__project, 'kirigami.yaml');
@@ -20,14 +21,19 @@ const config = await walkFile(__configpath);
 if(!config) throw `Invalid config file: ${__configpath}`;
 
 
-
 const getPHPInstance = async () => {
     if(!__php) {
         if(config?.kirigami?.root === undefined) throw `Missing prepros:root property in config file: ${__configpath}`;
         __root = path.join(__project, config.kirigami.root);
         if (!fs.existsSync(__root)) throw `Invalid prepros:root path: ${__root}`;
 
+        if(!config.image) config.image = {};
+        if(!config.image.format) config.image.format = 'webp';
+        if(!config.image.source) config.image.source = 'assets/images/';
+        if(!config.image.dest) config.image.dest = 'images/';
+
         const preprosConfig = config.prepros || {};
+        preprosConfig.image = config.image;
         preprosConfig.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         preprosConfig.root = joinWith('/project/', config?.kirigami?.root);
         preprosConfig.data = config.kirigami || {};
@@ -35,24 +41,35 @@ const getPHPInstance = async () => {
         __php = await (preprosConfig.network ? getPHPRuntimeWithNetwork() : getPHPRuntime());
         __php.setSpawnHandler((command, args, options) => spawn(command, args, options));
         __php.preprosConfig = preprosConfig;
+        __php.setIniValues({
+            log_errors:      1,
+            html_errors:     0,
+            display_errors:  1,
+            error_reporting: 32767,
+            error_log:       'php://stderr',
+            memory_limit:    '2G',
+        });
+
+        await mountPath(__dirname, '/prepros', __php);
+        await mountPath(joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root), __php);
 
         const __cache = path.join(__project, '.cache.db');
         const __cookie = path.join(__project, '.cookie.txt');
-        mountPath(__php, __dirname, '/prepros');
-        mountPath(__php, joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root));
-
-        if (fs.existsSync(__cache)) mountPath(__php, __cache, '/project/.cache.db');
-        if (fs.existsSync(__cookie)) mountPath(__php, __cookie, '/project/.cookie.txt');
+        if (fs.existsSync(__cache)) await mountPath(__cache, '/project/.cache.db', __php);
+        if (fs.existsSync(__cookie)) await mountPath(__cookie, '/project/.cookie.txt', __php);
 
-        __php.onMessage(async (data) => {
+        __php.onMessage(async data => {
             const msg = JSON.parse(data);
             if(!msg.command) return { success: false, error: "Invalid command."};
             const file = path.join(__dirname, 'phpjs', `${msg.command}.js`);
             if(!fs.existsSync(file)) return { success: false, error: "Invalid command."};
-
             try {
-                const cmdModule = await import(pathToFileURL(file).href);
-                const results = await cmdModule.default(__php, msg);
+                if(!__modules.has(msg.command)) {
+                    const cmdModule = await import(pathToFileURL(file).href);
+                    __modules.set(msg.command, cmdModule);
+                }
+                const mod = __modules.get(msg.command);
+                const results = await mod.default(__php, msg);
                 return JSON.stringify({
                     success: true,
                     results: results
@@ -63,35 +80,36 @@ const getPHPInstance = async () => {
                     error: typeof e == 'string' ? e : e.message
                 }
             }
-
-
-            // console.log(msg);
-            // console.log(__dirname);
-
         });
     }
     return __php;
 }
 
 
-const mountPath = (php, localPath, virtualDir) => {
+const mountPath = async (localPath, virtualDir, php) => {
+    php = php || await getPHPInstance();
+    if(!path.isAbsolute(localPath)) localPath = path.join(__project, localPath);
+    virtualDir = virtualDir || path.posix.join('/project', localPath.replace(__project + path.sep, ''));
     const includeExtensions = new Set(['.php', '.json', '.yaml', '.yml', '.md', '.db', '.txt', ...(config?.prepros?.mountext || [])]);
     const stat = fs.statSync(localPath);
     if (stat.isDirectory()) {
         php.mkdirTree(virtualDir);
         for (const entry of fs.readdirSync(localPath, { withFileTypes: true })) {
-            mountPath(php, path.join(localPath, entry.name), virtualDir + '/' + entry.name);
-        }
-    } else {
-        const ext = path.extname(localPath).toLowerCase();
-        if (includeExtensions.has(ext)) {
-            const buf = fs.readFileSync(localPath);
-            const parentDir = virtualDir.substring(0, virtualDir.lastIndexOf('/'));
-            if (parentDir) {
-                php.mkdirTree(parentDir);
+            const target = path.join(localPath, entry.name);
+            if(!fs.statSync(target).isDirectory()) {
+                const ext = path.extname(target).toLowerCase();
+                if (includeExtensions.has(ext)) {
+                    await mountPath(target, virtualDir + '/' + entry.name, php);
+                }
+            } else {
+                await mountPath(target, virtualDir + '/' + entry.name, php);
             }
-            php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
         }
+    } else {
+        const buf = fs.readFileSync(localPath);
+        const parentDir = virtualDir.substring(0, virtualDir.lastIndexOf('/'));
+        if (parentDir) php.mkdirTree(parentDir);
+        php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
     }
 }
 
@@ -129,7 +147,6 @@ const run = async (args = [], script = null, mountfiles = []) => {
             const buffer = php.readFileAsBuffer(resultPath);
             retobj = JSON.parse(Buffer.from(buffer).toString('utf8'));
             retobj.debug = stdout;
-
             if(retobj.files) await Promise.all(retobj.files.map(async (file, i) => {
                 const fbuffer = php.readFileAsBuffer(file);
                 const dest = file.replace(/^\/project\//i, '');
@@ -167,29 +184,19 @@ const runenv = async (script, paths = [], ...args) => {
 
 
 const render = async (file = '.') => {
-    const php = await getPHPInstance();
-    const target = path.resolve(__project, config?.kirigami?.root, file);
+    const target = path.resolve(config?.kirigami?.root, file);
     const fsvm = path.join('/project', config?.kirigami?.root, file).replace(/\\/g, '/');
-    mountPath(php, target, fsvm);
-    if(config?.prepros?.before) {
-        const include = path.resolve(__project, config?.kirigami?.root, config?.prepros?.before);
-        const dest = path.join('/project', config?.kirigami?.root, config?.prepros?.before).replace(/\\/g, '/');
-        mountPath(php, include, dest);
-    }
-    if(config?.prepros?.after) {
-        const include = path.resolve(__project, config?.kirigami?.root, config?.prepros?.after);
-        const dest = path.join('/project', config?.kirigami?.root, config?.prepros?.after).replace(/\\/g, '/');
-        mountPath(php, include, dest);
-    }
+    await mountPath(target);
+    if(config?.prepros?.before) await mountPath(path.resolve(config?.kirigami?.root, config?.prepros?.before));
+    if(config?.prepros?.after) await mountPath(path.resolve(config?.kirigami?.root, config?.prepros?.after));
     return run([fsvm]);
 }
 
 
-const sitemap = async (dir) => {
-    const php = await getPHPInstance();
-    mountPath(php, __root, '/project/' + config?.kirigami?.root);
+const sitemap = async () => {
+    await mountPath(config?.kirigami?.root);
     return run(['sitemap']);
 }
 
 
-export { runenv, render, sitemap };
+export { runenv, render, sitemap, mountPath };

package/src/utils/getfilestats.js

@@ -0,0 +1,30 @@
+import { stat } from 'node:fs/promises';
+
+/**
+ * Gets a file's information.
+ * @param {string} filePath - the file path
+ * @returns {Promise<object>} object holding the file's info
+ */
+async function getFileStats(filePath) {
+	try {
+		const stats = await stat(filePath);
+
+		return {
+			exists: true,
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			size: stats.size, // in bytes
+			createdAt: stats.birthtime,
+			modifiedAt: stats.mtime,
+			accessedAt: stats.atime,
+			changedAt: stats.ctime, // last metadata change
+		};
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			return { exists: false };
+		}
+		throw error; // other errors (permissions, etc.)
+	}
+}
+
+export default getFileStats;

package/src/utils/isbinary.js

@@ -1,5 +1,5 @@
-// Table de magic bytes compilée une seule fois au module load
-// Clé = premier octet, valeur = liste de signatures [octets, longueur à lire]
+// Magic-bytes table compiled once at module load
+// Key = first byte, value = list of signatures [bytes, length to read]
 const MAGIC_MAP = new Map([
 	[0x89, [[[0x89, 0x50, 0x4E, 0x47]]]],           // PNG
 	[0xFF, [[[0xFF, 0xD8, 0xFF]], [[0xFF, 0xFE]]]],  // JPEG, UTF-16 LE (text BOM)
@@ -14,20 +14,20 @@ const MAGIC_MAP = new Map([
 	[0x00, [[[0x00, 0x00, 0xFE, 0xFF]]]],             // UTF-32 BE BOM (text!)
 ]);
 
-// BOMs texte → jamais binaire, early exit immédiat
+// Text BOMs → never binary, immediate early exit
 const TEXT_BOMS = new Set([
 	'\xEF\xBB\xBF',   // UTF-8
 	'\xFF\xFE',        // UTF-16 LE
 	'\xFE\xFF',        // UTF-16 BE
 ]);
 
-const SAMPLE_SIZE = 512; // 8 Ko c'est inutile pour un mount local
+const SAMPLE_SIZE = 512; // 8 KB is overkill for a local mount
 
 /**
- * Détection binaire en 3 passes avec early exit agressif.
- * Optimisé pour être appelé sur des centaines de fichiers au démarrage.
+ * 3-pass binary detection with aggressive early exit.
+ * Optimized to be called on hundreds of files at startup.
  *
- * @param {Buffer} buf - Buffer du fichier (readFileSync)
+ * @param {Buffer} buf - the file's Buffer (readFileSync)
  * @returns {boolean}
  */
 function isBinary(buf) {
@@ -36,16 +36,16 @@ function isBinary(buf) {
 
 	const b0 = buf[0];
 
-	// Passe 1 — Magic bytes (O(1), max 4 comparaisons)
+	// Pass 1 — Magic bytes (O(1), max 4 comparisons)
 	const candidates = MAGIC_MAP.get(b0);
 	if (candidates) {
 		for (const sigs of candidates) {
 			for (const sig of sigs) {
 				if (sig.every((b, i) => buf[i] === b)) {
-					// BOM texte → sortie immédiate "text"
+					// Text BOM → immediate "text" exit
 					if (b0 === 0xEF || b0 === 0xFE || (b0 === 0xFF && buf[1] === 0xFE)) return false;
 					if (b0 === 0x00 && buf[1] === 0x00) return false; // UTF-32
-					return true; // Binaire confirmé
+					return true; // Binary confirmed
 				}
 			}
 		}
@@ -53,17 +53,17 @@ function isBinary(buf) {
 
 	const sample = Math.min(len, SAMPLE_SIZE);
 
-	// Passe 2 — Octet NUL (signal binaire quasi-certain, très fréquent dans les binaires)
-	// indexOf est natif C++ → beaucoup plus rapide qu'une boucle JS
+	// Pass 2 — NUL byte (a near-certain binary signal, very common in binaries)
+	// indexOf is native C++ → much faster than a JS loop
 	if (buf.indexOf(0x00, 0, 'binary') !== -1 &&
 		buf.indexOf(0x00) < sample) return true;
 
-	// Passe 3 — Ratio statistique sur l'échantillon
+	// Pass 3 — Statistical ratio over the sample
 	let nonText = 0;
 	for (let i = 0; i < sample; i++) {
 		const b = buf[i];
 		if (b < 0x20) {
-			// Caractères de contrôle légitimes en texte
+			// Control characters that are legitimate in text
 			if (b !== 0x09 && b !== 0x0A && b !== 0x0D && b !== 0x0C && b !== 0x1B) {
 				nonText++;
 			}

package/src/utils.inc.php

@@ -1,11 +1,4 @@
 <?php
-ini_set('log_errors', 1);
-ini_set('html_errors', 0);
-ini_set('display_errors', 1);
-ini_set('error_reporting', 32767);
-ini_set('error_log', 'php://stderr');
-error_reporting(E_ALL);
-
 
 const BR = '<br>';
 const RN = "\r\n";
@@ -14,13 +7,16 @@ const R = "\r";
 const N = "\n";
 
 
-function _print_r(mixed $obj) {
+function _print_r(mixed $obj, bool $ret = false) {
+    if($ret) return '<pre>' . print_r($obj, $ret) . '</pre>';
     echo '<pre>' . print_r($obj, true) . '</pre>';
 }
 
 
 spl_autoload_register(function ($class) {
     static $catalog = [
+
+        // Out of the box
         'ARR'             => 'arr.class.php',    
         'CACHE'           => 'cache.class.php',
         'CURL'            => 'curl.class.php',
@@ -28,12 +24,17 @@ spl_autoload_register(function ($class) {
         'HTML'            => 'html.class.php',
         'IMG'             => 'img.class.php',
         'MD'              => 'md.class.php',
+        'NORM'            => 'norm.class.php',
         'OBF'             => 'obf.class.php',
 		'PREPROS'         => 'prepros.class.php',
+        'SCHEMA'          => 'schema.class.php',
 		'SCRAPER'         => 'scraper.class.php',
         'STD'             => 'std.class.php',
         'STR'             => 'str.class.php',
         'YAML'            => 'yaml.class.php',
+
+        // Fallbacks
+        'Normalizer'      => 'normalizer.class.php'
     ];
     if (isset($catalog[$class])) require_once(__DIR__ . '/libraries/' . $catalog[$class]);
 }, true, true);