keycloakify 10.0.0-rc.8 → 10.0.0-rc.80

package/bin/877.index.js

@@ -0,0 +1,275 @@
+"use strict";
+exports.id = 877;
+exports.ids = [877];
+exports.modules = {
+
+/***/ 85877:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ cliTruncate)
+});
+
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/is-fullwidth-code-point/index.js
+/* eslint-disable yoda */
+
+function isFullwidthCodePoint(codePoint) {
+	if (!Number.isInteger(codePoint)) {
+		return false;
+	}
+
+	// Code points are derived from:
+	// https://unicode.org/Public/UNIDATA/EastAsianWidth.txt
+	return codePoint >= 0x1100 && (
+		codePoint <= 0x115F || // Hangul Jamo
+		codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+		codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
+		// CJK Radicals Supplement .. Enclosed CJK Letters and Months
+		(0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
+		// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+		(0x3250 <= codePoint && codePoint <= 0x4DBF) ||
+		// CJK Unified Ideographs .. Yi Radicals
+		(0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
+		// Hangul Jamo Extended-A
+		(0xA960 <= codePoint && codePoint <= 0xA97C) ||
+		// Hangul Syllables
+		(0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+		// CJK Compatibility Ideographs
+		(0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+		// Vertical Forms
+		(0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+		// CJK Compatibility Forms .. Small Form Variants
+		(0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
+		// Halfwidth and Fullwidth Forms
+		(0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+		(0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
+		// Kana Supplement
+		(0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+		// Enclosed Ideographic Supplement
+		(0x1F200 <= codePoint && codePoint <= 0x1F251) ||
+		// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+		(0x20000 <= codePoint && codePoint <= 0x3FFFD)
+	);
+}
+
+// EXTERNAL MODULE: ./node_modules/listr2/node_modules/ansi-styles/index.js
+var ansi_styles = __webpack_require__(51284);
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/slice-ansi/index.js
+
+
+
+const astralRegex = /^[\uD800-\uDBFF][\uDC00-\uDFFF]$/;
+
+const ESCAPES = [
+	'\u001B',
+	'\u009B'
+];
+
+const wrapAnsi = code => `${ESCAPES[0]}[${code}m`;
+
+const checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
+	let output = [];
+	ansiCodes = [...ansiCodes];
+
+	for (let ansiCode of ansiCodes) {
+		const ansiCodeOrigin = ansiCode;
+		if (ansiCode.includes(';')) {
+			ansiCode = ansiCode.split(';')[0][0] + '0';
+		}
+
+		const item = ansi_styles/* default.codes.get */.ZP.codes.get(Number.parseInt(ansiCode, 10));
+		if (item) {
+			const indexEscape = ansiCodes.indexOf(item.toString());
+			if (indexEscape === -1) {
+				output.push(wrapAnsi(isEscapes ? item : ansiCodeOrigin));
+			} else {
+				ansiCodes.splice(indexEscape, 1);
+			}
+		} else if (isEscapes) {
+			output.push(wrapAnsi(0));
+			break;
+		} else {
+			output.push(wrapAnsi(ansiCodeOrigin));
+		}
+	}
+
+	if (isEscapes) {
+		output = output.filter((element, index) => output.indexOf(element) === index);
+
+		if (endAnsiCode !== undefined) {
+			const fistEscapeCode = wrapAnsi(ansi_styles/* default.codes.get */.ZP.codes.get(Number.parseInt(endAnsiCode, 10)));
+			// TODO: Remove the use of `.reduce` here.
+			// eslint-disable-next-line unicorn/no-array-reduce
+			output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
+		}
+	}
+
+	return output.join('');
+};
+
+function sliceAnsi(string, begin, end) {
+	const characters = [...string];
+	const ansiCodes = [];
+
+	let stringEnd = typeof end === 'number' ? end : characters.length;
+	let isInsideEscape = false;
+	let ansiCode;
+	let visible = 0;
+	let output = '';
+
+	for (const [index, character] of characters.entries()) {
+		let leftEscape = false;
+
+		if (ESCAPES.includes(character)) {
+			const code = /\d[^m]*/.exec(string.slice(index, index + 18));
+			ansiCode = code && code.length > 0 ? code[0] : undefined;
+
+			if (visible < stringEnd) {
+				isInsideEscape = true;
+
+				if (ansiCode !== undefined) {
+					ansiCodes.push(ansiCode);
+				}
+			}
+		} else if (isInsideEscape && character === 'm') {
+			isInsideEscape = false;
+			leftEscape = true;
+		}
+
+		if (!isInsideEscape && !leftEscape) {
+			visible++;
+		}
+
+		if (!astralRegex.test(character) && isFullwidthCodePoint(character.codePointAt())) {
+			visible++;
+
+			if (typeof end !== 'number') {
+				stringEnd++;
+			}
+		}
+
+		if (visible > begin && visible <= stringEnd) {
+			output += character;
+		} else if (visible === begin && !isInsideEscape && ansiCode !== undefined) {
+			output = checkAnsi(ansiCodes);
+		} else if (visible >= stringEnd) {
+			output += checkAnsi(ansiCodes, true, ansiCode);
+			break;
+		}
+	}
+
+	return output;
+}
+
+// EXTERNAL MODULE: ./node_modules/listr2/node_modules/string-width/index.js
+var string_width = __webpack_require__(10509);
+;// CONCATENATED MODULE: ./node_modules/listr2/node_modules/cli-truncate/index.js
+
+
+
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+	if (string.charAt(wantedIndex) === ' ') {
+		return wantedIndex;
+	}
+
+	const direction = shouldSearchRight ? 1 : -1;
+
+	for (let index = 0; index <= 3; index++) {
+		const finalIndex = wantedIndex + (index * direction);
+		if (string.charAt(finalIndex) === ' ') {
+			return finalIndex;
+		}
+	}
+
+	return wantedIndex;
+}
+
+function cliTruncate(text, columns, options = {}) {
+	const {
+		position = 'end',
+		space = false,
+		preferTruncationOnSpace = false,
+	} = options;
+
+	let {truncationCharacter = '…'} = options;
+
+	if (typeof text !== 'string') {
+		throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+	}
+
+	if (typeof columns !== 'number') {
+		throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+	}
+
+	if (columns < 1) {
+		return '';
+	}
+
+	if (columns === 1) {
+		return truncationCharacter;
+	}
+
+	const length = (0,string_width/* default */.Z)(text);
+
+	if (length <= columns) {
+		return text;
+	}
+
+	if (position === 'start') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+			return truncationCharacter + sliceAnsi(text, nearestSpace, length).trim();
+		}
+
+		if (space === true) {
+			truncationCharacter += ' ';
+		}
+
+		return truncationCharacter + sliceAnsi(text, length - columns + (0,string_width/* default */.Z)(truncationCharacter), length);
+	}
+
+	if (position === 'middle') {
+		if (space === true) {
+			truncationCharacter = ` ${truncationCharacter} `;
+		}
+
+		const half = Math.floor(columns / 2);
+
+		if (preferTruncationOnSpace) {
+			const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+			const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+			return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+		}
+
+		return (
+			sliceAnsi(text, 0, half)
+				+ truncationCharacter
+				+ sliceAnsi(text, length - (columns - half) + (0,string_width/* default */.Z)(truncationCharacter), length)
+		);
+	}
+
+	if (position === 'end') {
+		if (preferTruncationOnSpace) {
+			const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+			return sliceAnsi(text, 0, nearestSpace) + truncationCharacter;
+		}
+
+		if (space === true) {
+			truncationCharacter = ` ${truncationCharacter}`;
+		}
+
+		return sliceAnsi(text, 0, columns - (0,string_width/* default */.Z)(truncationCharacter)) + truncationCharacter;
+	}
+
+	throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+}
+
+
+/***/ })
+
+};
+;

package/bin/932.index.js

@@ -0,0 +1,269 @@
+"use strict";
+exports.id = 932;
+exports.ids = [932];
+exports.modules = {
+
+/***/ 16932:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "command": () => (/* binding */ command)
+/* harmony export */ });
+/* harmony import */ var _shared_downloadKeycloakDefaultTheme__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(47802);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _tools_transformCodebase__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(60332);
+/* harmony import */ var _shared_promptKeycloakVersion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(95781);
+/* harmony import */ var _shared_buildContext__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(87751);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_5__);
+
+
+
+
+
+
+async function command(params) {
+    const { cliCommandOptions } = params;
+    const buildContext = (0,_shared_buildContext__WEBPACK_IMPORTED_MODULE_4__/* .getBuildContext */ .s)({ cliCommandOptions });
+    const emailThemeSrcDirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(buildContext.themeSrcDirPath, "email");
+    if (fs__WEBPACK_IMPORTED_MODULE_5__.existsSync(emailThemeSrcDirPath)) {
+        console.warn(`There is already a ${(0,path__WEBPACK_IMPORTED_MODULE_1__.relative)(process.cwd(), emailThemeSrcDirPath)} directory in your project. Aborting.`);
+        process.exit(-1);
+    }
+    console.log("Initialize with the base email theme from which version of Keycloak?");
+    const { keycloakVersion } = await (0,_shared_promptKeycloakVersion__WEBPACK_IMPORTED_MODULE_3__/* .promptKeycloakVersion */ .s)({
+        // NOTE: This is arbitrary
+        startingFromMajor: 17,
+        excludeMajorVersions: [],
+        cacheDirPath: buildContext.cacheDirPath
+    });
+    const { defaultThemeDirPath } = await (0,_shared_downloadKeycloakDefaultTheme__WEBPACK_IMPORTED_MODULE_0__/* .downloadKeycloakDefaultTheme */ .x)({
+        keycloakVersion,
+        buildContext
+    });
+    (0,_tools_transformCodebase__WEBPACK_IMPORTED_MODULE_2__/* .transformCodebase */ .N)({
+        srcDirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(defaultThemeDirPath, "base", "email"),
+        destDirPath: emailThemeSrcDirPath
+    });
+    {
+        const themePropertyFilePath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(emailThemeSrcDirPath, "theme.properties");
+        fs__WEBPACK_IMPORTED_MODULE_5__.writeFileSync(themePropertyFilePath, Buffer.from(`parent=base\n${fs__WEBPACK_IMPORTED_MODULE_5__.readFileSync(themePropertyFilePath).toString("utf8")}`, "utf8"));
+    }
+    console.log(`The \`${(0,path__WEBPACK_IMPORTED_MODULE_1__.join)(".", (0,path__WEBPACK_IMPORTED_MODULE_1__.relative)(process.cwd(), emailThemeSrcDirPath))}\` directory have been created.`);
+    console.log("You can delete any file you don't modify.");
+}
+//# sourceMappingURL=initialize-email-theme.js.map
+
+/***/ }),
+
+/***/ 95781:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "s": () => (/* binding */ promptKeycloakVersion)
+});
+
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const per_page = 99;
+function listTagsFactory(params) {
+    const { octokit } = params;
+    const octokit_repo_listTags = async (params) => {
+        return octokit.repos.listTags(params);
+    };
+    function listTags(params) {
+        return __asyncGenerator(this, arguments, function* listTags_1() {
+            const { owner, repo } = params;
+            let page = 1;
+            while (true) {
+                const resp = yield __await(octokit_repo_listTags({
+                    owner,
+                    repo,
+                    per_page,
+                    page: page++
+                }));
+                for (const branch of resp.data.map(({ name }) => name)) {
+                    yield yield __await(branch);
+                }
+                if (resp.data.length < 99) {
+                    break;
+                }
+            }
+        });
+    }
+    /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
+    async function getLatestTag(params) {
+        const { owner, repo } = params;
+        const itRes = await listTags({ owner, repo }).next();
+        if (itRes.done) {
+            return undefined;
+        }
+        return itRes.value;
+    }
+    return { listTags, getLatestTag };
+}
+//# sourceMappingURL=listTags.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/getLatestsSemVersionedTag.js
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+function getLatestsSemVersionedTagFactory(params) {
+    const { octokit } = params;
+    async function getLatestsSemVersionedTag(params) {
+        var _a, e_1, _b, _c;
+        const { owner, repo, count } = params;
+        const semVersionedTags = [];
+        const { listTags } = listTagsFactory({ octokit });
+        try {
+            for (var _d = true, _e = __asyncValues(listTags({ owner, repo })), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const tag = _c;
+                    let version;
+                    try {
+                        version = SemVer/* SemVer.parse */.h.parse(tag.replace(/^[vV]?/, ""));
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                    if (version.rc !== undefined) {
+                        continue;
+                    }
+                    semVersionedTags.push({ tag, version });
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer/* SemVer.compare */.h.compare(vY, vX))
+            .slice(0, count);
+    }
+    return { getLatestsSemVersionedTag };
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+// EXTERNAL MODULE: ./node_modules/@octokit/rest/dist-node/index.js
+var dist_node = __webpack_require__(55375);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(99398);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+;// CONCATENATED MODULE: ./dist/bin/shared/promptKeycloakVersion.js
+
+
+
+
+
+
+
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
+    const { getLatestsSemVersionedTag } = (() => {
+        const { octokit } = (() => {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const octokit = new dist_node.Octokit(githubToken === undefined ? undefined : { auth: githubToken });
+            return { octokit };
+        })();
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
+        return { getLatestsSemVersionedTag };
+    })();
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (async () => {
+        const cacheFilePath = (0,external_path_.join)(cacheDirPath, "keycloak-versions.json");
+        use_cache: {
+            if (!external_fs_.existsSync(cacheFilePath)) {
+                break use_cache;
+            }
+            const cache = JSON.parse(external_fs_.readFileSync(cacheFilePath).toString("utf8"));
+            if (Date.now() - cache.time > 3600000) {
+                external_fs_.unlinkSync(cacheFilePath);
+                break use_cache;
+            }
+            return cache.semVersionedTags;
+        }
+        const semVersionedTags = await getLatestsSemVersionedTag({
+            count: 50,
+            owner: "keycloak",
+            repo: "keycloak"
+        });
+        {
+            const dirPath = (0,external_path_.dirname)(cacheFilePath);
+            if (!external_fs_.existsSync(dirPath)) {
+                external_fs_.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        external_fs_.writeFileSync(cacheFilePath, JSON.stringify((0,id.id)({
+            time: Date.now(),
+            semVersionedTags
+        }), null, 2));
+        return semVersionedTags;
+    })();
+    semVersionedTags.forEach(semVersionedTag => {
+        if (startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor) {
+            return;
+        }
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            return;
+        }
+        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (currentSemVersionedTag !== undefined &&
+            SemVer/* SemVer.compare */.h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            return;
+        }
+        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
+    });
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
+    const { value } = await dist_default()({
+        values: lastMajorVersions
+    }).catch(() => {
+        process.exit(-1);
+    });
+    const keycloakVersion = value.split(" ")[0];
+    return { keycloakVersion };
+}
+//# sourceMappingURL=promptKeycloakVersion.js.map
+
+/***/ })
+
+};
+;