jopijs 0.0.1

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

@@ -0,0 +1,142 @@
+import path from "node:path";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_app from "jopi-toolkit/jk_app";
+
+/**
+ * The value of the "jopi" entry in package.json
+ */
+export interface PackageJson_jopi {
+    /**
+     * When importing a file, if this option is set, then
+     * we will not return a file path on the filesystem
+     * but an url pointing to this resource.
+     *
+     * The value here must be the PUBLIC url.
+     */
+    webSiteUrl?: string;
+
+    /**
+     * It's the url on which the website listens to if we don't use
+     * explicite url when defining the website.
+     *
+     * Here it's the PRIVATE url.
+     *
+     * If not defined, take the value of webSiteUrl.
+     */
+    webSiteListeningUrl?: string;
+
+    /**
+     * Is similar to 'webResourcesRoot' but for the server side resources.
+     * The server will redirect the resources from this url to the final
+     * url resolved once bundled.
+     */
+    webResourcesRoot_SSR?: string;
+
+    /**
+     * Is used with `webSiteUrl` to known where
+     * whe cas found the resource. Will allow installing
+     * a file server.
+     */
+    webResourcesRoot: string;
+
+    /**
+     * File which size is over this limite
+     * will not be inlined when option ?inline
+     * is set in the 'import', but resolved as
+     * a file path (or ulr).
+     */
+    inlineMaxSize_ko: number;
+
+    /**
+     * Indicate the directory where the bundler
+     * stores the images and resources.
+     * (use linux path format)
+     */
+    bundlerOutputDir: string;
+}
+
+export const INLINE_MAX_SIZE_KO = 3;
+
+let gTransformConfig: PackageJson_jopi|undefined;
+
+export function getPackageJsonConfig(): PackageJson_jopi {
+    function urlToPath(url: string) {
+        let urlInfos = new URL(url);
+        let port = urlInfos.port;
+
+        if (port.length && port[0]!==':') port = ':' + port;
+        return (urlInfos.hostname + port).replaceAll(".", "_").replaceAll(":", "_");
+    }
+
+    if (gTransformConfig!==undefined) return gTransformConfig;
+    let pkgJsonFilePath = jk_app.findPackageJson();
+
+    let bundlerOutputDir = "./temp/.reactHydrateCache";
+
+    gTransformConfig =  {
+        webResourcesRoot: "_bundle",
+        inlineMaxSize_ko: INLINE_MAX_SIZE_KO,
+        bundlerOutputDir: ""
+    }
+
+    if (pkgJsonFilePath) {
+        try {
+            let json = JSON.parse(jk_fs.readTextFromFileSync(pkgJsonFilePath));
+            let jopi = json.jopi;
+
+            if (jopi) {
+                let webSiteUrl = jopi.webSiteUrl;
+                if (webSiteUrl && !webSiteUrl.endsWith("/")) webSiteUrl += '/';
+                //
+                gTransformConfig.webSiteUrl = webSiteUrl;
+
+                let webSiteListeningUrl = jopi.webSiteListeningUrl;
+                if (webSiteListeningUrl && !webSiteListeningUrl.endsWith("/")) webSiteListeningUrl += '/';
+                //
+                gTransformConfig.webSiteListeningUrl = webSiteListeningUrl;
+
+                let webResourcesRoot = jopi.webResourcesRoot || "_bundle";
+                if (webResourcesRoot[0]==='/') webResourcesRoot = webResourcesRoot.substring(1);
+                if (!webResourcesRoot.endsWith("/")) webResourcesRoot += "/";
+                //
+                gTransformConfig.webResourcesRoot = webResourcesRoot;
+                gTransformConfig.webResourcesRoot_SSR = webResourcesRoot.slice(0, -1) + "_s/";
+
+                if (typeof(jopi.inlineMaxSize_ko)=="number") {
+                    gTransformConfig.inlineMaxSize_ko = jopi.inlineMaxSize_ko || INLINE_MAX_SIZE_KO;
+                }
+
+                if (webResourcesRoot.bundlerOutputDir) {
+                    bundlerOutputDir = webResourcesRoot.bundlerOutputDir;
+                }
+            }
+        } catch {
+        }
+    }
+
+    if (process.env.JOPI_WEBSITE_URL) {
+        gTransformConfig.webSiteUrl = process.env.JOPI_WEBSITE_URL;
+    }
+
+    if (process.env.JOPI_WEBSITE_LISTENING_URL) {
+        gTransformConfig.webSiteListeningUrl = process.env.JOPI_WEBSITE_LISTENING_URL;
+    }
+
+    if (!gTransformConfig.webSiteListeningUrl) {
+        gTransformConfig.webSiteListeningUrl = gTransformConfig.webSiteUrl;
+    } else if (!gTransformConfig.webSiteUrl) {
+        gTransformConfig.webSiteUrl = gTransformConfig.webSiteListeningUrl;
+    }
+
+    if (bundlerOutputDir && gTransformConfig.webSiteUrl) {
+        if (path.sep !== "/") {
+            bundlerOutputDir = bundlerOutputDir.replaceAll("/", path.sep);
+        }
+
+        bundlerOutputDir = path.resolve(bundlerOutputDir);
+        bundlerOutputDir = path.join(bundlerOutputDir, urlToPath(gTransformConfig.webSiteUrl));
+        gTransformConfig.bundlerOutputDir = bundlerOutputDir;
+    }
+
+    return gTransformConfig!;
+}

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

