keycloakify 11.5.3 → 11.6.0

package/bin/{682.index.js → 153.index.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 682;
-exports.ids = [682];
+exports.id = 153;
+exports.ids = [153];
 exports.modules = {
 
-/***/ 6682:
+/***/ 43153:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -271,9 +271,7 @@ function startViteDevServer(params) {
 //# sourceMappingURL=startViteDevServer.js.map
 // EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
 var is = __webpack_require__(16453);
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson.js
-
-
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.js
 
 
 
@@ -325,6 +323,12 @@ const zParsedRealmJson = (() => {
     assert/* assert */.h;
     return (0,id.id)(zTargetType);
 })();
+//# sourceMappingURL=ParsedRealmJson.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js
+
+
+
+
 function readRealmJsonFile(params) {
     const { realmJsonFilePath } = params;
     const parsedRealmJson = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
@@ -332,7 +336,7 @@ function readRealmJsonFile(params) {
     (0,assert/* assert */.h)((0,is.is)(parsedRealmJson));
     return parsedRealmJson;
 }
-//# sourceMappingURL=ParsedRealmJson.js.map
+//# sourceMappingURL=readRealmJsonFile.js.map
 ;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.js
 
 
@@ -556,8 +560,6 @@ const { getCachedValue, setCachedValue } = (() => {
     };
 })();
 //# sourceMappingURL=getSupportedDockerImageTags.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
-var runPrettier = __webpack_require__(48433);
 // EXTERNAL MODULE: ./node_modules/tsafe/esm/objectKeys.mjs
 var objectKeys = __webpack_require__(23483);
 // EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
@@ -774,7 +776,7 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
                 "claim.value": '["*"]',
                 "userinfo.token.claim": "true",
                 "id.token.claim": "false",
-                "lightweight.claim": "false",
+                "lightweight.claim": "true",
                 "access.token.claim": "true",
                 "claim.name": "allowed-origins",
                 "jsonType.label": "JSON",
@@ -802,6 +804,203 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
     }
 }
 //# sourceMappingURL=prepareRealmConfig.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
+;// CONCATENATED MODULE: ./dist/bin/tools/Stringifyable.js
+
+
+
+
+const zStringifyableAtomic = (() => {
+    const zTargetType = lib.z.union([lib.z.string(), lib.z.number(), lib.z.boolean(), lib.z["null"]()]);
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const zStringifyable = lib.z.any()
+    .superRefine((val, ctx) => {
+    const isStringifyable = (0,same.same)(JSON.parse(JSON.stringify(val)), val);
+    if (!isStringifyable) {
+        ctx.addIssue({
+            code: lib.z.ZodIssueCode.custom,
+            message: "Not stringifyable"
+        });
+    }
+});
+function getIsAtomic(stringifyable) {
+    return (["string", "number", "boolean"].includes(typeof stringifyable) ||
+        stringifyable === null);
+}
+const { getValueAtPath } = (() => {
+    function getValueAtPath_rec(stringifyable, path) {
+        if (path.length === 0) {
+            return stringifyable;
+        }
+        if (getIsAtomic(stringifyable)) {
+            return undefined;
+        }
+        const [first, ...rest] = path;
+        let dereferenced;
+        if (stringifyable instanceof Array) {
+            if (typeof first !== "number") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        else {
+            if (typeof first !== "string") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        if (dereferenced === undefined) {
+            return undefined;
+        }
+        return getValueAtPath_rec(dereferenced, rest);
+    }
+    function getValueAtPath(stringifyableObjectOrArray, path) {
+        return getValueAtPath_rec(stringifyableObjectOrArray, path);
+    }
+    return { getValueAtPath };
+})();
+//# sourceMappingURL=Stringifyable.js.map
+;// CONCATENATED MODULE: ./dist/bin/tools/canonicalStringify.js
+
+function canonicalStringify(params) {
+    const { data, referenceData } = params;
+    return JSON.stringify(makeDeterministicCopy({
+        path: [],
+        data,
+        getCanonicalKeys: path => {
+            const referenceValue = (() => {
+                const path_patched = [];
+                for (let i = 0; i < path.length; i++) {
+                    let value_i = getValueAtPath(referenceData, [
+                        ...path_patched,
+                        path[i]
+                    ]);
+                    if (value_i !== undefined) {
+                        path_patched.push(path[i]);
+                        continue;
+                    }
+                    if (typeof path[i] !== "number") {
+                        return undefined;
+                    }
+                    value_i = getValueAtPath(referenceData, [...path_patched, 0]);
+                    if (value_i !== undefined) {
+                        path_patched.push(0);
+                        continue;
+                    }
+                    return undefined;
+                }
+                return getValueAtPath(referenceData, path_patched);
+            })();
+            if (referenceValue === undefined) {
+                return undefined;
+            }
+            if (getIsAtomic(referenceValue)) {
+                return undefined;
+            }
+            if (referenceValue instanceof Array) {
+                return undefined;
+            }
+            return Object.keys(referenceValue);
+        }
+    }), null, 2);
+}
+function makeDeterministicCopy(params) {
+    const { path, data, getCanonicalKeys } = params;
+    if (getIsAtomic(data)) {
+        return data;
+    }
+    if (data instanceof Array) {
+        return makeDeterministicCopy_array({
+            path,
+            data,
+            getCanonicalKeys
+        });
+    }
+    return makeDeterministicCopy_record({
+        path,
+        data,
+        getCanonicalKeys
+    });
+}
+function makeDeterministicCopy_record(params) {
+    const { path, data, getCanonicalKeys } = params;
+    const keysOfAtomicValues = [];
+    const keysOfNonAtomicValues = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (getIsAtomic(value)) {
+            keysOfAtomicValues.push(key);
+        }
+        else {
+            keysOfNonAtomicValues.push(key);
+        }
+    }
+    keysOfAtomicValues.sort();
+    keysOfNonAtomicValues.sort();
+    const keys = [...keysOfAtomicValues, ...keysOfNonAtomicValues];
+    reorder_according_to_canonical: {
+        const canonicalKeys = getCanonicalKeys(path);
+        if (canonicalKeys === undefined) {
+            break reorder_according_to_canonical;
+        }
+        const keys_toPrepend = [];
+        for (const key of canonicalKeys) {
+            const indexOfKey = keys.indexOf(key);
+            if (indexOfKey === -1) {
+                continue;
+            }
+            keys.splice(indexOfKey, 1);
+            keys_toPrepend.push(key);
+        }
+        keys.unshift(...keys_toPrepend);
+    }
+    const result = {};
+    for (const key of keys) {
+        result[key] = makeDeterministicCopy({
+            path: [...path, key],
+            data: data[key],
+            getCanonicalKeys
+        });
+    }
+    return result;
+}
+function makeDeterministicCopy_array(params) {
+    const { path, data, getCanonicalKeys } = params;
+    return [...data].map((entry, i) => makeDeterministicCopy({
+        path: [...path, i],
+        data: entry,
+        getCanonicalKeys
+    }));
+}
+//# sourceMappingURL=canonicalStringify.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.js
+
+
+
+
+async function writeRealmJsonFile(params) {
+    const { realmJsonFilePath, parsedRealmJson, keycloakMajorVersionNumber } = params;
+    let sourceCode = canonicalStringify({
+        data: parsedRealmJson,
+        referenceData: getDefaultConfig({
+            keycloakMajorVersionNumber
+        })
+    });
+    if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
+        sourceCode = await (0,runPrettier/* runPrettier */.eY)({
+            sourceCode: sourceCode,
+            filePath: realmJsonFilePath
+        });
+    }
+    await promises_.writeFile(realmJsonFilePath, Buffer.from(sourceCode, "utf8"));
+}
+//# sourceMappingURL=writeRealmJsonFile.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/index.js
+
+
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/dumpContainerConfig.js
 
 
@@ -947,7 +1146,6 @@ async function dumpContainerConfig(params) {
 
 
 
-
 assert/* assert */.h;
 async function getRealmConfig(params) {
     const { keycloakMajorVersionNumber, realmJsonFilePath_userProvided, buildContext } = params;
@@ -976,18 +1174,11 @@ async function getRealmConfig(params) {
             external_fs_.mkdirSync(dirPath, { recursive: true });
         }
     }
-    const writeRealmJsonFile = async (params) => {
-        const { parsedRealmJson } = params;
-        let sourceCode = JSON.stringify(parsedRealmJson, null, 2);
-        if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
-            sourceCode = await (0,runPrettier/* runPrettier */.eY)({
-                sourceCode,
-                filePath: realmJsonFilePath
-            });
-        }
-        external_fs_.writeFileSync(realmJsonFilePath, sourceCode);
-    };
-    await writeRealmJsonFile({ parsedRealmJson });
+    await writeRealmJsonFile({
+        realmJsonFilePath,
+        parsedRealmJson,
+        keycloakMajorVersionNumber
+    });
     const { onRealmConfigChange } = (() => {
         const run = runExclusive.build(async () => {
             const start = Date.now();
@@ -1004,7 +1195,11 @@ async function getRealmConfig(params) {
                 console.log(source_default().red(`Failed to backup '${realmName}' config:`));
                 return;
             }
-            await writeRealmJsonFile({ parsedRealmJson });
+            await writeRealmJsonFile({
+                realmJsonFilePath,
+                parsedRealmJson,
+                keycloakMajorVersionNumber
+            });
             console.log([
                 source_default().grey(`Save changed to \`.${external_path_.sep}${(0,external_path_.relative)(buildContext.projectDirPath, realmJsonFilePath)}\``),
                 source_default().grey(`Next time you'll be running \`keycloakify start-keycloak\`, the realm '${realmName}' will be restored to this state.`),
@@ -1122,13 +1317,57 @@ async function command(params) {
             source_default().cyan("On which version of Keycloak do you want to test your theme?"),
             source_default().gray("You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 26` (or any other version)")
         ].join("\n"));
-        const { value: tag } = await dist_default()({
-            values: latestMajorTags
-        }).catch(() => {
-            process.exit(-1);
-        });
-        console.log(`→ ${tag}`);
-        return { dockerImageTag: tag };
+        const tag_userSelected = await (async () => {
+            let tag;
+            let latestMajorTags_copy = [...latestMajorTags];
+            while (true) {
+                const { value } = await dist_default()({
+                    values: latestMajorTags_copy
+                }).catch(() => {
+                    process.exit(-1);
+                });
+                tag = value;
+                {
+                    const doImplementAccountMpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type === "Multi-Page";
+                    if (doImplementAccountMpa && tag.startsWith("22.")) {
+                        console.log(source_default().yellow(`You are implementing a Multi-Page Account theme. Keycloak 22 is not supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => !tag.startsWith("22."));
+                        continue;
+                    }
+                }
+                const readMajor = (tag) => {
+                    const major = parseInt(tag.split(".")[0]);
+                    (0,assert/* assert */.h)(!isNaN(major));
+                    return major;
+                };
+                {
+                    const major = readMajor(tag);
+                    const doImplementAdminTheme = buildContext.implementedThemeTypes.admin.isImplemented;
+                    const getIsSupported = (major) => major >= 23;
+                    if (doImplementAdminTheme && !getIsSupported(major)) {
+                        console.log(source_default().yellow(`You are implementing an Admin theme. Only Keycloak 23 and later are supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => getIsSupported(readMajor(tag)));
+                        continue;
+                    }
+                }
+                {
+                    const doImplementAccountSpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type === "Single-Page";
+                    const major = readMajor(tag);
+                    const getIsSupported = (major) => major >= 19;
+                    if (doImplementAccountSpa && !getIsSupported(major)) {
+                        console.log(source_default().yellow(`You are implementing a Single-Page Account theme. Only Keycloak 19 and later are supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => getIsSupported(readMajor(tag)));
+                        continue;
+                    }
+                }
+                break;
+            }
+            return tag;
+        })();
+        console.log(`→ ${tag_userSelected}`);
+        return { dockerImageTag: tag_userSelected };
     })();
     const keycloakMajorVersionNumber = (() => {
         const [wrap] = getSupportedKeycloakMajorVersions()
@@ -1439,31 +1678,40 @@ async function command(params) {
             ignoreInitial: true
         })
             .on("all", async (...[, filePath]) => {
-            ignore_account_spa: {
-                const doImplementAccountSpa = buildContext.implementedThemeTypes.account.isImplemented &&
-                    buildContext.implementedThemeTypes.account.type === "Single-Page";
-                if (!doImplementAccountSpa) {
-                    break ignore_account_spa;
+            ignore_path_covered_by_hmr: {
+                if (filePath.endsWith(".properties")) {
+                    break ignore_path_covered_by_hmr;
                 }
-                if (!(0,isInside/* isInside */.V)({
-                    dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "account"),
-                    filePath
-                })) {
-                    break ignore_account_spa;
+                if (!doStartDevServer) {
+                    break ignore_path_covered_by_hmr;
                 }
-                return;
-            }
-            ignore_admin: {
-                if (!buildContext.implementedThemeTypes.admin.isImplemented) {
-                    break ignore_admin;
+                ignore_account_spa: {
+                    const doImplementAccountSpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type ===
+                            "Single-Page";
+                    if (!doImplementAccountSpa) {
+                        break ignore_account_spa;
+                    }
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "account"),
+                        filePath
+                    })) {
+                        break ignore_account_spa;
+                    }
+                    return;
                 }
-                if (!(0,isInside/* isInside */.V)({
-                    dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "admin"),
-                    filePath
-                })) {
-                    break ignore_admin;
+                ignore_admin: {
+                    if (!buildContext.implementedThemeTypes.admin.isImplemented) {
+                        break ignore_admin;
+                    }
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "admin"),
+                        filePath
+                    })) {
+                        break ignore_admin;
+                    }
+                    return;
                 }
-                return;
             }
             console.log(`Detected changes in ${filePath}`);
             await waitForDebounce();

package/bin/356.index.js

@@ -25,31 +25,20 @@ exports.modules = {
 async function getUiModuleFileSourceCodeReadyToBeCopied(params) {
     const { buildContext, uiModuleDirPath, fileRelativePath, isForEjection, uiModuleName, uiModuleVersion } = params;
     let sourceCode = (await fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(uiModuleDirPath, _shared_constants__WEBPACK_IMPORTED_MODULE_4__/* .KEYCLOAK_THEME */ .PC, fileRelativePath))).toString("utf8");
-    const toComment = (lines) => {
-        for (const ext of [".ts", ".tsx", ".css", ".less", ".sass", ".js", ".jsx"]) {
-            if (!fileRelativePath.endsWith(ext)) {
-                continue;
-            }
-            return [`/**`, ...lines.map(line => ` * ${line}`), ` */`].join("\n");
-        }
-        if (fileRelativePath.endsWith(".html")) {
-            return [`<!--`, ...lines.map(line => ` ${line}`), `-->`].join("\n");
-        }
-        return undefined;
-    };
-    const comment = toComment(isForEjection
-        ? [`This file was ejected from ${uiModuleName} version ${uiModuleVersion}.`]
-        : [
-            `WARNING: Before modifying this file run the following command:`,
-            ``,
-            `$ npx keycloakify eject-file --file ${fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_2__.sep).join("/")}`,
-            ``,
-            `This file comes from ${uiModuleName} version ${uiModuleVersion}.`,
-            `This file has been copied over to your repo by your postinstall script: \`npx keycloakify postinstall\``
-        ]);
-    if (comment !== undefined) {
-        sourceCode = [comment, ``, sourceCode].join("\n");
-    }
+    sourceCode = addCommentToSourceCode({
+        sourceCode,
+        fileRelativePath,
+        commentLines: isForEjection
+            ? [`This file was ejected from ${uiModuleName} version ${uiModuleVersion}.`]
+            : [
+                `WARNING: Before modifying this file run the following command:`,
+                ``,
+                `$ npx keycloakify eject-file --file '${fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_2__.sep).join("/")}'`,
+                ``,
+                `This file comes from ${uiModuleName} version ${uiModuleVersion}.`,
+                `This file has been copied over to your repo by your postinstall script: \`npx keycloakify postinstall\``
+            ]
+    });
     const destFilePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(buildContext.themeSrcDirPath, fileRelativePath);
     format: {
         if (!(await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__/* .getIsPrettierAvailable */ .MT)())) {
@@ -62,6 +51,40 @@ async function getUiModuleFileSourceCodeReadyToBeCopied(params) {
     }
     return Buffer.from(sourceCode, "utf8");
 }
+function addCommentToSourceCode(params) {
+    const { sourceCode, fileRelativePath, commentLines } = params;
+    const toResult = (comment) => {
+        return [comment, ``, sourceCode].join("\n");
+    };
+    for (const ext of [".ts", ".tsx", ".css", ".less", ".sass", ".js", ".jsx"]) {
+        if (!fileRelativePath.endsWith(ext)) {
+            continue;
+        }
+        return toResult([`/**`, ...commentLines.map(line => ` * ${line}`), ` */`].join("\n"));
+    }
+    if (fileRelativePath.endsWith(".properties")) {
+        return toResult(commentLines.map(line => `# ${line}`).join("\n"));
+    }
+    if (fileRelativePath.endsWith(".html") || fileRelativePath.endsWith(".svg")) {
+        const comment = [
+            `<!--`,
+            ...commentLines.map(line => ` ${line.replace("--file", "-f").replace("Before modifying", "Before modifying or replacing")}`),
+            `-->`
+        ].join("\n");
+        if (fileRelativePath.endsWith(".html") && sourceCode.trim().startsWith("<!")) {
+            const [first, ...rest] = sourceCode.split(">");
+            const last = rest.join(">");
+            return [`${first}>`, comment, last].join("\n");
+        }
+        if (fileRelativePath.endsWith(".svg") && sourceCode.trim().startsWith("<?")) {
+            const [first, ...rest] = sourceCode.split("?>");
+            const last = rest.join("?>");
+            return [`${first}?>`, comment, last].join("\n");
+        }
+        return toResult(comment);
+    }
+    return sourceCode;
+}
 //# sourceMappingURL=getUiModuleFileSourceCodeReadyToBeCopied.js.map
 
 /***/ }),