First draft

src/bin/generateFtl.ts

@@ -0,0 +1,105 @@
+
+
+import cheerio from "cheerio";
+import {
+    replaceImportFromStaticInJsCode,
+    generateCssCodeToDefineGlobals
+} from "./replaceImportFromStatic";
+
+export function generateFtlFilesCodeFactory(
+    params: {
+        ftlValuesGlobalName: string;
+        cssGlobalsToDefine: Record<string, string>;
+        indexHtmlCode: string;
+    }
+) {
+
+    const { ftlValuesGlobalName, cssGlobalsToDefine, indexHtmlCode } = params;
+
+    const $ = cheerio.load(indexHtmlCode);
+
+    $("script:not([src])").each((...[, element]) => {
+
+        const { fixedJsCode } = replaceImportFromStaticInJsCode({
+            ftlValuesGlobalName,
+            "jsCode": $(element).html()!
+        });
+
+        $(element).html(fixedJsCode);
+
+    });
+
+
+    ([
+        ["link", "href"],
+        ["script", "src"],
+    ] as const).forEach(([selector, attrName]) =>
+        $(selector).each((...[, element]) => {
+
+            const href = $(element).attr(attrName);
+
+            if (!href?.startsWith("/")) {
+                return;
+            }
+
+            $(element).attr(attrName, "${url.resourcesPath}" + href);
+
+        })
+    );
+
+    $("head").prepend(
+        [
+            '',
+            '<style>',
+            generateCssCodeToDefineGlobals(
+                { cssGlobalsToDefine }
+            ).cssCodeToPrependInHead,
+            '</style>',
+            '',
+            '<script>',
+            '    Object.assign(',
+            `        window.${ftlValuesGlobalName},`,
+            '        {',
+            '            "url": {',
+            '                "loginAction": "${url.loginAction}",',
+            '                "resourcesPath": "${url.resourcesPath}"',
+            '            }',
+            '        }',
+            '    });',
+            '</script>',
+            ''
+        ].join("\n"),
+    );
+
+
+    const partiallyFixedIndexHtmlCode = $.html();
+
+    function generateFtlFilesCode(
+        params: {
+            pageBasename: "login.ftl" | "register.ftl"
+        }
+    ): { ftlCode: string; } {
+
+        const { pageBasename } = params;
+
+        const $ = cheerio.load(partiallyFixedIndexHtmlCode);
+
+        $("head").prepend(
+            [
+                '',
+                '<script>',
+                `   window.${ftlValuesGlobalName} = { "pageBasename": "${pageBasename}" };'`,
+                '</script>',
+                ''
+            ].join("\n"),
+
+        );
+
+        return { "ftlCode": $.html() };
+
+    }
+
+    return { generateFtlFilesCode };
+
+
+}

src/bin/main.ts

