jopijs 0.0.1

package/src/@bundler/tailwind.ts

@@ -0,0 +1,139 @@
+import type {BundlerConfig, CreateBundleParams} from "jopijs";
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import postcss from "postcss";
+import tailwindPostcss from "@tailwindcss/postcss";
+
+export async function applyTailwindProcessor(params: CreateBundleParams): Promise<void> {
+    function append(text: string) {
+        return fs.appendFile(outFilePath, "\n" + text + "\n", "utf-8");
+    }
+
+    let sourceFiles = params.entryPoints;
+    let genDir = params.genDir;
+
+    // >>> Tailwind transform
+
+    if (params.singlePageMode) {
+        genDir = jk_fs.join(genDir, params.pageKey!);
+        sourceFiles = [genDir + ".jsx"];
+    }
+
+    const outFilePath = path.resolve(genDir, "tailwind.css");
+
+    if (await jk_fs.isFile(outFilePath)) {
+        await jk_fs.unlink(outFilePath);
+    }
+
+    // Assure the file exists.
+    await jk_fs.writeTextToFile(outFilePath, "");
+
+    let postCss = await applyPostCss(params, sourceFiles);
+    if (postCss) await append(postCss);
+}
+
+/**
+ * Generate Tailwind CSS file a list of source files and returns the CSS or undefined.
+ */
+async function applyPostCss(params: CreateBundleParams, sourceFiles: string[]): Promise<string|undefined> {
+    if (!sourceFiles.length) return "";
+
+    const bundlerConfig = params.config;
+
+    let plugins: postcss.AcceptedPlugin[] = [];
+
+    let config = bundlerConfig.tailwind.config || {};
+    if (!config.content) config.content = sourceFiles;
+    else config.content = [...sourceFiles, ...(config.content as string[])];
+
+    if (bundlerConfig.tailwind.extraSourceFiles) {
+        if (!config.content) config.content = [];
+        config.content = [...config.content, ...bundlerConfig.tailwind.extraSourceFiles];
+    }
+
+    let tailwindPlugin = bundlerConfig.tailwind.disable ? undefined : tailwindPostcss({config} as any);
+
+    if (bundlerConfig.postCss.initializer) {
+        plugins = bundlerConfig.postCss.initializer(sourceFiles, tailwindPlugin);
+    } else if (tailwindPlugin) {
+        plugins = [tailwindPlugin];
+    } else {
+        return undefined;
+    }
+
+    if (!plugins.length) return undefined;
+
+    let globalCssContent = await getGlobalCssFileContent(bundlerConfig);
+
+    try {
+        const processor = postcss(plugins);
+
+        const result = await processor.process(globalCssContent, {
+            // Setting 'from' allows resolving correctly the node_modules resolving.
+            from: params.outputDir
+        });
+
+        return result.css;
+    }
+    catch (e: any) {
+        console.error("Error while compiling for Tailwind:", e);
+        return undefined;
+    }
+}
+
+export async function getGlobalCssFileContent(config: BundlerConfig): Promise<string> {
+    if (config.tailwind.globalCssContent) {
+        return config.tailwind.globalCssContent;
+    }
+
+    if (config.tailwind.globalCssFilePath) {
+        if (!await jk_fs.isFile(config.tailwind.globalCssFilePath)) {
+            throw new Error(`Tailwind - File not found where resolving 'global.css': ${config.tailwind.globalCssFilePath}`);
+        }
+
+        return jk_fs.readTextFromFile(config.tailwind.globalCssFilePath);
+    }
+
+    let found = await getTailwindTemplateFromShadCnConfig();
+    if (found) return found;
+
+    let rootDir = jk_fs.dirname(jk_app.findPackageJson());
+
+    if (await jk_fs.isFile(jk_fs.join(rootDir, "global.css"))) {
+        return jk_fs.readTextFromFile(jk_fs.join(rootDir, "global.css"));
+    }
+
+    return `@import "tailwindcss";`;
+}
+
+/**
+ * Get Tailwind template CSS file from Shadcn config file (components.json).
+ * See: https://ui.shadcn.com/docs/components-json
+ */
+async function getTailwindTemplateFromShadCnConfig() {
+    const pkgJsonPath = jk_app.findPackageJson();
+    if (!pkgJsonPath) return undefined;
+
+    let filePath = path.join(path.dirname(pkgJsonPath), "components.json");
+    if (!await jk_fs.isFile(filePath)) return undefined;
+
+    try {
+        let asText = jk_fs.readTextFromFileSync(filePath);
+        let asJSON = JSON.parse(asText);
+
+        let tailwindConfig = asJSON.tailwind;
+        if (!tailwindConfig) return undefined;
+
+        let tailwindCssTemplate = tailwindConfig.css;
+        if (!tailwindCssTemplate) return undefined;
+
+        let fullPath = path.resolve(path.dirname(pkgJsonPath), tailwindCssTemplate);
+        return jk_fs.readTextFromFileSync(fullPath);
+    }
+    catch (e) {
+        console.error("Error reading Shadcn config file:", e);
+        return undefined;
+    }
+}

