keycloakify 11.5.1 → 11.5.2

package/bin/40.index.js

@@ -155,6 +155,91 @@ function maybeDelegateCommandToCustomHandler(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 89693:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/490.index.js

@@ -501,6 +501,91 @@ async function getLatestsSemVersionedTag(_a) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 38367:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/573.index.js

@@ -1533,6 +1533,91 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 27190:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/653.index.js

@@ -250,6 +250,91 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 89693:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/658.index.js

@@ -82,6 +82,91 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 89693:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/682.index.js

@@ -407,12 +407,12 @@ async function getSupportedDockerImageTags(params) {
             return result;
         }
     }
-    const tags = [];
+    const tags_queryResponse = [];
     await (async function callee(url) {
         const r = await lib_default()(url, buildContext.fetchOptions);
         await Promise.all([
             (async () => {
-                tags.push(...lib.z.object({
+                tags_queryResponse.push(...lib.z.object({
                     tags: lib.z.array(lib.z.string())
                 })
                     .parse(await r.json()).tags);
@@ -432,7 +432,8 @@ async function getSupportedDockerImageTags(params) {
             })()
         ]);
     })("https://quay.io/v2/keycloak/keycloak/tags/list");
-    const arr = tags
+    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
+    const allSupportedTags_withVersion = tags_queryResponse
         .map(tag => ({
         tag,
         version: (() => {
@@ -446,21 +447,27 @@ async function getSupportedDockerImageTags(params) {
             catch (_a) {
                 return undefined;
             }
+            if (tag.split(".").length !== 3) {
+                return undefined;
+            }
+            if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                return undefined;
+            }
             return version;
         })()
     }))
         .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
-        .filter((0,exclude/* exclude */.D)(undefined));
-    const versionByMajor = {};
-    for (const { version } of arr) {
-        const version_current = versionByMajor[version.major];
+        .filter((0,exclude/* exclude */.D)(undefined))
+        .sort(({ version: a }, { version: b }) => SemVer/* SemVer.compare */.h.compare(b, a));
+    const latestTagByMajor = {};
+    for (const { version } of allSupportedTags_withVersion) {
+        const version_current = latestTagByMajor[version.major];
         if (version_current === undefined ||
             SemVer/* SemVer.compare */.h.compare(version_current, version) === -1) {
-            versionByMajor[version.major] = version;
+            latestTagByMajor[version.major] = version;
         }
     }
-    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
-    const result = Object.entries(versionByMajor)
+    const latestMajorTags = Object.entries(latestTagByMajor)
         .sort(([a], [b]) => parseInt(b) - parseInt(a))
         .map(([, version]) => version)
         .map(version => {
@@ -471,15 +478,28 @@ async function getSupportedDockerImageTags(params) {
         return SemVer/* SemVer.stringify */.h.stringify(version);
     })
         .filter((0,exclude/* exclude */.D)(undefined));
+    const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
+    const result = {
+        latestMajorTags,
+        allSupportedTags
+    };
     await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
     return result;
 }
 const { getCachedValue, setCachedValue } = (() => {
+    const zResult = (() => {
+        const zTargetType = lib.z.object({
+            allSupportedTags: lib.z.array(lib.z.string()),
+            latestMajorTags: lib.z.array(lib.z.string())
+        });
+        assert/* assert */.h;
+        return (0,id.id)(zTargetType);
+    })();
     const zCache = (() => {
         const zTargetType = lib.z.object({
             keycloakifyVersion: lib.z.string(),
             time: lib.z.number(),
-            result: lib.z.array(lib.z.string())
+            result: zResult
         });
         assert/* assert */.h;
         return (0,id.id)(zTargetType);
@@ -1077,13 +1097,13 @@ async function command(params) {
         process.exit(1);
     }
     const { cliCommandOptions, buildContext } = params;
-    const availableTags = await getSupportedDockerImageTags({
+    const { allSupportedTags, latestMajorTags } = await getSupportedDockerImageTags({
         buildContext
     });
     const { dockerImageTag } = await (async () => {
         if (cliCommandOptions.keycloakVersion !== undefined) {
             const cliCommandOptions_keycloakVersion = cliCommandOptions.keycloakVersion;
-            const tag = availableTags.find(tag => tag.startsWith(cliCommandOptions_keycloakVersion));
+            const tag = allSupportedTags.find(tag => tag.startsWith(cliCommandOptions_keycloakVersion));
             if (tag === undefined) {
                 console.log(source_default().red([
                     `We could not find a Keycloak Docker image for ${cliCommandOptions_keycloakVersion}`,
@@ -1103,7 +1123,7 @@ async function command(params) {
             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: availableTags
+            values: latestMajorTags
         }).catch(() => {
             process.exit(-1);
         });
@@ -1458,6 +1478,91 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 38367:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/735.index.js

@@ -402,6 +402,91 @@ async function getLatestsSemVersionedTag(_a) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 89693:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/main.js

@@ -96,92 +96,6 @@ const TEST_APP_URL = "https://my-theme.keycloakify.dev";
 
 /***/ }),
 
-/***/ 12171:
-/***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
-
-"use strict";
-/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */   "h": () => (/* binding */ SemVer)
-/* harmony export */ });
-var SemVer;
-(function (SemVer) {
-    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
-    function parse(versionStr) {
-        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
-        if (!match) {
-            throw new Error(`${versionStr} is not a valid semantic version`);
-        }
-        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
-                const str = match[3];
-                return str === undefined ? 0 : parseInt(str);
-            })() }, (() => {
-            const str = match[4];
-            return str === undefined ? {} : { rc: parseInt(str) };
-        })());
-        const initialStr = stringify(semVer);
-        Object.defineProperty(semVer, "parsedFrom", {
-            enumerable: true,
-            get: function () {
-                const currentStr = stringify(this);
-                if (currentStr !== initialStr) {
-                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
-                }
-                return versionStr;
-            }
-        });
-        return semVer;
-    }
-    SemVer.parse = parse;
-    function stringify(v) {
-        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
-    }
-    SemVer.stringify = stringify;
-    /**
-     *
-     * v1  <  v2  => -1
-     * v1 === v2  => 0
-     * v1  >  v2  => 1
-     *
-     */
-    function compare(v1, v2) {
-        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
-        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
-        for (const level of ["major", "minor", "patch", "rc"]) {
-            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
-                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
-            }
-        }
-        return 0;
-    }
-    SemVer.compare = compare;
-    /*
-    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
-    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
-    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
-    */
-    function bumpType(params) {
-        const versionAhead = typeof params.versionAhead === "string"
-            ? parse(params.versionAhead)
-            : params.versionAhead;
-        const versionBehind = typeof params.versionBehind === "string"
-            ? parse(params.versionBehind)
-            : params.versionBehind;
-        if (compare(versionBehind, versionAhead) === 1) {
-            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
-        }
-        for (const level of ["major", "minor", "patch", "rc"]) {
-            if (versionBehind[level] !== versionAhead[level]) {
-                return level;
-            }
-        }
-        return "no bump";
-    }
-    SemVer.bumpType = bumpType;
-})(SemVer || (SemVer = {}));
-//# sourceMappingURL=SemVer.js.map
-
-/***/ }),
-
 /***/ 73036:
 /***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
 
@@ -16190,17 +16104,12 @@ function getBuildContext(params) {
     };
 }
 //# sourceMappingURL=buildContext.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
-var SemVer = __nccwpck_require__(12171);
 ;// CONCATENATED MODULE: ./dist/bin/main.js
 
 
 
 
 
-
-
-
 assertNoPnpmDlx();
 const program = Z({
     name: "keycloakify",
@@ -16293,36 +16202,10 @@ program
     skip,
     handler: async ({ projectDirPath, keycloakVersion, port, realmJsonFilePath }) => {
         const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(805), __nccwpck_require__.e(525), __nccwpck_require__.e(33), __nccwpck_require__.e(503), __nccwpck_require__.e(682)]).then(__nccwpck_require__.bind(__nccwpck_require__, 6682));
-        validate_keycloak_version: {
-            if (keycloakVersion === undefined) {
-                break validate_keycloak_version;
-            }
-            const isValidVersion = (() => {
-                if (typeof keycloakVersion === "number") {
-                    return false;
-                }
-                try {
-                    SemVer/* SemVer.parse */.h.parse(keycloakVersion);
-                }
-                catch (_a) {
-                    return false;
-                }
-                return;
-            })();
-            if (isValidVersion) {
-                break validate_keycloak_version;
-            }
-            console.log(source_default().red([
-                `Invalid Keycloak version: ${keycloakVersion}`,
-                "It should be a valid semver version example: 26.0.4"
-            ].join(" ")));
-            process.exit(1);
-        }
-        (0,assert/* assert */.h)((0,assert.is)(keycloakVersion));
         await command({
             buildContext: getBuildContext({ projectDirPath }),
             cliCommandOptions: {
-                keycloakVersion,
+                keycloakVersion: keycloakVersion === undefined ? undefined : `${keycloakVersion}`,
                 port,
                 realmJsonFilePath
             }

package/bin/start-keycloak/getSupportedDockerImageTags.d.ts

@@ -5,4 +5,7 @@ export type BuildContextLike = {
 };
 export declare function getSupportedDockerImageTags(params: {
     buildContext: BuildContextLike;
-}): Promise<string[]>;
+}): Promise<{
+    allSupportedTags: string[];
+    latestMajorTags: string[];
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "keycloakify",
-    "version": "11.5.1",
+    "version": "11.5.2",
     "description": "Framework to create custom Keycloak UIs",
     "repository": {
         "type": "git",

package/src/bin/main.ts

@@ -5,9 +5,6 @@ import { readThisNpmPackageVersion } from "./tools/readThisNpmPackageVersion";
 import * as child_process from "child_process";
 import { assertNoPnpmDlx } from "./tools/assertNoPnpmDlx";
 import { getBuildContext } from "./shared/buildContext";
-import { SemVer } from "./tools/SemVer";
-import { assert, is } from "tsafe/assert";
-import chalk from "chalk";
 
 type CliCommandOptions = {
     projectDirPath: string | undefined;
@@ -137,47 +134,11 @@ program
         handler: async ({ projectDirPath, keycloakVersion, port, realmJsonFilePath }) => {
             const { command } = await import("./start-keycloak");
 
-            validate_keycloak_version: {
-                if (keycloakVersion === undefined) {
-                    break validate_keycloak_version;
-                }
-
-                const isValidVersion = (() => {
-                    if (typeof keycloakVersion === "number") {
-                        return false;
-                    }
-
-                    try {
-                        SemVer.parse(keycloakVersion);
-                    } catch {
-                        return false;
-                    }
-
-                    return;
-                })();
-
-                if (isValidVersion) {
-                    break validate_keycloak_version;
-                }
-
-                console.log(
-                    chalk.red(
-                        [
-                            `Invalid Keycloak version: ${keycloakVersion}`,
-                            "It should be a valid semver version example: 26.0.4"
-                        ].join(" ")
-                    )
-                );
-
-                process.exit(1);
-            }
-
-            assert(is<string | undefined>(keycloakVersion));
-
             await command({
                 buildContext: getBuildContext({ projectDirPath }),
                 cliCommandOptions: {
-                    keycloakVersion,
+                    keycloakVersion:
+                        keycloakVersion === undefined ? undefined : `${keycloakVersion}`,
                     port,
                     realmJsonFilePath
                 }

package/src/bin/start-keycloak/getSupportedDockerImageTags.ts

@@ -10,6 +10,7 @@ import { join as pathJoin, dirname as pathDirname } from "path";
 import * as fs from "fs/promises";
 import { existsAsync } from "../tools/fs.existsAsync";
 import { readThisNpmPackageVersion } from "../tools/readThisNpmPackageVersion";
+import type { ReturnType } from "tsafe";
 
 export type BuildContextLike = {
     fetchOptions: BuildContext["fetchOptions"];
@@ -20,7 +21,10 @@ assert<BuildContext extends BuildContextLike ? true : false>;
 
 export async function getSupportedDockerImageTags(params: {
     buildContext: BuildContextLike;
-}) {
+}): Promise<{
+    allSupportedTags: string[];
+    latestMajorTags: string[];
+}> {
     const { buildContext } = params;
 
     {
@@ -31,14 +35,14 @@ export async function getSupportedDockerImageTags(params: {
         }
     }
 
-    const tags: string[] = [];
+    const tags_queryResponse: string[] = [];
 
     await (async function callee(url: string) {
         const r = await fetch(url, buildContext.fetchOptions);
 
         await Promise.all([
             (async () => {
-                tags.push(
+                tags_queryResponse.push(
                     ...z
                         .object({
                             tags: z.array(z.string())
@@ -70,7 +74,9 @@ export async function getSupportedDockerImageTags(params: {
         ]);
     })("https://quay.io/v2/keycloak/keycloak/tags/list");
 
-    const arr = tags
+    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
+
+    const allSupportedTags_withVersion = tags_queryResponse
         .map(tag => ({
             tag,
             version: (() => {
@@ -86,28 +92,35 @@ export async function getSupportedDockerImageTags(params: {
                     return undefined;
                 }
 
+                if (tag.split(".").length !== 3) {
+                    return undefined;
+                }
+
+                if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                    return undefined;
+                }
+
                 return version;
             })()
         }))
         .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
-        .filter(exclude(undefined));
+        .filter(exclude(undefined))
+        .sort(({ version: a }, { version: b }) => SemVer.compare(b, a));
 
-    const versionByMajor: Record<number, SemVer | undefined> = {};
+    const latestTagByMajor: Record<number, SemVer | undefined> = {};
 
-    for (const { version } of arr) {
-        const version_current = versionByMajor[version.major];
+    for (const { version } of allSupportedTags_withVersion) {
+        const version_current = latestTagByMajor[version.major];
 
         if (
             version_current === undefined ||
             SemVer.compare(version_current, version) === -1
         ) {
-            versionByMajor[version.major] = version;
+            latestTagByMajor[version.major] = version;
         }
     }
 
-    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
-
-    const result = Object.entries(versionByMajor)
+    const latestMajorTags = Object.entries(latestTagByMajor)
         .sort(([a], [b]) => parseInt(b) - parseInt(a))
         .map(([, version]) => version)
         .map(version => {
@@ -121,16 +134,40 @@ export async function getSupportedDockerImageTags(params: {
         })
         .filter(exclude(undefined));
 
+    const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
+
+    const result = {
+        latestMajorTags,
+        allSupportedTags
+    };
+
     await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
 
     return result;
 }
 
 const { getCachedValue, setCachedValue } = (() => {
+    type Result = ReturnType<typeof getSupportedDockerImageTags>;
+
+    const zResult = (() => {
+        type TargetType = Result;
+
+        const zTargetType = z.object({
+            allSupportedTags: z.array(z.string()),
+            latestMajorTags: z.array(z.string())
+        });
+
+        type InferredType = z.infer<typeof zTargetType>;
+
+        assert<Equals<TargetType, InferredType>>;
+
+        return id<z.ZodType<TargetType>>(zTargetType);
+    })();
+
     type Cache = {
         keycloakifyVersion: string;
         time: number;
-        result: string[];
+        result: Result;
     };
 
     const zCache = (() => {
@@ -139,7 +176,7 @@ const { getCachedValue, setCachedValue } = (() => {
         const zTargetType = z.object({
             keycloakifyVersion: z.string(),
             time: z.number(),
-            result: z.array(z.string())
+            result: zResult
         });
 
         type InferredType = z.infer<typeof zTargetType>;

package/src/bin/start-keycloak/start-keycloak.ts

@@ -97,7 +97,7 @@ export async function command(params: {
 
     const { cliCommandOptions, buildContext } = params;
 
-    const availableTags = await getSupportedDockerImageTags({
+    const { allSupportedTags, latestMajorTags } = await getSupportedDockerImageTags({
         buildContext
     });
 
@@ -105,7 +105,7 @@ export async function command(params: {
         if (cliCommandOptions.keycloakVersion !== undefined) {
             const cliCommandOptions_keycloakVersion = cliCommandOptions.keycloakVersion;
 
-            const tag = availableTags.find(tag =>
+            const tag = allSupportedTags.find(tag =>
                 tag.startsWith(cliCommandOptions_keycloakVersion)
             );
 
@@ -143,7 +143,7 @@ export async function command(params: {
         );
 
         const { value: tag } = await cliSelect<string>({
-            values: availableTags
+            values: latestMajorTags
         }).catch(() => {
             process.exit(-1);
         });