jopi-toolkit 3.0.5

package/src/jk_app/common.ts

@@ -0,0 +1,389 @@
+// noinspection JSUnusedGlobalSymbols
+
+import * as jk_thread from "jopi-toolkit/jk_thread";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_timer from "jopi-toolkit/jk_timer";
+import {isBunJS, isNodeJS} from "jopi-toolkit/jk_what";
+import {isUsingWorker} from "jopi-toolkit/jk_thread";
+
+export type Listener = ()=>void|Promise<void>;
+
+async function execListeners(listeners: Listener[]) {
+    const list = [...listeners];
+    listeners.splice(0);
+
+    for (const listener of list) {
+        try {
+            const res = listener();
+            if (res instanceof Promise) await res;
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+
+//region Life cycle
+
+declare global {
+    var jopiHotReload: HotReloadType;
+}
+
+const gOnServerSideReady: Listener[] = [];
+const gOnAppExiting: Listener[] = [];
+const gOnAppExited: Listener[] = [];
+const gOnAppStart: Listener[] = [];
+let gIsServerSideReady = !(isNodeJS || isBunJS);
+
+let gIsHotReload = globalThis.jopiHotReload !== undefined;
+let gIsAppStarted = false;
+
+export interface HotReloadType {
+    onHotReload: Listener[];
+    memory: { [key: string]: any };
+}
+
+if (gIsHotReload) {
+    execListeners(globalThis.jopiHotReload.onHotReload).then();
+} else {
+    globalThis.jopiHotReload = {
+        onHotReload: [],
+        memory: {}
+    }
+}
+
+const gOnHotReload = globalThis.jopiHotReload.onHotReload;
+const gMemory = globalThis.jopiHotReload.memory;
+
+export function onServerSideReady(listener: Listener) {
+    if (gIsServerSideReady) listener();
+    else gOnServerSideReady.push(listener);
+}
+
+export function waitServerSideReady() {
+    if (gIsServerSideReady) {
+        return Promise.resolve();
+    }
+
+    return new Promise<void>(r => {
+        onServerSideReady(r);
+    });
+}
+
+export async function declareServerSideReady() {
+    gIsServerSideReady = true;
+    await execListeners(gOnServerSideReady);
+}
+
+export function onAppStart(listener: Listener) {
+    if (gIsAppStarted) listener();
+    else gOnAppStart.push(listener);
+}
+
+export function onAppExiting(listener: Listener) {
+    if (gIsExited) listener();
+    else gOnAppExiting.push(listener);
+}
+
+export function onAppExited(listener: Listener) {
+    if (gIsExited) listener();
+    else gOnAppExited.push(listener);
+}
+
+export async function declareAppStarted() {
+    gIsAppStarted = true;
+    await execListeners(gOnAppStart);
+}
+
+export async function declareAppExiting() {
+    if (gIsExited) return;
+    gIsExited = true;
+
+    if (isUsingWorker()) {
+        // Wait 1 sec, which allows the worker to correctly initialize.
+        await jk_timer.tick(1000);
+    }
+
+    gIsAppStarted = false;
+
+    await execListeners(gOnAppExiting);
+
+    if (isUsingWorker()) {
+        // Allows to worker to correctly stop their activity.
+        await jk_timer.tick(100);
+    }
+
+    if (!jk_thread.isMainThread) {
+        // Allows to worker to correctly stop their activity.
+        await jk_timer.tick(50);
+    }
+
+    await execListeners(gOnAppExited);
+}
+
+export async function executeApp(app: Listener) {
+    await waitServerSideReady();
+    declareAppStarted();
+
+    try {
+        const res = app();
+        if (res instanceof Promise) await res;
+    }
+    finally {
+        declareAppExiting();
+    }
+}
+
+//endregion
+
+//region Hot-reload
+
+export function onHotReload(listener: Listener) {
+    gOnHotReload.push(listener);
+}
+
+export function keepOnHotReload<T>(key: string, provider: ()=>T): T {
+    let current = gMemory[key];
+    if (current!==undefined) return current;
+    return gMemory[key] = provider();
+}
+
+export function clearHotReloadKey(key: string) {
+    delete(gMemory[key]);
+}
+
+//endregion
+
+//region Temp dir
+
+export function getTempDir(): string {
+    if (!gTempDir) {
+        gTempDir = jk_fs.resolve(process.cwd(), "temp")!;
+    }
+
+    return gTempDir;
+}
+
+let gIsExited = false;
+let gTempDir: string|undefined;
+
+//endregion
+
+//region Resolving
+
+export function findNodePackageDir(packageName: string, useLinuxPathFormat: boolean = true): string|undefined {
+    let currentDir = jk_fs.dirname(findPackageJson());
+
+    while (true) {
+        const packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
+
+        if (jk_fs.isDirectorySync(packagePath)) {
+            if (useLinuxPathFormat) return jk_fs.win32ToLinuxPath(packagePath);
+            return packagePath;
+        }
+
+        const parentDir = jk_fs.dirname(currentDir);
+
+        // Reached root directory
+        if (parentDir === currentDir) {
+            break;
+        }
+
+        currentDir = parentDir;
+    }
+
+    return undefined;
+}
+
+export function requireNodePackageDir(packageName: string, useLinuxPathFormat: boolean = true): string {
+    let pkgDir = findNodePackageDir(packageName, useLinuxPathFormat);
+    if (!pkgDir) throw new Error("Package '" + packageName + "' not found");
+    return pkgDir;
+}
+
+export function findPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string {
+    let pkgJsonPath = findPackageJson(searchFromDir);
+    return jk_fs.dirname(pkgJsonPath);
+}
+
+export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string {
+    if (!searchFromDir && (gPackageJsonPath!==undefined)) return gPackageJsonPath;
+
+    let currentDir = searchFromDir;
+
+    while (true) {
+        const packagePath = jk_fs.join(currentDir, 'package.json');
+
+        if (jk_fs.isFileSync(packagePath)) return gPackageJsonPath = packagePath;
+
+        const parentDir = jk_fs.dirname(currentDir);
+
+        // Reached root directory
+        if (parentDir === currentDir) break;
+
+        currentDir = parentDir;
+    }
+
+    throw "No package.json found."
+}
+//
+let gPackageJsonPath: string|undefined;
+
+export function setApplicationMainFile(applicationMainFile: string) {
+    gApplicationMainFile = applicationMainFile;
+    gCodeSourceDirHint = jk_fs.dirname(applicationMainFile);
+}
+
+export function getApplicationMainFile(): string|undefined {
+    return gApplicationMainFile;
+}
+
+export function getCodeSourceDirHint() {
+    if (!gCodeSourceDirHint) return process.cwd();
+    return gCodeSourceDirHint;
+}
+
+export function getSourceCodeDir(): string {
+    if (gSourceCodeDir) return gSourceCodeDir;
+
+    let pkgJsonPath = findPackageJson();
+    let dirName = jk_fs.join(jk_fs.dirname(pkgJsonPath), "src");
+
+    if (jk_fs.isDirectorySync(dirName)) {
+        return gSourceCodeDir = dirName;
+    }
+
+    return gSourceCodeDir = jk_fs.dirname(pkgJsonPath);
+}
+
+export function getCompiledCodeDir(): string {
+    if (gCompiledSourcesDir) return gCompiledSourcesDir;
+    const sourceCodeDir = getSourceCodeDir();
+
+    if (!sourceCodeDir.endsWith("src")) {
+        return gCompiledSourcesDir = sourceCodeDir;
+    }
+
+    // This means that it's Bun.js, and it directly uses the TypeScript version.
+    if (gApplicationMainFile && isBunJS && gApplicationMainFile.startsWith(sourceCodeDir)) {
+        return gCompiledSourcesDir = sourceCodeDir;
+    }
+
+    let pkgJsonPath = findPackageJson();
+
+    let rootDir = jk_fs.dirname(pkgJsonPath);
+
+    for (let toTest of ["dist", "build", "out"]) {
+        if (jk_fs.isDirectorySync(jk_fs.join(rootDir, toTest))) {
+            return gCompiledSourcesDir = jk_fs.join(rootDir, toTest);
+        }
+    }
+
+    // No output dir? Assume we compiled on the same dir.
+    return rootDir;
+}
+
+export function getCompiledFilePathFor(sourceFilePath: string): string {
+    const compiledCodeDir = getCompiledCodeDir();
+    const sourceCodeDir = getSourceCodeDir();
+
+    if (!sourceFilePath.startsWith(sourceCodeDir)) {
+        throw new Error("jopi-loader - The source file must be in the source code directory: " + sourceFilePath);
+    }
+
+    let filePath = sourceFilePath.substring(sourceCodeDir.length);
+
+    if (isNodeJS && !filePath.endsWith(".js")) {
+        let idx = filePath.lastIndexOf(".");
+        if (idx !== -1) filePath = filePath.substring(0, idx) + ".js";
+    }
+
+    return jk_fs.join(compiledCodeDir, filePath);
+}
+
+export function getSourcesCodePathFor(compiledFilePath: string): string {
+    const compiledCodeDir = getCompiledCodeDir();
+    const sourceCodeDir = getSourceCodeDir();
+
+    if (!compiledFilePath.startsWith(compiledCodeDir)) {
+        throw new Error("jopi-loader - The compiled file must be in the compiled code directory: " + compiledFilePath);
+    }
+
+    let filePath =  jk_fs.join(sourceCodeDir, compiledFilePath.substring(compiledCodeDir.length));
+
+    let idx = filePath.lastIndexOf(".");
+    if (idx !== -1) filePath = filePath.substring(0, idx);
+
+    if (jk_fs.isFileSync(filePath + ".tsx")) {
+        return filePath + ".tsx";
+    }
+
+    if (jk_fs.isFileSync(filePath + ".ts")) {
+        return filePath + ".ts";
+    }
+
+    return filePath + ".js";
+}
+
+export function requireSourceOf(scriptPath: string): string {
+    let src = searchSourceOf(scriptPath);
+    if (!src) throw new Error("Cannot find source of " + scriptPath);
+    return src;
+}
+
+/**
+ * Search the source of the component if it's a JavaScript and not a TypeScript.
+ * Why? Because EsBuild doesn't work well on already transpiled code.
+ */
+export function searchSourceOf(scriptPath: string): string|undefined {
+    function tryResolve(filePath: string, outDir: string) {
+        let out = jk_fs.sep + outDir + jk_fs.sep;
+        let idx = filePath.lastIndexOf(out);
+
+        if (idx !== -1) {
+            filePath = filePath.slice(0, idx) + jk_fs.sep + "src" + jk_fs.sep + filePath.slice(idx + out.length);
+            if (jk_fs.isFileSync(filePath)) return filePath;
+        }
+
+        return undefined;
+    }
+
+    let scriptExt = jk_fs.extname(scriptPath);
+
+    if ((scriptExt===".ts") || (scriptExt===".tsx")) {
+        // Is already the source.
+        return scriptPath;
+    }
+
+    const originalScriptPath = scriptPath;
+    let isJavascript = (scriptPath.endsWith(".js")||(scriptPath.endsWith(".jsx")));
+
+    if (isJavascript) {
+        // Remove his extension.
+        scriptPath = scriptPath.slice(0, -scriptExt.length);
+    }
+
+    let tryDirs = ["dist", "build"];
+
+    for (let toTry of tryDirs) {
+        if (isJavascript) {
+            let found = tryResolve(scriptPath + ".tsx", toTry);
+            if (found) return found;
+
+            found = tryResolve(scriptPath + ".ts", toTry);
+            if (found) return found;
+        } else {
+            let found = tryResolve(scriptPath, toTry);
+            if (found) return found;
+        }
+    }
+
+    return originalScriptPath;
+}
+
+let gSourceCodeDir: string|undefined;
+let gCodeSourceDirHint: string|undefined;
+let gApplicationMainFile: string|undefined;
+let gCompiledSourcesDir: string|undefined;
+
+//endregion

package/src/jk_app/index.js

@@ -0,0 +1,3 @@
+export * from "./common.ts";
+import { init } from "./jBundler_ifServer.ts";
+init();

package/src/jk_app/index.ts

@@ -0,0 +1,4 @@
+export * from "./common.ts";
+
+import {init} from "./jBundler_ifServer.ts";
+init();

package/src/jk_app/jBundler_ifBrowser.ts

@@ -0,0 +1,2 @@
+export function init() {
+}

package/src/jk_app/jBundler_ifServer.js

@@ -0,0 +1,8 @@
+import { declareServerSideReady, declareAppExiting } from "./common.ts";
+declareServerSideReady().then();
+export function init() {
+    // When the program exits gracefully
+    process.on('exit', function () { return declareAppExiting(); });
+    // When the user wants to terminate the program (CTRL+C)
+    process.on('SIGINT', function () { return declareAppExiting(); });
+}

package/src/jk_app/jBundler_ifServer.ts

@@ -0,0 +1,11 @@
+import {declareServerSideReady, declareAppExiting} from "./common.ts";
+
+declareServerSideReady().then();
+
+export function init() {
+    // When the program exits gracefully
+    process.on('exit', () => declareAppExiting());
+
+    // When the user wants to terminate the program (CTRL+C)
+    process.on('SIGINT', () => declareAppExiting());
+}

package/src/jk_compress/index.js

@@ -0,0 +1 @@
+export * from "./jBundler_ifServer.ts";

package/src/jk_compress/index.ts

@@ -0,0 +1 @@
+export * from "./jBundler_ifServer.ts";

package/src/jk_compress/jBundler_ifBrowser.ts

@@ -0,0 +1,2 @@
+export const gunzipSync = () => { throw new Error("Not implemented") };
+export const gzipSync = () => { throw new Error("Not implemented") };

package/src/jk_compress/jBundler_ifServer.js

@@ -0,0 +1,10 @@
+import { gunzipSync as n_gunzipSync, gzipSync as n_gzipSync } from "node:zlib";
+import { isNodeJS } from "jopi-toolkit/jk_what";
+function node_gunzipSync(data) {
+    return n_gunzipSync(Buffer.from(data));
+}
+function node_gzipSync(data) {
+    return n_gzipSync(Buffer.from(data));
+}
+export var gunzipSync = isNodeJS ? node_gunzipSync : Bun.gunzipSync;
+export var gzipSync = isNodeJS ? node_gzipSync : Bun.gzipSync;

package/src/jk_compress/jBundler_ifServer.ts

@@ -0,0 +1,16 @@
+import {gunzipSync as n_gunzipSync, gzipSync as n_gzipSync} from "node:zlib";
+import {isNodeJS} from "jopi-toolkit/jk_what";
+
+type t_gunzipSync = (data: Uint8Array|string) => Buffer;
+type t_gzipSync = (data: Uint8Array|string) => Buffer;
+
+function node_gunzipSync(data: Uint8Array|string): Buffer {
+    return n_gunzipSync(Buffer.from(data));
+}
+
+function node_gzipSync(data: Uint8Array|string): Buffer {
+    return n_gzipSync(Buffer.from(data));
+}
+
+export const gunzipSync: t_gunzipSync = isNodeJS ? node_gunzipSync : (Bun.gunzipSync as t_gunzipSync);
+export const gzipSync: t_gzipSync = isNodeJS ? node_gzipSync : (Bun.gzipSync as t_gzipSync);

package/src/jk_crypto/index.js

@@ -0,0 +1 @@
+export * from "./jBundler_ifServer.ts";

package/src/jk_crypto/index.ts

@@ -0,0 +1 @@
+export * from "./jBundler_ifServer.ts";

package/src/jk_crypto/jBundler_ifBrowser.ts

@@ -0,0 +1,2 @@
+export const md5 = () => { throw new Error("Not implemented") };
+export const fastHash = () => { throw new Error("Not implemented") };

package/src/jk_crypto/jBundler_ifServer.ts

@@ -0,0 +1,21 @@
+import crypto from "node:crypto";
+import {isNodeJS} from "jopi-toolkit/jk_what";
+
+function node_md5(text: string): string {
+    return crypto.createHash('md5').update(text).digest('hex');
+}
+
+function node_fastHash(text: string): string {
+    return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function bun_fastHash(text: string): string {
+    return Bun.hash(text).toString();
+}
+
+function bun_md5(text: string): string {
+    return Bun.MD5.hash(text, "hex");
+}
+
+export const md5 = isNodeJS ? node_md5 : bun_md5;
+export const fastHash = isNodeJS ? node_fastHash : bun_fastHash;