keycloakify 11.6.1 → 11.7.0

package/bin/{653.index.js → 288.index.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 653;
-exports.ids = [653];
+exports.id = 288;
+exports.ids = [288];
 exports.modules = {
 
-/***/ 2653:
+/***/ 27288:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -11,30 +11,71 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "command": () => (/* reexport */ command)
+  "initializeSpa": () => (/* reexport */ initializeSpa)
 });
 
-// EXTERNAL MODULE: ./dist/bin/postinstall/uiModuleMeta.js + 3 modules
-var postinstall_uiModuleMeta = __webpack_require__(58644);
+// 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/esm/assert.mjs + 1 modules
 var assert = __webpack_require__(29041);
-// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
-var lib = __webpack_require__(52300);
 // EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
 var id = __webpack_require__(38469);
-// EXTERNAL MODULE: external "fs/promises"
-var promises_ = __webpack_require__(73292);
-// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
-var SemVer = __webpack_require__(12171);
-// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
-var same = __webpack_require__(33805);
+;// CONCATENATED MODULE: ./dist/bin/shared/initializeSpa/addSyncExtensionsToPostinstallScript.js
+
+
+(0,assert/* assert */.h)();
+function addSyncExtensionsToPostinstallScript(params) {
+    var _a;
+    const { parsedPackageJson, buildContext } = params;
+    const cmd_base = "keycloakify sync-extensions";
+    const projectCliOptionValue = (() => {
+        const packageJsonDirPath = (0,external_path_.dirname)(buildContext.packageJsonFilePath);
+        const relativePath = (0,external_path_.relative)(packageJsonDirPath, buildContext.projectDirPath);
+        if (relativePath === "") {
+            return undefined;
+        }
+        return relativePath.split(external_path_.sep).join("/");
+    })();
+    const generateCmd = (params) => {
+        const { cmd_preexisting } = params;
+        let cmd = cmd_preexisting === undefined ? "" : `${cmd_preexisting} && `;
+        cmd += cmd_base;
+        if (projectCliOptionValue !== undefined) {
+            cmd += ` -p ${projectCliOptionValue}`;
+        }
+        return cmd;
+    };
+    {
+        const scripts = ((_a = parsedPackageJson.scripts) !== null && _a !== void 0 ? _a : (parsedPackageJson.scripts = {}));
+        for (const scriptName of ["postinstall", "prepare"]) {
+            const cmd_preexisting = scripts[scriptName];
+            if (cmd_preexisting === undefined) {
+                continue;
+            }
+            if (!cmd_preexisting.includes(cmd_base)) {
+                scripts[scriptName] = generateCmd({ cmd_preexisting });
+                return;
+            }
+        }
+    }
+    parsedPackageJson.scripts = Object.assign({ postinstall: generateCmd({ cmd_preexisting: undefined }) }, parsedPackageJson.scripts);
+}
+//# sourceMappingURL=addSyncExtensionsToPostinstallScript.js.map
 // EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
 var runPrettier = __webpack_require__(48433);
 // EXTERNAL MODULE: ./dist/bin/tools/npmInstall.js
 var npmInstall = __webpack_require__(50030);
-// EXTERNAL MODULE: external "path"
-var external_path_ = __webpack_require__(71017);
-;// CONCATENATED MODULE: ./dist/bin/postinstall/installUiModulesPeerDependencies.js
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+;// CONCATENATED MODULE: ./dist/bin/shared/initializeSpa/initializeSpa.js
+
 
 
 
@@ -45,206 +86,76 @@ var external_path_ = __webpack_require__(71017);
 
 
 (0,assert/* assert */.h)();