package/src/@core/PageComponent.tsx

@@ -0,0 +1,25 @@
+import React from "react";
+import {PageContext, PageController_ExposePrivate} from "jopijs/ui";
+import * as ReactServer from "react-dom/server";
+
+export default function({children, controller}: { children: React.ReactNode|React.ReactNode[], controller: PageController_ExposePrivate<unknown> }) {
+    const body = ReactServer.renderToStaticMarkup(
+        <PageContext.Provider value={controller}>
+            {children}
+        </PageContext.Provider>
+    );
+
+    const state = controller.getOptions();
+
+    return <html {...state.htmlProps}>
+        <head {...state.headProps}>
+            {state.head}
+            <title>{state.pageTitle}</title>
+        </head>
+        <body {...state.bodyProps}>
+            {state.bodyBegin}
+            <div dangerouslySetInnerHTML={{ __html: body }} />
+            {state.bodyEnd}
+        </body>
+    </html>
+}

package/src/@core/README.md

@@ -0,0 +1 @@
+The core of jopijs. Here it's mainly the server-side parts.

package/src/@core/_logs.ts

@@ -0,0 +1,11 @@
+import {getLogger} from "jopi-toolkit/jk_logs";
+
+export const logServer = getLogger("jopi.server");
+export const logServer_startApp = getLogger("startApp", logServer);
+export const logServer_request = getLogger("request", logServer);
+export const logServer_linker = getLogger("linker", logServer);
+
+export const logBundler = getLogger("jopi.bundler");
+
+export const logCache = getLogger("jopi.cache");
+export const logCache_notInCache = getLogger("notInCache", logCache);

package/src/@core/automaticStartStop.ts