@@ -0,0 +1,76 @@
+import path from "node:path";
+import * as sass from "sass";
+import fs from "node:fs/promises";
+import postcssModules from "postcss-modules";
+import postcss from "postcss";
+import * as jk_crypto from "jopi-toolkit/jk_crypto";
+import * as jk_app from "jopi-toolkit/jk_app";
+
+import * as jk_fs from "jopi-toolkit/jk_fs";
+
+/**
+ * Compile a CSS or SCSS file to a JavaScript file.
+ */
+export default async function compileCssModule(filePath: string): Promise<string> {
+    // Occurs when it's compiled with TypeScript.
+    if (!await jk_fs.isFile(filePath)) {
+        let source = jk_app.searchSourceOf(filePath)!;
+        if (!source) throw new Error(`Source not found for file not found: ${filePath}`);
+        filePath = source;
+    }
+
+    const ext = path.extname(filePath).toLowerCase();
+
+    let css: string;
+    let fromPath = filePath;
+
+    if (ext === ".scss") {
+        // Compile SCSS to CSS
+        css = scssToCss(filePath);
+        fromPath = filePath.replace(/\.scss$/i, '.css');
+    } else {
+        css = await fs.readFile(filePath, 'utf-8');
+    }
+
+    // Process with PostCSS and css-modules
+    let knownClassNames: Record<string, string> = {};
+
+    try {
+        const plugins = [
+            postcssModules({
+                // The format of the classnames.
+                generateScopedName: '[name]__[local]',
+                localsConvention: 'camelCaseOnly',
+
+                // Allow capturing the class names.
+                getJSON: (_cssFileName: string, json: Record<string, string>) => {
+                    knownClassNames = json || {};
+                }
+            })
+        ];
+
+        let res = await postcss(plugins).process(css, {from: fromPath, map: false});
+        css = res.css;
+
+    } catch (e: any) {
+        console.warn("jopi-loader - PostCSS processing failed:", e?.message || e);
+        throw e;
+    }
+
+    knownClassNames.__CSS__ = css;
+    knownClassNames.__FILE_HASH__ = jk_crypto.md5(filePath);
+
+    // Here __TOKENS__ contain something like {myLocalStyle: "LocalStyleButton__myLocalStyle___n1l3e"}.
+    // The goal is to resolve the computed class name and the original name.
+
+    if (process.env.JOPI_BUNLDER_ESBUILD) {
+        return `export default ${JSON.stringify(knownClassNames)};`;
+    }
+
+    return `export default ${JSON.stringify(knownClassNames)};`
+}
+
+export function scssToCss(filePath: string): any {
+    const res = sass.compile(filePath, { style: 'expanded' });
+    return res.css.toString();
+}

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