-(0,assert/* assert */.h)();
-async function installUiModulesPeerDependencies(params) {
-    var _a, _b;
-    const { buildContext, uiModuleMetas } = params;
-    const { uiModulesPerDependencies } = (() => {
-        const uiModulesPerDependencies = {};
-        for (const { peerDependencies } of uiModuleMetas) {
-            for (const [peerDependencyName, versionRange_candidate] of Object.entries(peerDependencies)) {
-                const versionRange = (() => {
-                    const versionRange_current = uiModulesPerDependencies[peerDependencyName];
-                    if (versionRange_current === undefined) {
-                        return versionRange_candidate;
-                    }
-                    if (versionRange_current === "*") {
-                        return versionRange_candidate;
-                    }
-                    if (versionRange_candidate === "*") {
-                        return versionRange_current;
-                    }
-                    const { versionRange } = [
-                        versionRange_current,
-                        versionRange_candidate
-                    ]
-                        .map(versionRange => ({
-                        versionRange,
-                        semVer: SemVer/* SemVer.parse */.h.parse((() => {
-                            if (versionRange.startsWith("^") ||
-                                versionRange.startsWith("~")) {
-                                return versionRange.slice(1);
-                            }
-                            return versionRange;
-                        })())
-                    }))
-                        .sort((a, b) => SemVer/* SemVer.compare */.h.compare(b.semVer, a.semVer))[0];
-                    return versionRange;
-                })();
-                uiModulesPerDependencies[peerDependencyName] = versionRange;
-            }
+async function initializeSpa(params) {
+    var _a;
+    const { themeType, buildContext } = params;
+    {
+        const themeTypeSrcDirPath = (0,external_path_.join)(buildContext.themeSrcDirPath, themeType);
+        if (external_fs_.existsSync(themeTypeSrcDirPath) &&
+            external_fs_.readdirSync(themeTypeSrcDirPath).length > 0) {
+            console.warn(source_default().red(`There is already a ${(0,external_path_.relative)(process.cwd(), themeTypeSrcDirPath)} directory in your project. Aborting.`));
+            process.exit(-1);
         }
-        return { uiModulesPerDependencies };
-    })();
-    const parsedPackageJson = await (async () => {
+    }
+    const parsedPackageJson = (() => {
         const zParsedPackageJson = (() => {
-            const zParsedPackageJson = lib.z.object({
-                dependencies: lib.z.record(lib.z.string()).optional(),
-                devDependencies: lib.z.record(lib.z.string()).optional()
+            const zTargetType = lib.z.object({
+                scripts: lib.z.record(lib.z.union([lib.z.string(), lib.z.undefined()])).optional(),
+                dependencies: lib.z.record(lib.z.union([lib.z.string(), lib.z.undefined()])).optional(),
+                devDependencies: lib.z.record(lib.z.union([lib.z.string(), lib.z.undefined()])).optional()
             });
-            (0,assert/* assert */.h)();
-            return (0,id.id)(zParsedPackageJson);
+            assert/* assert */.h;
+            return (0,id.id)(zTargetType);
         })();
-        const parsedPackageJson = JSON.parse((await promises_.readFile(buildContext.packageJsonFilePath)).toString("utf8"));
+        const parsedPackageJson = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString("utf8"));
         zParsedPackageJson.parse(parsedPackageJson);
         (0,assert/* assert */.h)((0,assert.is)(parsedPackageJson));
         return parsedPackageJson;
     })();
-    const parsedPackageJson_before = JSON.parse(JSON.stringify(parsedPackageJson));
-    for (const [moduleName, versionRange] of Object.entries(uiModulesPerDependencies)) {
-        if (moduleName.startsWith("@types/")) {
-            ((_a = parsedPackageJson.devDependencies) !== null && _a !== void 0 ? _a : (parsedPackageJson.devDependencies = {}))[moduleName] = versionRange;
-            continue;
+    addSyncExtensionsToPostinstallScript({
+        parsedPackageJson,
+        buildContext
+    });
+    const uiSharedMajor = (() => {
+        const dependencies = Object.assign(Object.assign({}, parsedPackageJson.devDependencies), parsedPackageJson.dependencies);
+        const version = dependencies["@keycloakify/keycloak-ui-shared"];
+        if (version === undefined) {
+            return undefined;
         }
-        if (parsedPackageJson.devDependencies !== undefined) {
-            delete parsedPackageJson.devDependencies[moduleName];
+        const match = version.match(/^[^~]?(\d+)\./);
+        if (match === null) {
+            return undefined;
         }
-        ((_b = parsedPackageJson.dependencies) !== null && _b !== void 0 ? _b : (parsedPackageJson.dependencies = {}))[moduleName] = versionRange;
-    }
-    if ((0,same.same)(parsedPackageJson, parsedPackageJson_before)) {
-        return;
+        return match[1];
+    })();
+    const moduleName = `@keycloakify/keycloak-${themeType}-ui`;
+    const version = JSON.parse(external_child_process_.execSync(`npm show ${moduleName} versions --json`)
+        .toString("utf8")
+        .trim())
+        .reverse()
+        .filter(version => !version.includes("-"))
+        .find(version => uiSharedMajor === undefined ? true : version.startsWith(`${uiSharedMajor}.`));
+    (0,assert/* assert */.h)(version !== undefined);
+    ((_a = parsedPackageJson.dependencies) !== null && _a !== void 0 ? _a : (parsedPackageJson.dependencies = {}))[moduleName] = `~${version}`;
+    if (parsedPackageJson.devDependencies !== undefined) {
+        delete parsedPackageJson.devDependencies[moduleName];
     }
-    let packageJsonContentStr = JSON.stringify(parsedPackageJson, null, 2);
-    format: {
-        if (!(await (0,runPrettier/* getIsPrettierAvailable */.MT)())) {
-            break format;
+    {
+        let sourceCode = JSON.stringify(parsedPackageJson, undefined, 2);
+        if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
+            sourceCode = await (0,runPrettier/* runPrettier */.eY)({
+                sourceCode,
+                filePath: buildContext.packageJsonFilePath
+            });
         }
-        packageJsonContentStr = await (0,runPrettier/* runPrettier */.eY)({
-            sourceCode: packageJsonContentStr,
-            filePath: buildContext.packageJsonFilePath
-        });
+        external_fs_.writeFileSync(buildContext.packageJsonFilePath, Buffer.from(sourceCode, "utf8"));
     }
-    await promises_.writeFile(buildContext.packageJsonFilePath, packageJsonContentStr);
     await (0,npmInstall/* npmInstall */.c)({
         packageJsonDirPath: (0,external_path_.dirname)(buildContext.packageJsonFilePath)
     });
-    process.exit(0);
 }
-//# sourceMappingURL=installUiModulesPeerDependencies.js.map
-// EXTERNAL MODULE: ./dist/bin/postinstall/managedGitignoreFile.js
-var managedGitignoreFile = __webpack_require__(36843);
-// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
-var fs_existsAsync = __webpack_require__(43765);
-// EXTERNAL MODULE: external "child_process"
-var external_child_process_ = __webpack_require__(32081);
-// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
-var Deferred = __webpack_require__(50689);
-;// CONCATENATED MODULE: ./dist/bin/tools/isTrackedByGit.js
-
-
-
-function getIsTrackedByGit(params) {
-    const { filePath } = params;
-    const dIsTracked = new Deferred.Deferred();
-    external_child_process_.exec(`git ls-files --error-unmatch ${(0,external_path_.basename)(filePath)}`, { cwd: (0,external_path_.dirname)(filePath) }, error => {
-        if (error === null) {
-            dIsTracked.resolve(true);
-            return;
-        }
-        if (error.code === 1) {
-            dIsTracked.resolve(false);
-            return;
-        }
-        dIsTracked.reject(error);
-    });
-    return dIsTracked.pr;
-}
-//# sourceMappingURL=isTrackedByGit.js.map
-;// CONCATENATED MODULE: ./dist/bin/tools/untrackFromGit.js
-
-
-
-async function untrackFromGit(params) {
-    const { filePath } = params;
-    const dDone = new Deferred.Deferred();
-    external_child_process_.exec(`git rm --cached ${(0,external_path_.basename)(filePath)}`, { cwd: (0,external_path_.dirname)(filePath) }, error => {
-        if (error !== null) {
-            dDone.reject(error);
-            return;
-        }
-        dDone.resolve();
-    });
-    await dDone.pr;
-}
-//# sourceMappingURL=untrackFromGit.js.map
-;// CONCATENATED MODULE: ./dist/bin/postinstall/postinstall.js
-
-
-
-
-
-
-
-
-
-async function command(params) {
-    const { buildContext } = params;
-    const uiModuleMetas = await (0,postinstall_uiModuleMeta/* getUiModuleMetas */.j)({ buildContext });
-    await installUiModulesPeerDependencies({
-        buildContext,
-        uiModuleMetas
-    });
-    const { ejectedFilesRelativePaths } = await (0,managedGitignoreFile/* readManagedGitignoreFile */.w)({
-        buildContext
-    });
-    await (0,managedGitignoreFile/* writeManagedGitignoreFile */.Y)({
-        buildContext,
-        ejectedFilesRelativePaths,
-        uiModuleMetas
-    });
-    await Promise.all(uiModuleMetas
-        .map(uiModuleMeta => Promise.all(uiModuleMeta.files.map(async ({ fileRelativePath, copyableFilePath, hash }) => {
-        if (ejectedFilesRelativePaths.includes(fileRelativePath)) {
-            return;
-        }
-        const destFilePath = (0,external_path_.join)(buildContext.themeSrcDirPath, fileRelativePath);
-        const doesFileExist = await (0,fs_existsAsync/* existsAsync */.o)(destFilePath);
-        skip_condition: {
-            if (!doesFileExist) {
-                break skip_condition;
-            }
-            const destFileHash = (0,postinstall_uiModuleMeta/* computeHash */.x)(await promises_.readFile(destFilePath));
-            if (destFileHash !== hash) {
-                break skip_condition;
-            }
-            return;
-        }
-        git_untrack: {
-            if (!doesFileExist) {
-                break git_untrack;
-            }
-            const isTracked = await getIsTrackedByGit({
-                filePath: destFilePath
-            });
-            if (!isTracked) {
-                break git_untrack;
-            }
-            await untrackFromGit({
-                filePath: destFilePath
-            });
-        }
-        {
-            const dirName = (0,external_path_.dirname)(destFilePath);
-            if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirName))) {
-                await promises_.mkdir(dirName, { recursive: true });
-            }
-        }
-        await promises_.copyFile(copyableFilePath, destFilePath);
-    })))
-        .flat());
-}
-//# sourceMappingURL=postinstall.js.map
-;// CONCATENATED MODULE: ./dist/bin/postinstall/index.js
+//# sourceMappingURL=initializeSpa.js.map
+;// CONCATENATED MODULE: ./dist/bin/shared/initializeSpa/index.js
 
 //# sourceMappingURL=index.js.map
 
@@ -482,7 +393,7 @@ async function runPackageManagerInstall(params) {
     });
     child.stdout.on("data", data => process.stdout.write(data));
     child.stderr.on("data", data => {
-        if (data.toString("utf8").includes("has unmet peer dependency")) {
+        if (data.toString("utf8").includes("peer dependency")) {
             return;
         }
         process.stderr.write(data);
@@ -732,6 +643,115 @@ async function installWithoutBreakingLinks(params) {
 
 /***/ }),
 
+/***/ 50689:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.VoidDeferred = exports.Deferred = void 0;
+var overwriteReadonlyProp_1 = __webpack_require__(47803);
+var Deferred = /** @class */ (function () {
+    function Deferred() {
+        var _this_1 = this;
+        this.isPending = true;
+        var resolve;
+        var reject;
+        this.pr = new Promise(function (resolve_, reject_) {
+            resolve = function (value) {
+                (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this_1, "isPending", false);
+                resolve_(value);
+            };
+            reject = function (error) {
+                (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this_1, "isPending", false);
+                reject_(error);
+            };
+        });
+        this.resolve = resolve;
+        this.reject = reject;
+    }
+    return Deferred;
+}());
+exports.Deferred = Deferred;
+var VoidDeferred = /** @class */ (function (_super) {
+    __extends(VoidDeferred, _super);
+    function VoidDeferred() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return VoidDeferred;
+}(Deferred));
+exports.VoidDeferred = VoidDeferred;
+//# sourceMappingURL=Deferred.js.map
+
+/***/ }),
+
+/***/ 47803:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.overwriteReadonlyProp = void 0;
+/**
+ * Assign a value to a property even if the object is freezed or if the property is not writable
+ * Throw if the assignation fail ( for example if the property is non configurable write: false )
+ * */
+var overwriteReadonlyProp = function (obj, propertyName, value) {
+    try {
+        obj[propertyName] = value;
+    }
+    catch (_a) { }
+    if (obj[propertyName] === value) {
+        return value;
+    }
+    var errorDefineProperty = undefined;
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(obj, propertyName) || {
+        "enumerable": true,
+        "configurable": true,
+    };
+    if (!!propertyDescriptor.get) {
+        throw new Error("Probably a wrong ides to overwrite ".concat(String(propertyName), " getter"));
+    }
+    try {
+        Object.defineProperty(obj, propertyName, __assign(__assign({}, propertyDescriptor), { value: value }));
+    }
+    catch (error) {
+        errorDefineProperty = error;
+    }
+    if (obj[propertyName] !== value) {
+        throw errorDefineProperty || new Error("Can't assign");
+    }
+    return value;
+};
+exports.overwriteReadonlyProp = overwriteReadonlyProp;
+//# sourceMappingURL=overwriteReadonlyProp.js.map
+
+/***/ }),
+
 /***/ 23483:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {