jopijs 0.0.1

package/dist/@uikit/reactRouter/index.d.ts

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

package/dist/@uikit/reactRouter/index.js

@@ -0,0 +1,2 @@
+export * from "./hooks/jBundler_ifServer.js";
+//# sourceMappingURL=index.js.map

package/dist/@uikit/reactRouter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/@uikit/reactRouter/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA+B,CAAC"}

package/dist/@uikit/users/hooks.d.ts

@@ -0,0 +1,10 @@
+import { type UiUserInfos } from "jopijs/ui";
+import React from "react";
+export declare function useLogOutUser(): () => void;
+export declare function useUserStateRefresh(): () => void;
+export declare function useUserHasRoles(roles: string[]): boolean;
+export declare function useUserInfos(): UiUserInfos | undefined;
+export declare function RequireRoles({ roles, children }: {
+    roles: string[];
+    children: React.ReactNode;
+}): React.ReactNode;

package/dist/@uikit/users/hooks.js

@@ -0,0 +1,39 @@
+import { _usePage } from "jopijs/ui";
+import React from "react";
+export function useLogOutUser() {
+    const page = _usePage();
+    return () => {
+        page.logOutUser();
+        page.onRequireRefresh();
+    };
+}
+export function useUserStateRefresh() {
+    const page = _usePage();
+    return () => {
+        page.refreshUserInfos();
+        page.onRequireRefresh();
+    };
+}
+export function useUserHasRoles(roles) {
+    if (roles.length === 0)
+        return true;
+    let userInfos = useUserInfos();
+    if (!userInfos)
+        return false;
+    let userRoles = userInfos.roles;
+    if (!userRoles)
+        return false;
+    return !!roles.every(role => userRoles.includes(role));
+}
+export function useUserInfos() {
+    const page = _usePage();
+    return page.getUserInfos();
+}
+export function RequireRoles({ roles, children }) {
+    const hasRoles = useUserHasRoles(roles);
+    if (hasRoles) {
+        return children;
+    }
+    return null;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/@uikit/users/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/@uikit/users/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAmB,MAAM,WAAW,CAAC;AACrD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,UAAU,aAAa;IACzB,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;IAExB,OAAO,GAAG,EAAE;QACR,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC,CAAA;AACL,CAAC;AAED,MAAM,UAAU,mBAAmB;IAC/B,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;IAExB,OAAO,GAAG,EAAE;QACR,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5B,CAAC,CAAA;AACL,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAe;IAC3C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpC,IAAI,SAAS,GAAG,YAAY,EAAE,CAAC;IAC/B,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAE7B,IAAI,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC;IAChC,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAE7B,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,YAAY;IACxB,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC;IACxB,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,EAAC,KAAK,EAAE,QAAQ,EAG5C;IACG,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IAExC,IAAI,QAAQ,EAAE,CAAC;QACX,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/@uikit/users/index.d.ts

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

package/dist/@uikit/users/index.js

@@ -0,0 +1,2 @@
+export * from "./hooks.js";
+//# sourceMappingURL=index.js.map

package/dist/@uikit/users/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/@uikit/users/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/@uikit/variants/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare const VariantContext: React.Context<any>;
+export declare function VariantProvider({ children, variants }: {
+    children: React.ReactNode;
+    variants?: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useVariant<T extends React.FC>(name: string, defaultValue?: T | undefined): any;

package/dist/@uikit/variants/index.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+export const VariantContext = React.createContext({});
+export function VariantProvider({ children, variants }) {
+    return _jsx(VariantContext.Provider, { value: variants, children: children });
+}
+export function useVariant(name, defaultValue) {
+    const variants = React.useContext(VariantContext);
+    return variants[name] ?? (defaultValue ?? variantNotFound(name));
+}
+function variantNotFound(variantName) {
+    return function () {
+        return _jsxs("div", { children: ["Variant not found: ", variantName] });
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/@uikit/variants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/@uikit/variants/index.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,aAAa,CAAM,EAAE,CAAC,CAAC;AAE3D,MAAM,UAAU,eAAe,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAA8C;IAC7F,OAAO,KAAC,cAAc,CAAC,QAAQ,IAAC,KAAK,EAAE,QAAQ,YAC1C,QAAQ,GACa,CAAA;AAC9B,CAAC;AAED,MAAM,UAAU,UAAU,CAAqB,IAAY,EAAE,YAA0B;IACnF,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IAClD,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,eAAe,CAAC,WAAmB;IACxC,OAAO;QACH,OAAO,iDAAyB,WAAW,IAAO,CAAC;IACvD,CAAC,CAAA;AACL,CAAC"}

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "jopijs",
+  "version": "0.0.1",
+  "publishedDate": "11/20/2025",
+  "publicPublishedDate": "11/19/2025",
+  "license": "MIT",
+  "homepage": "https://github.com/johanpiquet/jopijs",
+  "keywords": [
+    "express.js",
+    "nextjs",
+    "react",
+    "react-ssr",
+    "react-hydrate"
+  ],
+  "author": "Johan PIQUET",
+  "description": "A web framework for building proxy/cache and react-hydrate applications",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "type": "module",
+  "files": [
+    "/dist",
+    "./src",
+    "./bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "jopib": "bin/jopib.js",
+    "jopin": "bin/jopin.js"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist .turbo tsconfig.tsbuildinfo",
+    "build:priority:2": "npx tsc",
+    "bun-publish": "bun publish",
+    "untrack": "git rm -r --cached -- ./dist/**;"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/postcss-url": "^10.0.4",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@types/ws": "^8.18.1"
+  },
+  "dependencies": {
+    "@tailwindcss/postcss": "^4.1.12",
+    "acme-client": "^5.4.0",
+    "cheerio": "^1.1.2",
+    "chokidar": "^4.0.3",
+    "css-url-parser": "^1.1.4",
+    "esbuild": "=0.25.9",
+    "jopi-toolkit": "^3.0.5",
+    "jsonwebtoken": "^9.0.2",
+    "magic-string": "^0.30.19",
+    "postcss": "^8.5.6",
+    "postcss-modules": "^6.0.1",
+    "postcss-url": "^10.1.3",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-router": "^7.8.2",
+    "rou3": "^0.7.3",
+    "sass": "^1.90.0",
+    "source-map": "^0.7.6",
+    "strip-json-comments": "^5.0.3",
+    "tailwindcss": "^4.1.12",
+    "ws": "^8.18.3"
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/@core/index.ts",
+      "default": "./dist/@core/index.js"
+    },
+    "./ui": {
+      "bun": "./src/@ui/index.ts",
+      "default": "./dist/@ui/index.js"
+    },
+    "./uikit": {
+      "bun": "./src/@uikit/index.ts",
+      "default": "./dist/@uikit/index.js"
+    },
+    "./bundler": {
+      "bun": "./src/@bundler/index.ts",
+      "default": "./dist/@bundler/index.js"
+    },
+    "./crawler": {
+      "bun": "./src/@crawler/index.ts",
+      "default": "./dist/@crawler/index.js"
+    },
+    "./generated": {
+      "bun": "./src/@generated/index.ts",
+      "default": "./dist/@generated/index.js"
+    },
+    "./loader": {
+      "bun": "./src/@loader/index.ts",
+      "default": "./dist/@loader/index.js"
+    },
+    "./loader/loader.mjs": "./src/@loader/loader.mjs",
+    "./bun-server-static": "./src/@loader/bunHtmlCompiler.mjs",
+    "./loader-tools": "./dist/@loader-tools/index.js",
+    "./loader-client": {
+      "bun": "./src/@loader-client/index.ts",
+      "default": "./dist/@loader-client/index.js"
+    },
+    "./linker": {
+      "bun": "./src/@linker/index.ts",
+      "default": "./dist/@linker/index.js"
+    },
+    "./tool-jopinb": {
+      "bun": "./src/@tool-jopinb/index.ts",
+      "default": "./dist/@tool-jopinb/index.js"
+    },
+    "./types": "./src/@loader-types/extensions.d.ts"
+  }
+}

package/src/@bundler/README.md

@@ -0,0 +1 @@
+Contains the bundler functionalities of Jopi Rewrite.

package/src/@bundler/_logs.ts

@@ -0,0 +1,4 @@
+import {getLogger} from "jopi-toolkit/jk_logs";
+
+export const logBundler = getLogger("jopi.bundler");
+export const logServer_refresh = getLogger("refresh", logBundler);

package/src/@bundler/core.ts

@@ -0,0 +1,41 @@
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as jk_events from "jopi-toolkit/jk_events";
+import type {CreateBundleParams} from "jopijs";
+import {isReactHMR} from "jopijs/loader-client";
+import {esBuildBundle} from "./esbuild.ts";
+
+async function createBundle(params: CreateBundleParams): Promise<void> {
+    const config = params.config;
+
+    // Load the metadata generated.
+    const metaDataFilePath = jk_fs.join(params.genDir, "esbuildMeta.json");
+
+    process.env.JOPI_BUNLDER_ESBUILD = "1";
+
+    try {
+        await esBuildBundle({
+            metaDataFilePath,
+            dontEmbed: config.embed.dontEmbedThis,
+
+            ...params
+        });
+    }
+    finally {
+        delete process.env.JOPI_BUNLDER_ESBUILD;
+    }
+}
+
+jk_events.addListener("@jopi.bundler.createBundle", jk_events.EventPriority.veryLow, async (params: CreateBundleParams) => {
+    // For React HMR, creating the full bundle is not required
+    // and will only slow down the startup.
+    //
+    if (isReactHMR()) return;
+
+    // Will compile all the pages.
+    await createBundle(params);
+});
+
+jk_events.addListener("@jopi.bundler.createBundleForPage", jk_events.EventPriority.veryLow, async (params: CreateBundleParams) => {
+    // Will compile only the selected page, because of params values.
+    await createBundle(params);
+});

package/src/@bundler/esbuild.ts

@@ -0,0 +1,141 @@
+import esbuild, {type BuildResult} from "esbuild";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import * as n_what from "jopi-toolkit/jk_what";
+import type {CreateBundleParams} from "../@core/index.ts";
+import {jopiReplaceText, jopiLoaderPlugin, jopiDetectRebuild} from "./plugins.ts";
+import {applyTailwindProcessor} from "./tailwind.ts";
+
+export interface EsBuildParams extends CreateBundleParams {
+    metaDataFilePath: string;
+    dontEmbed: string[]|undefined;
+}
+
+export async function esBuildBundle(params: EsBuildParams) {
+    // To know: will generate:
+    // * Some files out/page_xxxx.js, where each page is an "page.tsx".
+    // * Some files out/page_xxxx.css with the CSS specific to this page.
+
+    const buildOptions: esbuild.BuildOptions = {
+        entryPoints: params.entryPoints,
+
+        bundle: true,
+        outdir: params.outputDir,
+        external:  params.dontEmbed,
+
+        // Allows generating relative url
+        // without the full website name.
+        //
+        publicPath: "/_bundle/",
+
+        platform: 'browser',
+        format: 'esm',
+        target: "es2020",
+
+        splitting: true,
+
+        plugins: [
+            jopiLoaderPlugin,
+            jopiReplaceText()
+        ],
+
+        loader: {
+            ".css": "css",
+            ".scss": "css",
+
+            // Polices
+            '.woff': 'file',
+            '.woff2': 'file',
+            '.ttf': 'file',
+            '.eot': 'file',
+
+            // Images
+            '.jpg': 'file',
+            '.jpeg': 'file',
+            '.png': 'file',
+            '.svg': 'file',
+            '.gif': 'file',
+            '.webp': 'file',
+
+            // Media
+            '.mp3': 'file',
+            '.mp4': 'file',
+
+            // Others
+            '.html': 'text',
+            '.md': 'text'
+        },
+
+        minify: true,
+        //minify: false,
+        sourcemap: true,
+
+        // Will trigger an error on collision detection.
+        allowOverwrite: false,
+
+        // Produce metadata about the build.
+        metafile: true
+    };
+
+    // Note: each page is compiled one time.
+    // Once compiled, the watch mode will refresh it.
+    //
+    if (params.singlePageMode) {
+        buildOptions.publicPath += params.pageKey! + '/';
+        buildOptions.entryPoints = [params.pageScript!];
+        buildOptions.outdir = jk_fs.join(buildOptions.outdir!, params.pageKey!);
+        buildOptions.plugins?.push(jopiDetectRebuild(params));
+    }
+
+    await applyTailwindProcessor(params);
+
+    const context = await esbuild.context(buildOptions);
+    let result: BuildResult = await context.rebuild();
+
+    if (params.singlePageMode) {
+        try {
+            // Will allows the page to be automatically updated.
+            await context.watch({
+                delay: n_what.isNodeJS ? 100 : 0
+            });
+        } catch {
+            process.exit(1);
+        }
+    }
+
+    // >>> Resolve virtual urls
+
+    // The url is formed before the bundle is done.
+    // It's why we don't know the final url of the resource
+    // which is a processed and transformed resource, especially
+    // for CSS files, which content is resolving his dependencies.
+
+    if (params.virtualUrlMap) {
+        const allMeta = result.metafile!;
+
+        if (allMeta.outputs) {
+            for (const outputFilePath in allMeta.outputs) {
+                const ext = jk_fs.extname(outputFilePath);
+                if ([".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"].includes(ext)) continue;
+
+                const metaValue = allMeta.outputs[outputFilePath];
+
+                if (metaValue.inputs) {
+                    const inputs = metaValue.inputs;
+
+                    for (let inputFilePath of Object.keys(inputs)) {
+                        const key = jk_fs.resolve(inputFilePath);
+                        const entry = params.virtualUrlMap.find(e => e.sourceFile === key);
+
+                        // Don't override if already set because the next
+                        // entry can be a resource using our entry, so it
+                        // will be overridden.
+                        //
+                        if (entry && !entry.bundleFile) {
+                            entry.bundleFile = jk_fs.resolve(outputFilePath);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/src/@bundler/index.ts

@@ -0,0 +1,3 @@
+export {getGlobalCssFileContent} from "./tailwind.ts";
+
+import "./core.ts";

package/src/@bundler/plugins.ts

@@ -0,0 +1,163 @@
+import {type Plugin} from "esbuild";
+import fs from "node:fs/promises";
+import path from "node:path";
+import {applyTailwindProcessor} from "./tailwind.ts";
+import * as jk_events from "jopi-toolkit/jk_events";
+import type {EsBuildParams} from "./esbuild.ts";
+import {installEsBuildPlugins} from "jopijs/loader-tools";
+import MagicString from 'magic-string';
+import {SourceMapConsumer, SourceMapGenerator} from "source-map";
+import {logServer_refresh} from "./_logs.ts";
+
+/**
+ * This plugin allows replacing some text entries according to rules.
+ */
+export function jopiReplaceText(): Plugin {
+    async function getExistingSourceMap(filePath: string, source: string): Promise<string | null> {
+        const sourceMapCommentMatch = source.match(/\/\/# sourceMappingURL=(.+)$/m);
+        if (!sourceMapCommentMatch) return null;
+
+        const sourceMapUrl = sourceMapCommentMatch[1];
+
+        if (sourceMapUrl.startsWith('data:application/json;base64,')) {
+            const base64Content = sourceMapUrl.replace('data:application/json;base64,', '');
+            return Buffer.from(base64Content, 'base64').toString('utf8');
+        } else {
+            const sourceMapPath = path.resolve(path.dirname(filePath), sourceMapUrl);
+            try {
+                return await fs.readFile(sourceMapPath, 'utf8');
+            } catch {
+                return null;
+            }
+        }
+    }
+
+    return {
+        name: "jopi-replace-text",
+
+        setup(build) {
+            build.onLoad({ filter: /\.(tsx|jsx|js)$/ }, async (args) => {
+                const oldContent = await fs.readFile(args.path, 'utf8');
+                let newContent = oldContent.replace("jBundler_ifServer", "jBundler_ifBrowser");
+                if (newContent === oldContent) return undefined;
+
+                const useSourceMap = !!build.initialOptions.sourcemap;
+
+                if (!useSourceMap) {
+                    let loader = path.extname(args.path).toLowerCase().substring(1);
+                    return {contents: newContent, loader: loader as 'js' | 'jsx' | 'ts' | 'tsx'};
+                }
+
+                const existingSourceMap = await getExistingSourceMap(args.path, oldContent);
+                const magic = new MagicString(oldContent, {filename: args.path});
+                magic.replace("jBundler_ifServer", "jBundler_ifBrowser");
+
+                const map = magic.generateMap({
+                    file: args.path,
+                    source: path.basename(args.path),
+                    includeContent: true,
+                    hires: true
+                });
+
+                let finalMap: string;
+
+                // Will merge the existing and final source-map.
+                //
+                if (existingSourceMap) {
+                    const consumerExisting = await new SourceMapConsumer(existingSourceMap);
+                    const generator = SourceMapGenerator.fromSourceMap(consumerExisting);
+
+                    const consumerNew = await new SourceMapConsumer(JSON.parse(map.toString()));
+                    consumerNew.eachMapping((mapping) => {
+                        if (mapping.originalLine != null && mapping.originalColumn != null) {
+                            generator.addMapping({
+                                source: mapping.source || path.basename(args.path),
+                                original: { line: mapping.originalLine, column: mapping.originalColumn },
+                                generated: { line: mapping.generatedLine, column: mapping.generatedColumn },
+                                name: mapping.name,
+                            });
+                        }
+                    });
+
+                    consumerNew.sources.forEach((source) => {
+                        const content = consumerNew.sourceContentFor(source, true);
+                        if (content) {
+                            generator.setSourceContent(source, content);
+                        }
+                    });
+
+                    finalMap = JSON.stringify(generator.toJSON());
+                    consumerNew.destroy();
+                    consumerExisting.destroy();
+                } else {
+                    finalMap = map.toString();
+                }
+
+                newContent = magic.toString() +
+                    `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(finalMap).toString('base64')}`;
+
+                let loader = path.extname(args.path).toLowerCase().substring(1);
+                return {contents: newContent, loader: loader as 'js' | 'jsx' | 'ts' | 'tsx'};
+            });
+        }
+    };
+}
+
+export function jopiDetectRebuild(params: EsBuildParams): Plugin {
+    // Allow avoiding behaviors with TypeScript compiler doing some late works.
+    //
+    let isEnabled = false;
+    setTimeout(() => { isEnabled = true }, 2000);
+
+    return {
+        name: "jopi-detect-rebuild",
+
+        setup(build) {
+            build.onStart(async () => {
+                // isEnabled is automatically set to true after 2 seconds.
+                // It allows avoiding some behaviors with false calls from EsBuild.
+                // (probably caused by the dev-tools, including TypeScript compiler)
+                //
+                if (!isEnabled) return;
+
+                if (params.singlePageMode) {
+                    logServer_refresh.info("Refreshing page " + params.pageRoute);
+                }
+
+                // Rebuild Tailwind.
+                // - Single page mode: rebuild only the local tailwind.
+                // - Global mode: never occurs.
+                //
+                if (params.requireTailwind) {
+                    await applyTailwindProcessor(params);
+                }
+
+                if (params.singlePageMode) {
+                    // This event will execute Jopi Linker.
+                    await jk_events.sendAsyncEvent("@jopi.bundler.watch.beforeRebuild");
+                }
+            });
+
+            build.onEnd(async () => {
+                if (!isEnabled) return;
+
+                if (params.singlePageMode) {
+                    // This event will execute trigger the SSE event that refreshes the browser.
+                    await jk_events.sendAsyncEvent("@jopi.bundler.watch.afterRebuild");
+                }
+            });
+        }
+    }
+}
+
+/**
+ * Allows managing custom import:
+ * * Importing CSS modules (.module.css)
+ * * Import with ?raw and ?inline
+ */
+export const jopiLoaderPlugin: Plugin = {
+    name: "jopi-loader",
+    setup(build) {
+        installEsBuildPlugins(build as unknown as Bun.PluginBuilder)
+    },
+};