@@ -0,0 +1,142 @@
+import cssModuleCompiler from "./cssModuleCompiler.ts";
+import {transformFile} from "./transform.ts";
+import {getPackageJsonConfig} from "./config.ts";
+import path from "node:path";
+import fs from "node:fs";
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_events from "jopi-toolkit/jk_events";
+
+// Note: Bun.js plugins are partially compatible with EsBuild modules.
+
+interface JopiRawContent {
+    file: string;
+    type: string
+}
+
+async function processCssModule(path: string) {
+    let jsSource = await cssModuleCompiler(path);
+
+    return {
+        contents: jsSource,
+        loader: "js",
+    };
+}
+
+async function inlineAndRawModuleHandler(options: string, resPath: string) {
+    // Occurs when it's compiled with TypeScript.
+    if (!await jk_fs.isFile(resPath)) {
+        resPath = jk_app.requireSourceOf(resPath);
+    }
+
+    let res = await transformFile(resPath, options);
+
+    return {
+        contents: res.text,
+        loader: "js",
+    };
+}
+
+export function resolveAndCheckPath(filePath: string, resolveDir: string): {path?: string, error?: string} {
+    let absolutePath: string;
+
+    if (path.isAbsolute(filePath)) {
+        absolutePath = filePath;
+    } else {
+        absolutePath = path.resolve(resolveDir, filePath);
+    }
+
+    try {
+        fs.accessSync(absolutePath);
+        return { path: absolutePath };
+    } catch (error) {
+        return { error: `Resource not found: ${absolutePath}` };
+    }
+}
+
+function createJopiRawFile(targetFilePath: string, processType: string): any {
+    // Bun.js load doesn't support having an '?' in the path.
+    // It's why we do strange things here to process this case.
+    //
+    // Also, there are strange behaviors that we avoid when using this strategy.
+
+    let options = getPackageJsonConfig();
+    let tempDir = options?.bundlerOutputDir || path.join(jk_app.getTempDir(), "bunjs");
+    fs.mkdirSync(tempDir, {recursive: true});
+
+    let fileName = path.resolve(tempDir, (gNextTempFileName++) + ".jopiraw");
+    fs.writeFileSync(fileName, JSON.stringify({file: targetFilePath, type: processType}));
+
+    return {
+        // The file must exist, otherwise
+        // an exception is triggered :-(
+        path: fileName
+    };
+}
+
+export function installEsBuildPlugins(build: Bun.PluginBuilder) {
+    build.onResolve({filter: /\.module\.(css|scss)$/}, (args) => {
+        const result = resolveAndCheckPath(args.path, path.dirname(args.importer));
+
+        if (result.error) {
+            return {
+                errors: [{
+                    text: result.error
+                }]
+            };
+        }
+
+        //@ts-ignore
+        return createJopiRawFile(result.path!, "cssmodule");
+    });
+
+    // The only role of this resolver is to be able to know who is importing a CSS/SCSS file.
+    //
+    build.onResolve({filter: /\.(css|scss)$/}, (args) => {
+        jk_events.sendEvent("jopi.bundler.resolve.css", {
+            resolveDir: args.resolveDir,
+            path: args.path,
+            importer: args.importer
+        });
+
+        // Avoid influencing the transformation.
+        return null;
+    });
+
+    // @ts-ignore
+    build.onResolve({filter: /\?(?:inline|raw)$/}, async (args) => {
+        let [filePath, option] = args.path.split('?');
+
+        const result = resolveAndCheckPath(filePath, path.dirname(args.importer));
+
+        if (result.error) {
+            return {
+                errors: [{
+                    text: result.error
+                }]
+            };
+        }
+
+        //@ts-ignore
+        return createJopiRawFile(result.path!, "option-" + option);
+    });
+
+    // @ts-ignore
+    build.onLoad({filter: /\.jopiraw$/},  async (args) => {
+        let json = JSON.parse(await jk_fs.readTextFromFile(args.path)) as JopiRawContent;
+        await jk_fs.unlink(args.path);
+
+        let filePath = json.file;
+
+        switch (json.type) {
+            case "option-inline":
+                return inlineAndRawModuleHandler("inline", filePath);
+            case "option-raw":
+                return inlineAndRawModuleHandler("raw", filePath);
+            case "cssmodule":
+                return processCssModule(filePath);
+        }
+    });
+}
+
+let gNextTempFileName = 1;

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

@@ -0,0 +1,11 @@
+export { installEsBuildPlugins } from "./esBuildPlugin.ts";
+export { scssToCss } from "./cssModuleCompiler.ts";
+export { installBunJsLoader } from "./bunJsLoader.ts";
+export { findNodePackageDir } from "./tools.ts";
+
+export * from "./nodeJsResolver.ts";
+export * from "./nodeJsLoader.js";
+
+export * from "./config.ts";
+export * from "./jopin.ts"
+export * from "./virtualUrl.ts"