zephyr-agent/dist/lib/build-context/detect-monorepo.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    detectMonorepo: ()=>detectMonorepo,
    getMonorepoRootPackageJson: ()=>getMonorepoRootPackageJson
});
const external_node_fs_namespaceObject = require("node:fs");
const promises_namespaceObject = require("node:fs/promises");
const external_node_path_namespaceObject = require("node:path");
const debug_js_namespaceObject = require("../logging/debug.js");
const MONOREPO_CONFIG_FILES = [
    {
        file: 'pnpm-workspace.yaml',
        type: 'pnpm'
    },
    {
        file: 'pnpm-workspace.yml',
        type: 'pnpm'
    },
    {
        file: 'lerna.json',
        type: 'lerna'
    },
    {
        file: 'nx.json',
        type: 'nx'
    },
    {
        file: 'rush.json',
        type: 'rush'
    }
];
const MAX_TRAVERSAL_DEPTH = 10;
async function detectMonorepo(startPath) {
    let currentDir = (0, external_node_path_namespaceObject.resolve)(startPath);
    let depth = 0;
    while(depth < MAX_TRAVERSAL_DEPTH){
        for (const config of MONOREPO_CONFIG_FILES){
            const configPath = (0, external_node_path_namespaceObject.join)(currentDir, config.file);
            if (fileExists(configPath)) {
                debug_js_namespaceObject.ze_log.misc(`Found ${config.type} monorepo config at ${configPath}`);
                return {
                    type: config.type,
                    root: currentDir,
                    configFile: configPath
                };
            }
        }
        const packageJsonPath = (0, external_node_path_namespaceObject.join)(currentDir, 'package.json');
        if (fileExists(packageJsonPath)) try {
            const content = await (0, promises_namespaceObject.readFile)(packageJsonPath, 'utf8');
            const packageJson = JSON.parse(content);
            if (packageJson.workspaces) {
                debug_js_namespaceObject.ze_log.misc(`Found ${packageJson.packageManager?.startsWith('yarn') ? 'yarn' : 'npm'} workspaces at ${packageJsonPath}`);
                return {
                    type: packageJson.packageManager?.startsWith('yarn') ? 'yarn' : 'npm',
                    root: currentDir,
                    configFile: packageJsonPath,
                    workspaces: Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || []
                };
            }
            const yarnrcPath = (0, external_node_path_namespaceObject.join)(currentDir, '.yarnrc.yml');
            if (fileExists(yarnrcPath)) {
                debug_js_namespaceObject.ze_log.misc(`Found Yarn Berry workspace at ${currentDir}`);
                return {
                    type: 'yarn',
                    root: currentDir,
                    configFile: yarnrcPath
                };
            }
        } catch (error) {
            debug_js_namespaceObject.ze_log.misc(`Error reading package.json at ${packageJsonPath}:`, error);
        }
        const parentDir = (0, external_node_path_namespaceObject.resolve)(currentDir, '..');
        if (parentDir === currentDir) break;
        currentDir = parentDir;
        depth++;
    }
    debug_js_namespaceObject.ze_log.misc('No monorepo configuration found');
    return {
        type: 'none',
        root: startPath
    };
}
async function getMonorepoRootPackageJson(monorepoRoot) {
    const packageJsonPath = (0, external_node_path_namespaceObject.join)(monorepoRoot, 'package.json');
    if (!fileExists(packageJsonPath)) return null;
    try {
        const content = await (0, promises_namespaceObject.readFile)(packageJsonPath, 'utf8');
        return JSON.parse(content);
    } catch (error) {
        debug_js_namespaceObject.ze_log.misc(`Error reading root package.json at ${packageJsonPath}:`, error);
        return null;
    }
}
function fileExists(path) {
    try {
        (0, external_node_fs_namespaceObject.accessSync)(path, external_node_fs_namespaceObject.constants.F_OK);
        return true;
    } catch  {
        return false;
    }
}
exports.detectMonorepo = __webpack_exports__.detectMonorepo;
exports.getMonorepoRootPackageJson = __webpack_exports__.getMonorepoRootPackageJson;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "detectMonorepo",
    "getMonorepoRootPackageJson"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=detect-monorepo.js.map