@@ -0,0 +1,132 @@
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_timer from "jopi-toolkit/jk_timer";
+
+const ONE_MINUTE = jk_timer.ONE_MINUTE;
+const newInterval = jk_timer.newInterval;
+
+export enum AutomaticStartStopState { Stopped, Starting, Started, Stopping }
+
+export interface AutomaticStartStopManagerParams {
+    onStart: (data: any)=>Promise<number>;
+    onStop?: (data: any)=>Promise<void>;
+}
+
+export class AutomaticStartStop {
+    private _state = AutomaticStartStopState.Stopped;
+    private lastStartDate: number = 0;
+
+    private readonly startChangeListeners: (() => void)[] = [];
+
+    private readonly onStart: (data: any)=>Promise<number>;
+    private readonly onStop?: (data: any)=>Promise<void>;
+
+    public readonly data: any = {};
+
+    constructor(params: AutomaticStartStopManagerParams) {
+        this.onStop = params.onStop;
+        this.onStart = params.onStart;
+
+        jk_app.onAppExiting(this.stop.bind(this));
+    }
+
+    get state() {
+        return this._state;
+    }
+
+    private waitStateChange(): Promise<void> {
+        return new Promise<void>(resolve => {
+            this.startChangeListeners.push(resolve);
+        });
+    }
+
+    private setState(state: AutomaticStartStopState) {
+        if (this._state === state) return;
+        this._state = state;
+
+        if (this.startChangeListeners) {
+            this.startChangeListeners.forEach(l => l());
+            this.startChangeListeners.splice(0);
+        }
+    }
+
+    async start() {
+        if (this.state===AutomaticStartStopState.Started) {
+            return;
+        }
+
+        if (this.state===AutomaticStartStopState.Starting) {
+            await this.waitStateChange();
+            return;
+        }
+
+        if (this.state===AutomaticStartStopState.Stopping) {
+            await this.waitStateChange();
+        }
+
+        // If we are here, then it's in the state "stopped".
+        // But since it's async, state can have changed since.
+        //
+        if (this.state===AutomaticStartStopState.Stopped) {
+            this.setState(AutomaticStartStopState.Starting);
+            let toWait = await this.onStart(this.data);
+
+            this.lastStartDate = Date.now();
+            this.startTimer(toWait);
+
+            this.setState(AutomaticStartStopState.Started);
+        }
+    }
+
+    async stop() {
+        if (this.state===AutomaticStartStopState.Stopped) {
+            return;
+        }
+
+        if (this.state===AutomaticStartStopState.Stopping) {
+            await this.waitStateChange();
+            return;
+        }
+
+        if (this.state===AutomaticStartStopState.Starting) {
+            await this.waitStateChange();
+        }
+
+        // If we are here, then it's in the state "started".
+        // But since it's async, state can have changed since.
+        //
+        if (this.state===AutomaticStartStopState.Started) {
+            this.setState(AutomaticStartStopState.Stopping);
+
+            if (this.onStop) {
+                await this.onStop(this.data);
+            }
+
+            this.setState(AutomaticStartStopState.Stopped);
+        }
+    }
+
+    private startTimer(toWait_ms: number) {
+        const onTimer = async () => {
+            switch (this.state) {
+                case AutomaticStartStopState.Starting:
+                    return true;
+                case AutomaticStartStopState.Stopping:
+                case AutomaticStartStopState.Stopped:
+                    // false: stop the timer.
+                    return false;
+            }
+
+            let timeDiff = Date.now() - this.lastStartDate;
+
+            if (timeDiff>toWait_ms) {
+                await this.stop();
+                // false: stop the timer.
+                return false;
+            }
+
+            return true;
+        }
+
+        newInterval(ONE_MINUTE, onTimer);
+    }
+}

package/src/@core/browserCacheControl.ts

@@ -0,0 +1,40 @@
+import type {JopiRequest} from "./jopiRequest.ts";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_crypto from "jopi-toolkit/jk_crypto";
+
+export type BrowserCacheValidationInfos = {
+    etag: string;
+    fileState: jk_fs.FileState;
+};
+
+export interface BrowserCacheStrategy {
+    cacheDuration?: number;
+}
+
+export interface ReqReturnFileParams extends BrowserCacheStrategy {
+    contentEncoding?: string;
+    cacheDuration?: number;
+}
+
+export interface TryReturnFileParams extends ReqReturnFileParams {
+    req: JopiRequest;
+    filePath: string;
+    contentEncoding: string|undefined;
+    validationInfos: BrowserCacheValidationInfos;
+}
+
+export function addBrowserCacheControlHeaders(headers: any, params: TryReturnFileParams) {
+    let stats = params.validationInfos.fileState;
+    headers["etag"] = params.validationInfos.etag;
+    headers["last-modified"] = new Date(stats.mtimeMs).toUTCString();
+
+    if (params.cacheDuration) {
+        headers["cache-control"] = `Cache-Control: public, max-age=${params.cacheDuration}, immutable`;
+    } else {
+        headers["cache-control"] = "public, max-age=0, must-revalidate";
+    }
+}
+
+export function calcETagForText(text: string): string {
+    return jk_crypto.fastHash(text);
+}

package/src/@core/bundler/bundler.ts