@@ -0,0 +1,80 @@
+
+import { transformCodebase } from "../tools/transformCodebase";
+import * as fs from "fs";
+import { join as pathJoin } from "path";
+import { assert } from "evt/tools/typeSafety/assert";
+import {
+    replaceImportFromStaticInCssCode,
+    replaceImportFromStaticInJsCode
+} from "./replaceImportFromStatic";
+import { generateFtlFilesCodeFactory } from "./generateFtl";
+
+
+const reactAppBuildDirPath = pathJoin(__dirname, "build");
+
+assert(
+    fs.existsSync(reactAppBuildDirPath),
+    "Run 'react-script build' first (the build dir should be present)"
+);
+
+const keycloakDir = pathJoin(reactAppBuildDirPath, "..", "keycloak_build");
+
+let allCssGlobalsToDefine: Record<string, string> = {};
+
+const ftlValuesGlobalName = "keycloakFtlValues";
+
+
+transformCodebase({
+    "destDirPath": pathJoin(keycloakDir, "login", "resources"),
+    "srcDirPath": reactAppBuildDirPath,
+    "transformSourceCodeString": ({ filePath, sourceCode }) => {
+
+        if (/\.css?$/i.test(filePath)) {
+
+            const { cssGlobalsToDefine, fixedCssCode } = replaceImportFromStaticInCssCode(
+                { "cssCode": sourceCode.toString("utf8") }
+            );
+
+            allCssGlobalsToDefine = {
+                ...allCssGlobalsToDefine,
+                ...cssGlobalsToDefine
+            };
+
+            return { "modifiedSourceCode": Buffer.from(fixedCssCode, "utf8") };
+
+        }
+
+        if (/\.js?$/i.test(filePath)) {
+
+            const { fixedJsCode } = replaceImportFromStaticInJsCode({
+                "jsCode": sourceCode.toString("utf8"),
+                ftlValuesGlobalName
+            });
+
+            return { "modifiedSourceCode": Buffer.from(fixedJsCode, "utf8") };
+
+        }
+
+        return { "modifiedSourceCode": sourceCode };
+
+    }
+});
+
+const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
+    "cssGlobalsToDefine": allCssGlobalsToDefine,
+    ftlValuesGlobalName,
+    "indexHtmlCode": fs.readFileSync(
+        pathJoin(reactAppBuildDirPath, "index.html")
+    ).toString("utf8")
+});
+
+(["login.ftl", "register.ftl"] as const).forEach(pageBasename => {
+
+    const { ftlCode } = generateFtlFilesCode({ pageBasename });
+
+    fs.writeFileSync(
+        pathJoin(keycloakDir, "login", pageBasename),
+        Buffer.from(ftlCode, "utf8")
+    )
+
+});

src/bin/replaceImportFromStatic.ts

@@ -0,0 +1,91 @@
+
+import * as crypto from "crypto";
+
+export function replaceImportFromStaticInJsCode(
+    params: {
+        ftlValuesGlobalName: string;
+        jsCode: string;
+    }
+): { fixedJsCode: string; } {
+
+    const { jsCode, ftlValuesGlobalName } = params;
+
+    const fixedJsCode = jsCode!.replace(
+        /"static\//g,
+        `window.${ftlValuesGlobalName}.url.resourcesPath.replace(/^\//,"") + "/" + "static/`
+    );
+
+    return { fixedJsCode };
+
+}
+
+export function replaceImportFromStaticInCssCode(
+    params: {
+        cssCode: string;
+    }
+): {
+    fixedCssCode: string;
+    cssGlobalsToDefine: Record<string, string>;
+} {
+
+    const { cssCode } = params;
+
+    const cssGlobalsToDefine: Record<string, string> = {};
+
+    new Set(cssCode.match(/(url\(\/[^)]+\))/g) ?? [])
+        .forEach(match =>
+            cssGlobalsToDefine[
+            "url" + crypto
+                .createHash("sha256")
+                .update(match)
+                .digest("hex")
+                .substring(0, 15)
+            ] = match
+        );
+
+    let fixedCssCode = cssCode;
+
+    Object.keys(cssGlobalsToDefine).forEach(
+        cssVariableName =>
+            //NOTE: split/join pattern ~ replace all
+            fixedCssCode =
+            fixedCssCode.split(cssGlobalsToDefine[cssVariableName])
+                .join(`var(--${cssVariableName})`)
+    );
+
+    return { fixedCssCode, cssGlobalsToDefine };
+
+}
+
+export function generateCssCodeToDefineGlobals(
+    params: {
+        cssGlobalsToDefine: Record<string, string>;
+    }
+): {
+    cssCodeToPrependInHead: string;
+} {
+
+    const { cssGlobalsToDefine } = params;
+
+    return {
+        "cssCodeToPrependInHead": [
+            ":root {",
+            ...Object.keys(cssGlobalsToDefine)
+                .map(cssVariableName => [
+                    `--${cssVariableName}:`,
+                    [
+                        "url(",
+                        "${url.resourcesPath}" +
+                        cssGlobalsToDefine[cssVariableName].match(/^url\(([^)]+)\)$/)![1],
+                        ")"
+                    ].join("")
+                ].join(" "))
+                .map(line => "    " + line),
+            "}"
+        ].join("\n")
+    };
+
+}
+
+
+