mono-runner
Version:
A script runner for mono repos that just works. Use Mono to run separate compilers and dev servers for your packages at once, build only dependent packages or format everything at once.
396 lines (361 loc) • 14.1 kB
JavaScript
import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
/******/ // The require scope
/******/ var __nccwpck_require__ = {};
/******/
/************************************************************************/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __nccwpck_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__nccwpck_require__.o(definition, key) && !__nccwpck_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/compat */
/******/
/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = new URL('.', import.meta.url).pathname.slice(import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/";
/******/
/************************************************************************/
var __webpack_exports__ = {};
// EXPORTS
__nccwpck_require__.d(__webpack_exports__, {
fS: () => (/* reexport */ ViteMonoPlugin),
LX: () => (/* reexport */ createSassImporter),
Ay: () => (/* binding */ lib),
lo: () => (/* reexport */ defaultResolvers),
Q3: () => (/* reexport */ svelteKitResolver),
Fz: () => (/* reexport */ svelteMonoAlias),
yy: () => (/* reexport */ sveltePackageResolver),
ol: () => (/* reexport */ typescriptResolver),
fp: () => (/* reexport */ viteResolver)
});
;// CONCATENATED MODULE: ./lib/resolvers/svelte.ts
const klarPackageResolver = ({ dependencies }) => {
if (dependencies.includes("@klar/package")) {
return {
outPath: "dist",
srcPath: "src/lib",
readyIPC: true
};
}
else {
return null;
}
};
const sveltePackageResolver = ({ dependencies }) => {
if (dependencies.includes("@sveltejs/package")) {
return {
outPath: "dist",
srcPath: "src/lib"
};
}
else {
return null;
}
};
const svelteKitResolver = ({ dependencies }) => {
if (dependencies.includes("@sveltejs/kit")) {
return {
outPath: ".svelte-kit/generated",
srcPath: "src/lib"
};
}
else {
return null;
}
};
;// CONCATENATED MODULE: external "path"
const external_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("path");
;// CONCATENATED MODULE: external "node:fs/promises"
const promises_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs/promises");
;// CONCATENATED MODULE: external "node:fs"
const external_node_fs_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs");
;// CONCATENATED MODULE: ./lib/utils/packages.ts
const rootPath = process.env.MONO_ROOT || process.cwd();
const readFileJSON = async (path) => {
const data = await readFile(path, { encoding: "utf-8" });
return JSON.parse(data);
};
const readFileJSONSync = (path) => {
const data = (0,external_node_fs_namespaceObject.readFileSync)(path, { encoding: "utf-8" });
return JSON.parse(data);
};
const getWorkspaces = async () => {
try {
const pJson = await readFileJSON(join(rootPath, "package.json"));
const base = pJson.workspaces || [];
const workspaces = base.map((w) => w.replace("/*", ""));
const existing = [];
await Promise.all(workspaces.map(async (w) => {
const path = join(rootPath, w);
if (await access(path).then(() => true).catch(() => false)) {
existing.push(w);
}
}));
return existing;
}
catch (e) {
console.error("Please run this command in a directory with a valid package.json file.");
return [];
}
};
const getWorkspacesSync = () => {
try {
const pJson = readFileJSONSync((0,external_path_namespaceObject.join)(rootPath, "package.json"));
const base = pJson.workspaces || [];
const workspaces = base.map((w) => w.replace("/*", ""));
const existing = [];
workspaces.forEach((w) => {
const path = (0,external_path_namespaceObject.join)(rootPath, w);
if ((0,external_node_fs_namespaceObject.existsSync)(path)) {
existing.push(w);
}
});
return existing;
}
catch (e) {
console.error("Please run this command in a directory with a valid package.json file.");
return [];
}
};
const getPackageJson = async (path) => {
const pJson = await readFileJSON(join(path, "package.json"));
return pJson;
};
const getPackageJsonSync = (path) => {
const pJson = readFileJSONSync((0,external_path_namespaceObject.join)(path, "package.json"));
return pJson;
};
const listPackages = async (workspace) => {
const root = join(rootPath, workspace);
const dirs = await readdir(root, { withFileTypes: true });
const packages = dirs.filter((d) => d.isDirectory()).map((d) => d.name);
const packageJsons = (await Promise.all(packages.map((p) => getPackageJson(join(root, p))
.then((pJson) => ({ ...pJson, path: p }))
.catch(() => null)))).filter((p) => p !== null);
const packageInfo = {};
packageJsons.forEach((p) => {
const { name, path } = p;
packageInfo[name] = `${workspace}/${path}`;
});
return packageInfo;
};
const listPackagesSync = (workspace) => {
const root = (0,external_path_namespaceObject.join)(rootPath, workspace);
const dirs = (0,external_node_fs_namespaceObject.readdirSync)(root, { withFileTypes: true });
const packages = dirs.filter((d) => d.isDirectory()).map((d) => d.name);
const packageJsons = packages.map((p) => {
try {
const pJson = getPackageJsonSync((0,external_path_namespaceObject.join)(root, p));
return { ...pJson, path: p };
}
catch (e) {
return null;
}
}).filter((p) => p !== null);
const packageInfo = {};
packageJsons.forEach((p) => {
const { name, path } = p;
packageInfo[name] = `${workspace}/${path}`;
});
return packageInfo;
};
const getWorkspacePackages = async () => {
const workspaces = await getWorkspaces();
const packages = await Promise.all(workspaces.map((w) => listPackages(w)));
const info = packages.reduce((acc, cur) => ({ ...acc, ...cur }), {});
return info;
};
const getWorkspacePackagesSync = () => {
const workspaces = getWorkspacesSync();
const packages = workspaces.map((w) => listPackagesSync(w));
const info = packages.reduce((acc, cur) => ({ ...acc, ...cur }), {});
return info;
};
const formatPackageInfo = async (info) => {
const packages = Object.keys(info).map((name) => ({
name,
path: info[name],
localDependencies: [],
dependencies: [],
scripts: [],
scriptCommands: {}
}));
const prms = packages.map(async (pcg) => {
const { path } = pcg;
const root = join(rootPath, path);
const pJson = await getPackageJson(root);
const { dependencies = {}, devDependencies = {} } = pJson;
const deps = Object.keys({ ...dependencies, ...devDependencies });
const locals = packages.filter((p) => deps.includes(p.name));
pcg.localDependencies = locals;
pcg.dependencies = deps;
pcg.scriptCommands = pJson.scripts || {};
pcg.scripts = Object.keys(pJson.scripts || {});
});
await Promise.all(prms);
return packages;
};
const getLocalPackages = async () => {
const info = await getWorkspacePackages();
const packages = await formatPackageInfo(info);
return packages;
};
;// CONCATENATED MODULE: ./lib/resolvers/typescript.ts
const typescriptResolver = async ({ dependencies, path }, { loadDependency }) => {
if (dependencies.includes("typescript")) {
const tscPath = (0,external_path_namespaceObject.join)(rootPath, path, "tsconfig.json");
const typescript = await loadDependency("typescript");
if (!typescript) {
return null;
}
const ts = typescript.default;
const tsConfig = ts.readConfigFile(tscPath, ts.sys.readFile);
if (!tsConfig) {
return null;
}
const out = {
outPath: null,
srcPath: null
};
if (tsConfig?.config?.compilerOptions?.outDir) {
out.outPath = tsConfig.config.compilerOptions.outDir;
}
if (tsConfig?.config?.compilerOptions?.rootDir) {
out.srcPath = tsConfig.config.compilerOptions.rootDir;
}
if (dependencies.includes("mono-runner")) {
out.readyIPC = true;
}
return out;
}
else {
return null;
}
};
;// CONCATENATED MODULE: external "fs"
const external_fs_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("fs");
;// CONCATENATED MODULE: ./lib/resolvers/vite.ts
const viteResolver = async ({ dependencies, path }, { loadDependency, loadBundled }) => {
if (dependencies.includes("vite")) {
const packageRoot = (0,external_path_namespaceObject.join)(rootPath, path);
const configPathJs = (0,external_path_namespaceObject.join)(packageRoot, "vite.config.js");
const configPathTs = (0,external_path_namespaceObject.join)(packageRoot, "vite.config.ts");
const configPath = (0,external_fs_namespaceObject.existsSync)(configPathTs) ? "vite.config.ts" : (0,external_fs_namespaceObject.existsSync)(configPathJs) ? "vite.config.js" : null;
if (!configPath) {
return null;
}
const viteConfig = await loadBundled(configPath).catch(() => null);
if (!viteConfig || !viteConfig.default) {
return null;
}
let parsed = viteConfig.default;
if (typeof viteConfig.default === "function") {
parsed = await Promise.resolve(viteConfig.default({ command: "build", mode: "production", ssrBuild: true }));
}
if (!parsed) {
return null;
}
const out = {
outPath: "dist",
srcPath: "."
};
if (parsed.build?.outDir) {
out.outPath = parsed.build.outDir;
}
if (parsed.root) {
out.srcPath = parsed.root;
}
return out;
}
else {
return null;
}
};
;// CONCATENATED MODULE: ./lib/utils/resolvers.ts
const defaultResolvers = [
klarPackageResolver,
sveltePackageResolver,
svelteKitResolver,
viteResolver,
typescriptResolver
];
/* harmony default export */ const resolvers = ((/* unused pure expression or super */ null && (defaultResolvers)));
;// CONCATENATED MODULE: ./lib/plugins/sass.ts
const createSassImporter = () => {
const packages = getWorkspacePackagesSync();
const resolve = (request) => {
for (const [name, path] of Object.entries(packages)) {
if (request.startsWith(name)) {
return (0,external_path_namespaceObject.join)(rootPath, path, request.substring(name.length));
}
}
return request;
};
return (request, source, done) => {
const mod = resolve(request);
if (done) {
done({
file: mod,
});
}
else {
return {
file: mod,
};
}
};
};
;// CONCATENATED MODULE: ./lib/plugins/vite.ts
const ViteMonoPlugin = (config) => {
const packages = getWorkspacePackagesSync();
const packageKeys = Object.keys(packages);
return {
name: "mono-vite-plugin",
config: (opts, env) => {
},
resolveId: (id) => {
for (let index = 0; index < packageKeys.length; index++) {
const key = packageKeys[index];
if (id.startsWith(key)) {
const path = packages[key];
const newPath = id.replace(key, path);
return {
id: (0,external_path_namespaceObject.join)(rootPath, newPath),
};
}
}
return undefined;
}
};
};
;// CONCATENATED MODULE: ./lib/plugins/svelte.ts
const svelteMonoAlias = () => {
const packages = getWorkspacePackagesSync();
const alias = {};
Object.entries(packages).forEach(([key, value]) => {
alias[key] = (0,external_path_namespaceObject.join)(rootPath, value);
});
return alias;
};
;// CONCATENATED MODULE: ./lib/index.ts
/* harmony default export */ const lib = (defaultResolvers);
var __webpack_exports__ViteMonoPlugin = __webpack_exports__.fS;
var __webpack_exports__createSassImporter = __webpack_exports__.LX;
var __webpack_exports__default = __webpack_exports__.Ay;
var __webpack_exports__defaultResolvers = __webpack_exports__.lo;
var __webpack_exports__svelteKitResolver = __webpack_exports__.Q3;
var __webpack_exports__svelteMonoAlias = __webpack_exports__.Fz;
var __webpack_exports__sveltePackageResolver = __webpack_exports__.yy;
var __webpack_exports__typescriptResolver = __webpack_exports__.ol;
var __webpack_exports__viteResolver = __webpack_exports__.fp;
export { __webpack_exports__ViteMonoPlugin as ViteMonoPlugin, __webpack_exports__createSassImporter as createSassImporter, __webpack_exports__default as default, __webpack_exports__defaultResolvers as defaultResolvers, __webpack_exports__svelteKitResolver as svelteKitResolver, __webpack_exports__svelteMonoAlias as svelteMonoAlias, __webpack_exports__sveltePackageResolver as sveltePackageResolver, __webpack_exports__typescriptResolver as typescriptResolver, __webpack_exports__viteResolver as viteResolver };