@@ -0,0 +1,128 @@
+import {WebSiteImpl} from "../jopiWebSite.tsx";
+import {serverInitChronos} from "../internalTools.ts";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_events from "jopi-toolkit/jk_events";
+import {getBundleDirPath} from "./common.ts";
+import {type BundlerConfig, getBundlerConfig} from "./config.ts";
+import {getExtraCssToBundle} from "./extraContent.ts";
+import {configureServer} from "./server.ts";
+import {getVirtualUrlMap, type VirtualUrlEntry} from "jopijs/loader-tools";
+import "./pagesGenerator.ts";
+import {isSinglePageMode} from "jopijs/loader-client";
+import {logBundler} from "../_logs.ts";
+
+export interface CreateBundleParams {
+    // Is enabled when JOPI_DEV or JOPI_DEV_UI
+    // If bun.js: bundler is never called when JOPI_DEV_UI.
+    //            since it uses React HMR mode.
+    //
+    singlePageMode: boolean;
+
+    innerUrl: string;
+
+    entryPoints: string[];
+    outputDir: string;
+    genDir: string;
+    publicUrl: string;
+    webSite: WebSiteImpl;
+    config: BundlerConfig,
+    requireTailwind: boolean;
+    virtualUrlMap: VirtualUrlEntry[];
+
+    pageRoute?: string;
+    pageKey?: string;
+    pageScript?: string;
+
+    promise?: Promise<void>;
+}
+
+export async function createBundle(webSite: WebSiteImpl): Promise<void> {
+    serverInitChronos.start("createBrowserBundle", "Time for building browser bundler")
+
+    const genDir = getBundleDirPath(webSite);
+    const outputDir = jk_fs.join(genDir, "out");
+
+    // Reset the dir.
+    await jk_fs.rmDir(genDir);
+    await jk_fs.mkDir(genDir);
+
+    const innerUrl =  "/_bundle/";
+    const publicUrl = webSite.welcomeUrl + innerUrl;
+
+    // noinspection PointlessBooleanExpressionJS
+    const requireTailwind: boolean = (getBundlerConfig().tailwind.disable) !== true;
+
+    const cssToImport = [...getExtraCssToBundle()];
+
+    if (requireTailwind) cssToImport.push("./tailwind.css");
+
+    // Bun has his own bundler system of development.
+    const config = getBundlerConfig();
+
+    gCreateBundleData = {
+        singlePageMode: isSinglePageMode(),
+        outputDir, genDir, publicUrl, innerUrl, webSite, requireTailwind,
+        config: getBundlerConfig(), entryPoints: [...config.entryPoints],
+        virtualUrlMap: getVirtualUrlMap()
+    }
+
+    await executeBundler(gCreateBundleData);
+
+    configureServer(outputDir);
+    serverInitChronos.end();
+}
+
+let gCreateBundleData: CreateBundleParams|undefined;
+
+let gPageBundlerIsOk: Record<string, boolean> = {};
+
+export async function createBundleForPage(pageKey: string, route: string) {
+    // Allow knowing of this page is already compiled.
+    if (gPageBundlerIsOk[pageKey]) return;
+    gPageBundlerIsOk[pageKey] = true;
+
+    const endLog = logBundler.beginInfo((w) => w("Bundling page for route " + route));
+
+    let fileName = pageKey + ".jsx";
+
+    if (!gCreateBundleData) return;
+
+    let params = {...gCreateBundleData};
+    params.pageRoute = route;
+    params.pageKey = pageKey;
+    params.pageScript = jk_fs.join(params.genDir, fileName);
+
+    await jk_events.sendAsyncEvent("@jopi.bundler.beforeCreateBundleForPage", params);
+    await jk_events.sendAsyncEvent("@jopi.bundler.createBundleForPage", params);
+
+    endLog();
+}
+
+async function executeBundler(params: CreateBundleParams) {
+    if (!gIsBundlerLoader) {
+        gIsBundlerLoader = true;
+        await import(FALLBACK_PACKAGE);
+    }
+
+    // createBundle is called when the event is triggered.
+    //
+    // Here we will compile all the pages in one go.
+    // It's why it's not enabled with single-page mode.
+    //
+    // When using React HMR, we don't use the same bundler.
+    // (internally it's an optimized single-page mode).
+    // So, we don't need to compile the full bundle.
+
+    if (!isSinglePageMode()) {
+        const endLog = logBundler.beginInfo("Bundling all pages");
+
+        // Will create the HTML pages.
+        await jk_events.sendAsyncEvent("@jopi.bundler.beforeCreateBundle", params);
+        await jk_events.sendAsyncEvent("@jopi.bundler.createBundle", params);
+
+        endLog();
+    }
+}
+//
+const FALLBACK_PACKAGE = "jopijs/bundler";
+let gIsBundlerLoader = false;

