jopijs 0.0.1

package/src/@loader-tools/jopin.ts

@@ -0,0 +1,403 @@
+import fs from "node:fs";
+import {type ChildProcess, spawn} from "node:child_process";
+import path from "node:path";
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_os from "jopi-toolkit/jk_os";
+import * as jk_term from "jopi-toolkit/jk_term";
+import {SourceChangesWatcher} from "./sourceChangesWatcher.ts";
+
+// *************************
+const FORCE_LOG = false;
+const VERSION = "20251118a";
+// *************************
+
+let mustLog = false; // Set env var JOPI_LOG to 1 to enable.
+
+interface WatchInfos {
+    needHot: boolean;
+    needWatch: boolean;
+    needUiWatch: boolean;
+
+    hasJopiWatchTask?: boolean;
+    hasJopiBuildTask_node?: boolean;
+    hasJopiWatchTask_node?: boolean;
+    hasJopiWatchTask_bun?: boolean;
+    hasJopiBuildTask_bun?: boolean;
+
+    packageJsonFilePath?: string;
+}
+
+enum DevModType {
+    NONE = "none",
+    FULL_RELOAD = "full-reload",
+    UI_REBUILD = "ui-rebuild"
+}
+
+function getDevModeType(): DevModType {
+    let modFullReload = false;
+    let modUiRebuild = false;
+
+    //region Test jopi-dev
+
+    let idx = process.argv.indexOf("--jopi-dev");
+
+    if (idx!==-1) {
+        process.argv.splice(idx, 1);
+        modFullReload = true;
+    }
+
+    if (process.env.JOPI_DEV === "1") {
+        modFullReload = true;
+    }
+
+    //endregion
+
+    //region Test jopi-dev-ui
+
+    idx = process.argv.indexOf("--jopi-dev-ui");
+
+    if (idx!==-1) {
+        process.argv.splice(idx, 1);
+        modUiRebuild = true;
+    }
+
+    if (process.env.JOPI_DEV_UI === "1") {
+        modUiRebuild = true;
+    }
+
+    //endregion
+
+    if (modUiRebuild) return DevModType.UI_REBUILD;
+    if (modFullReload) return DevModType.FULL_RELOAD;
+    return DevModType.NONE;
+}
+
+export async function jopiLauncherTool(jsEngine: string) {
+    function execTask(taskName: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            let cwd = path.dirname(config.packageJsonFilePath!);
+            let cmd = isNodeJs ? "npm" : "bun";
+            const child = spawn(cmd, ["run", taskName], {stdio: "inherit", cwd, env});
+
+            child.on('exit', (code) => {
+                if (code === 0) { resolve() }
+                else { reject(new Error(`Task ${taskName} exited with code ${code}`)); }
+            });
+
+            child.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+
+    function onSpawned() {
+        // Nothing to do. Keep for future usages.
+    }
+
+    function addKnownPackages(toPreload: string[], toSearch: string[]) {
+        if (!toSearch) return;
+
+        for (const key in toSearch) {
+            if (knowPackagesToPreload.includes(key)) {
+                toPreload.push(key);
+            }
+        }
+    }
+
+    function getPreloadModules() {
+        const packageJsonPath = jk_app.findPackageJson();
+
+        if (!packageJsonPath) {
+            return [];
+        }
+
+        try {
+            const packageContent = fs.readFileSync(packageJsonPath, 'utf8');
+            const packageData = JSON.parse(packageContent);
+
+            let toPreload: string[] = [];
+
+            let jopi = packageData.jopi;
+
+            if (jopi && jopi.preload) {
+                if (Array.isArray(jopi.preload)) {
+                    toPreload = [...toPreload, ...jopi.preload];
+                }
+            }
+
+            addKnownPackages(toPreload, packageData["devDependencies"]);
+            addKnownPackages(toPreload, packageData["dependencies"]);
+
+            return toPreload;
+
+        } catch {
+            // Ignore parsing errors and continue without preload modules.
+            return [];
+        }
+    }
+
+    async function getConfiguration(): Promise<WatchInfos> {
+        let res: WatchInfos = {
+            needHot: false,
+            needUiWatch: gDevModeType === DevModType.UI_REBUILD,
+            needWatch: gDevModeType === DevModType.FULL_RELOAD
+        };
+
+        let pckJson = jk_app.findPackageJson();
+
+        if (pckJson) {
+            if (mustLog) console.log("JopiN - package.json file found at", pckJson);
+
+            res.packageJsonFilePath = pckJson;
+
+            try {
+                let json = JSON.parse(await jk_fs.readTextFromFile(pckJson));
+                let jopi: any = json["jopi"];
+
+                if (jopi) {
+                    if (jopi.needUiWatch===true) {
+                        res.needUiWatch = true;
+                    }
+                    else if (jopi.watch===true) {
+                        res.needWatch = true;
+                    }
+                }
+
+                if (json.scripts) {
+                    let scripts = json.scripts;
+
+                    if (scripts.jopiWatch) res.hasJopiWatchTask = true;
+                    if (scripts.jopiWatch_node) res.hasJopiWatchTask_node = true;
+                    if (scripts.jopiWatch_bun) res.hasJopiWatchTask_bun = true;
+
+                    if (scripts.jopiBuild_node) res.hasJopiBuildTask_node = true;
+                    if (scripts.jopiBuild_bun) res.hasJopiBuildTask_bun = true;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        } else if (process.env.NODE_ENV !== 'production') {
+            console.warn("JopiN - package.json not found, can't enable file watching");
+        }
+
+        let watch = process.env.WATCH;
+
+        if (watch) {
+            switch (watch) {
+                case "0":
+                case "false":
+                case "no":
+                    break;
+                case "1":
+                case "true":
+                case "yes":
+                    res.needWatch = true;
+                    break;
+            }
+        }
+
+        return res;
+    }
+
+    const importFlag = jsEngine === "node" ? "--import" : "--preload";
+    const isNodeJs = jsEngine == "node";
+
+    mustLog = process.env.JOPI_LOG==="1" || FORCE_LOG;
+
+    if (mustLog) {
+        console.log("JopiN Lib Version:", VERSION, " - engine:", jsEngine);
+    }
+
+    const knowPackagesToPreload = ["jopijs"];
+
+    // Here first is node.js, second is jopi. (it's du to shebang usage).
+    let argv = process.argv.slice(2);
+
+    if (!argv.length) {
+        console.log("jopi-loader "+ VERSION +" installed at ", import.meta.dirname);
+        return;
+    }
+
+    // Catch --hot and --watch, and remove them.
+    //
+    argv = argv.filter(arg => {
+        if (arg === "--hot") {
+            config.needHot = true;
+            config.needWatch = true;
+            return false;
+        }
+
+        if (arg === "--watch") {
+            config.needHot = false;
+            config.needWatch = true;
+            return false;
+        }
+
+        return arg !== "--watch-path";
+    });
+
+    let toPreload = getPreloadModules();
+    toPreload = ["jopijs/loader", ...toPreload];
+
+    let preloadArgs: string[] = [];
+
+    toPreload.forEach(pkg => {
+        preloadArgs.push(importFlag);
+        preloadArgs.push(pkg);
+    });
+
+    if (jsEngine==="node") {
+        preloadArgs.push("--loader", "jopijs/loader/loader.mjs");
+        preloadArgs.push("--no-warnings");
+    }
+
+    let cmd = jk_os.whichSync(jsEngine, jsEngine)!;
+    if (mustLog) console.log("jopiN - Using " + jsEngine + " from:", cmd);
+    let args = [...preloadArgs, ...argv];
+
+    let config = await getConfiguration();
+
+    const cwd = process.cwd();
+    let env: Record<string, string> = {...process.env} as Record<string, string>;
+    let enableFileWatcher = false;
+
+    if (config.needWatch || config.needUiWatch) {
+        env["JOPIN_BROWSER_REFRESH_ENABLED"] = "1";
+        if (config.needWatch) env["JOPI_DEV"] = "1";
+        if (config.needUiWatch) env["JOPI_DEV_UI"] = "1";
+
+        let toPrepend: string[] = [];
+
+        if (config.needWatch) {
+            if (config.needHot) {
+                toPrepend.push("--hot");
+            }
+            else {
+                //toPrepend.push("--watch");
+                enableFileWatcher = true;
+                env["JOPI_CUSTOM_WATCHER"] = "1";
+                jk_term.logBlue("JopiN - Source watching enabled.");
+            }
+
+            args = [...toPrepend, ...args];
+        }
+    }
+
+    if (mustLog) {
+        console.log("jopiN - Use current working dir:", cwd);
+        console.log("jopiN - Executing:", cmd, ...args);
+    }
+
+    // If dev-mode, then execute the scripts
+    // jopiWatch_node/jopiWatch_bun from package.json
+    //
+    if (gDevModeType === DevModType.FULL_RELOAD) {
+        if (config.hasJopiWatchTask) await execTask("jopiWatch");
+        if (isNodeJs && config.hasJopiWatchTask_node) await execTask("jopiWatch_node");
+        if (!isNodeJs && config.hasJopiWatchTask_bun) await execTask("jopiWatch_bun");
+    } else {
+        if (isNodeJs && config.hasJopiBuildTask_node) await execTask("jopiBuild_node");
+        if (!isNodeJs && config.hasJopiBuildTask_bun) await execTask("jopiBuild_bun");
+    }
+
+    if (enableFileWatcher) {
+        if (mustLog) console.log("Using SourceChangesWatcher");
+
+        const watcher = new SourceChangesWatcher({
+            watchDirs: [path.join(process.cwd(), "src")],
+            excludeDir: [path.join(process.cwd(), "src", "_jopiLinkerGen")],
+            isDev: true, env, cmd, args, mustLog: mustLog,
+            jsEngine
+        });
+
+        await watcher.start();
+
+    } else {
+        if (mustLog) console.log("Is not using SourceChangesWatcher");
+
+        spawnChild({
+            cmd, env, args, onSpawned, cwd: process.cwd(), killOnExit: false
+        });
+    }
+}
+
+export interface SpawnParams {
+    env?: Record<string, string>;
+    cmd: string;
+    args: string[];
+    cwd: string;
+    killOnExit: boolean;
+    onSpawned?: (child: ChildProcess) => void;
+}
+
+function killAll(signalName: NodeJS.Signals) {
+    gToKill.forEach(child => {
+        if (child.killed) return;
+
+        if (gDevModeType!==DevModType.NONE) {
+            // > If dev-mode, directly do a fast hard kill.
+            child.kill('SIGKILL');
+            process.exit(0);
+        } else {
+            try {
+                child.kill(signalName);
+            }
+            catch {
+            }
+
+            setTimeout(() => {
+                if (!child.killed) {
+                    child.kill('SIGKILL');
+                }
+            }, 1000);
+        }
+    });
+}
+
+function spawnChild(params: SpawnParams): void {
+    let useShell = params.cmd.endsWith('.cmd') || params.cmd.endsWith('.bat') || params.cmd.endsWith('.sh');
+
+    if (mustLog) {
+        console.log("spawnChild", {cmd: params.cmd, args: params.args, cwd: process.cwd(), useShell})
+    }
+
+    const child = spawn(params.cmd, params.args, {
+        stdio: "inherit", shell: useShell,
+        cwd: process.cwd(),
+        env: params.env
+    });
+
+    gToKill.push(child);
+
+    if (params.killOnExit) {
+        child.on('exit', (code, signal) => {
+            // The current instance has stopped?
+            if (signal) process.kill(process.pid, signal);
+            else process.exit(code ?? 0);
+        });
+
+        child.on('error', (err) => {
+            // The current instance is in error?
+            console.error(err.message || String(err));
+            process.exit(1);
+        });
+    }
+
+    if (params.onSpawned) {
+        child.on('spawn', () => {
+            params.onSpawned!(child);
+        })
+    }
+}
+
+// Allow a killing child process when this process exits.
+
+process.on('SIGTERM', () => killAll("SIGTERM"));
+process.on('SIGINT', () => killAll("SIGINT"));
+process.on('SIGHUP', () => killAll("SIGHUP"));
+process.on('exit', () => killAll("exit" as NodeJS.Signals));
+
+const gDevModeType = getDevModeType();
+const gToKill: ChildProcess[] = [];

package/src/@loader-tools/nodeJsLoader.ts

@@ -0,0 +1,119 @@
+import type { ResolveHook, ResolveFnOutput } from 'node:module';
+import nodeModule from 'node:module';
+
+import {pathToFileURL} from "node:url";
+import * as jk_app from "jopi-toolkit/jk_app";
+import {getPathAliasInfo, type PathAliasInfo} from "./tools.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+//**********************************************************************************************************************
+// NodeJS RESOLVER vs LOADER
+//
+// Resolver is the new Node.js API for import resolving and processing.
+// But currently (Node v22) there is not a full support, and the old
+// mechanism (loader) must be used for some special cases.
+//
+//**********************************************************************************************************************
+
+const LOG = process.env.JOPI_LOGS === "1";
+
+let gRequire: NodeJS.Require|undefined;
+
+/**
+ * Using a loader (old API) allows doing thing not correctly supported by resolver (new API)
+ *
+ * 1- Resolving alias.
+ *      Example: import myComp from "@/lib/myComp".
+ *      The alias definitions are taken in the paths section of tsconfig.json.
+ *
+ * 2- Resolving import for an exposed file inside a module
+ *      Exemple:                import 'primereact/sidebar'
+ *      where the target is     import 'primereact/sidebar/index.mjs.js'
+ */
+export const resolveNodeJsAlias: ResolveHook = async (specifier, context, nextResolve): Promise<ResolveFnOutput> => {
+    if (!gPathAliasInfos) {
+        gPathAliasInfos = await getPathAliasInfo();
+    }
+
+    //region Resolve alias
+
+    if (specifier[0]==='@') {
+        let foundAlias = "";
+
+        for (const alias in gPathAliasInfos.alias) {
+            if (specifier.startsWith(alias)) {
+                if (foundAlias.length < alias.length) {
+                    foundAlias = alias;
+                }
+            }
+        }
+
+        if (foundAlias) {
+            if (LOG) console.log(`jopi-loader - Found alias ${foundAlias} for resource ${specifier}`);
+
+            let pathAlias = gPathAliasInfos.alias[foundAlias];
+            const resolvedPath = specifier.replace(foundAlias, pathAlias);
+
+            let filePath = resolvedPath.endsWith('.js') ? resolvedPath : `${resolvedPath}.js`;
+            filePath = jk_app.getCompiledFilePathFor(filePath);
+
+            return nextResolve(pathToFileURL(filePath).href, context);
+        }
+
+        // > Will continue on next cases.
+    }
+
+    //endregion
+
+    let mustProcess = specifier.includes("/");
+
+    if (mustProcess) {
+        if ((specifier[0] === '@') && specifier[1]!=='/') {
+            mustProcess = false;
+        } else if (specifier.indexOf(":")!==-1) {
+            mustProcess = false;
+        } else if (specifier.endsWith(".js") || specifier.endsWith(".mjs")) {
+            mustProcess = false;
+        }
+    }
+
+    // If we are here, it means we have possibly something like:
+    //      import "module/internalPath"
+    //
+    // The matter is that the extension is missing, and Node.js doesn't handle this case
+    // despite UI lib used by Vite.js or WebPack.
+    //
+    if (mustProcess) {
+        if (!gRequire) {
+            gRequire = nodeModule.createRequire(context.parentURL!);
+        }
+
+        try {
+            // Testing nextResolve and catching exception don't work.
+            // It's why we use require.resolve to localize the package..
+            //
+            let found = gRequire.resolve(specifier);
+
+            if (found) {
+                const pkgPath = nodeModule.findPackageJSON(pathToFileURL(found));
+
+                if (pkgPath) {
+                    let pkgJson = await fs.readFile(pkgPath, "utf-8");
+                    const json = JSON.parse(pkgJson);
+
+                    if (json.module) {
+                        const oldName = specifier;
+                        specifier = path.resolve(path.dirname(pkgPath), json.module);
+                        if (LOG) console.log("Resolving", oldName, "to", specifier);
+                    }
+                }
+            }
+        } catch {
+        }
+    }
+
+    return nextResolve(specifier, context);
+}
+
+let gPathAliasInfos: PathAliasInfo|undefined;

package/src/@loader-tools/nodeJsResolver.ts

@@ -0,0 +1,140 @@
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import {fileURLToPath} from "node:url";
+import path from "node:path";
+import {supportedExtensions} from "./rules.ts";
+import {transformFile} from "./transform.ts";
+
+//**********************************************************************************************************************
+// NodeJS RESOLVER vs LOADER
+//
+// Resolver is the new Node.js API for import resolving and processing.
+// But currently (Node v22) there is not a full support, and the old
+// mechanism (loader) must be used for some special cases.
+//
+//**********************************************************************************************************************
+
+export async function doNodeJsResolve(specifier: string, context: any, nextResolve: any) {
+    async function tryResolveFile(filePath: string, moduleName: string) {
+        if (await jk_fs.isFile(filePath)) {
+            return nextResolve(moduleName, context);
+        }
+
+        return undefined;
+    }
+
+    async function tryResolveDirectory(url: string) {
+        const basePath = fileURLToPath(url);
+        let basename = path.basename(basePath);
+
+        let allFilesToTry = ["index.js", basename + ".cjs.js", basename + ".js"];
+
+        for (let fileToTry of allFilesToTry) {
+            const res = await tryResolveFile(path.join(basePath, fileToTry), specifier + "/" + fileToTry);
+            if (res) return res;
+        }
+
+        // Will throw an error.
+        return nextResolve(specifier, context);
+    }
+
+    async function tryResolveModule(url: string) {
+        const basePath = fileURLToPath(url);
+
+        const res = await tryResolveFile(basePath + ".js", specifier + ".js");
+
+        if (res) {
+            return res;
+        }
+
+        // Will throw an error.
+        return nextResolve(specifier, context);
+    }
+
+    // Remove what is after the "?" to be able to test the extension.
+    //
+    let idx = specifier.indexOf("?");
+    let options = "";
+
+    if (idx!==-1) {
+        options = specifier.substring(idx);
+        specifier = specifier.substring(0, idx);
+    }
+
+    if (supportedExtensions.includes(path.extname(specifier))) {
+        const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
+
+        let href: string;
+
+        if (!isRelative) {
+            let resolved = await nextResolve(specifier, context);
+            href = resolved.url;
+        }
+        else {
+            href = new URL(specifier, context.parentURL).href;
+        }
+
+        return {
+            url: href + options,
+            format: "jopi-loader",
+            shortCircuit: true
+        };
+    }
+
+    try {
+        return nextResolve(specifier, context);
+    } catch (e: any) {
+        if (e.code === "ERR_UNSUPPORTED_DIR_IMPORT") {
+            return await tryResolveDirectory(e.url! as string);
+        }
+        if (e.code === "ERR_MODULE_NOT_FOUND") {
+            return await tryResolveModule(e.url! as string);
+        }
+        throw e;
+    }
+}
+
+// noinspection JSUnusedGlobalSymbols
+export async function doNodeJsLoad(url: string, context: any, nextLoad: any) {
+    if (context.format==="jopi-loader") {
+        let idx = url.indexOf("?");
+        let options = "";
+
+        if (idx !== -1) {
+            options = url.substring(idx + 1);
+            url = url.substring(0, idx);
+        }
+
+        // Some ".js" file can be found here, du to a strange bug
+        // inside the node.js loader, where the context object seems to be reused.
+        // It doesn't go through doNodeJsResolve and directly appears here.
+        //
+        if (!supportedExtensions.includes(path.extname(url))) {
+            context.format = "module";
+            return nextLoad(url, context);
+        }
+
+        let filePath = fileURLToPath(url);
+
+        // Occurs when it's compiled with TypeScript.
+        if (!await jk_fs.isFile(filePath)) {
+            filePath = jk_app.requireSourceOf(filePath);
+        }
+
+        try {
+            let res = await transformFile(filePath, options);
+
+            return {
+                source: res.text,
+                format: 'module',
+                shortCircuit: true
+            };
+        }
+        catch (e: any) {
+            console.warn("jopi-loader - Error while loading:", e?.message || e);
+            throw "jopi-loader - error";
+        }
+    }
+
+    return nextLoad(url, context);
+}

package/src/@loader-tools/rules.ts

@@ -0,0 +1,45 @@
+import {isBunJS} from "jopi-toolkit/jk_what";
+
+function toFlatList(rec: Record<string, string[]>): string[] {
+    let res: string[] = [];
+
+    for (let group in rec) {
+        res = [...res, ...rec[group]]
+    }
+
+    return res;
+}
+
+function invertKeys(rec: Record<string, string[]>): Record<string, string> {
+    const res: Record<string, string> = {};
+
+    for (let key in rec) {
+        let group = rec[key];
+        group.forEach(e => {res[e] = key});
+    }
+
+    return res;
+}
+
+function patchForJsEngine(value: Record<any, any>) {
+    // Bun.js handle JSON specially, with care for import/require differences.
+    if (!isBunJS) {
+       value.text.push(".json");
+    }
+
+    return value;
+}
+
+const supportedExtensionsByGroup = patchForJsEngine({
+    css: [".css", ".scss"],
+    binary: [".jpg", ".png", ".jpeg", ".gif", ".webp", ".woff", ".woff2", ".ttf", ".avif", ".ico"],
+
+    //.json added here by patchForJsEngine if not bun.js
+    text: [".txt", ".svg", ".glsl", /*".json" added only for node.js */]
+});
+
+export const supportedExtensions = toFlatList(supportedExtensionsByGroup);
+export const supportedExtensionToType = invertKeys(supportedExtensionsByGroup);
+
+export const supportedExtensionsRegExp = new RegExp(`(${supportedExtensions.map(ext => ext.replace('.', '\\.')).join('|')})(?:\\?.*)?$`);
+