package/src/@core/bundler/common.ts

@@ -0,0 +1,18 @@
+import {type WebSite, WebSiteImpl} from "../jopiWebSite.js";
+import path from "node:path";
+import * as jk_app from "jopi-toolkit/jk_app";
+
+export function getBundleDirPath(webSite: WebSite) {
+    // To known: the loader uses jopi.webSiteUrl from "package.json".
+    // This can create a situation where we have 2 output directories for
+    // the same website.
+    //
+    let webSiteHost = (webSite as WebSiteImpl).host.replaceAll(".", "_").replaceAll(":", "_");
+    return path.join(gTempDirPath, webSiteHost);
+}
+
+// Don't use node_modules because of a bug when using workspaces.
+// This bug is doing that WebStorm doesn't resolve the file to his real location
+// but to the workspace node_modules (and not the project inside the workspace).
+//
+let gTempDirPath = path.resolve(jk_app.getTempDir(), ".reactHydrateCache");

package/src/@core/bundler/config.ts

@@ -0,0 +1,37 @@
+import type {Config as TailwindConfig} from 'tailwindcss';
+import postcss from 'postcss';
+
+export type PostCssInitializer = (sources: string[], tailwindPlugin:  postcss.AcceptedPlugin|undefined) => postcss.AcceptedPlugin[];
+
+export interface BundlerConfig {
+    tailwind: {
+        config?: TailwindConfig;
+
+        globalCssContent?: string;
+        globalCssFilePath?: string;
+
+        disable?: boolean;
+        extraSourceFiles?: string[];
+    },
+
+    postCss: {
+        initializer?: PostCssInitializer;
+    },
+
+    embed: {
+        dontEmbedThis?: string[];
+    },
+
+    entryPoints: string[];
+}
+
+const gBundlerConfig: BundlerConfig = {
+    tailwind: {},
+    postCss: {},
+    embed: {},
+    entryPoints: []
+}
+
+export function getBundlerConfig(): BundlerConfig {
+    return gBundlerConfig;
+}

package/src/@core/bundler/extraContent.ts

@@ -0,0 +1,30 @@
+import {addVirtualUrlEntry, type VirtualUrlEntry} from "jopijs/loader-tools";
+import * as jk_events from "jopi-toolkit/jk_events";
+
+/**
+ * Add a CSS file which must be bundled with the page.
+ */
+export function addExtraCssToBundle(cssFilePath: string) {
+    gHasManuallyIncludedCss = true;
+    if (gAllCssFiles.includes(cssFilePath)) return;
+    gAllCssFiles.push(cssFilePath);
+}
+
+export function hasExternalCssToBundle() {
+    return gHasManuallyIncludedCss;
+}
+
+export function getExtraCssToBundle(): string[] {
+    return gAllCssFiles;
+}
+
+jk_events.addListener<VirtualUrlEntry>("jopi.virtualUrl.added", (v) => {
+    if (!v.url) debugger;
+
+    if (v.url && v.url.endsWith(".css") || v.url.endsWith(".scss")) {
+        addExtraCssToBundle(v.sourceFile);
+    }
+});
+
+let gHasManuallyIncludedCss = false;
+const gAllCssFiles: string[] = [];