@storm-software/workspace-tools
Version:
Tools for managing a Storm workspace, including various Nx generators and executors for common development tasks.
320 lines (306 loc) • 11.3 kB
JavaScript
import {
writeDebug,
writeTrace
} from "./chunk-MMA4S6LZ.mjs";
import {
findWorkspaceRoot
} from "./chunk-3J2CP54B.mjs";
import {
joinPaths
} from "./chunk-TBW5MCN6.mjs";
// ../build-tools/src/config.ts
var DEFAULT_JS_BANNER = `
// ---------------------------------------
// \u{1F5F2} Built by Storm Software
// ---------------------------------------
`;
var DEFAULT_CSS_BANNER = `
/* ---------------------------------------
\u{1F5F2} Built by Storm Software
--------------------------------------- */
`;
var DEFAULT_ENVIRONMENT = "production";
var DEFAULT_TARGET = "esnext";
var DEFAULT_ORGANIZATION = "storm-software";
// ../build-tools/src/utilities/copy-assets.ts
import { CopyAssetsHandler } from "@nx/js/src/utils/assets/copy-assets-handler";
import { glob } from "glob";
import { readFile, writeFile } from "node:fs/promises";
var copyAssets = async (config, assets, outputPath, projectRoot, sourceRoot, generatePackageJson = true, includeSrc = false, banner, footer) => {
const pendingAssets = Array.from(assets ?? []);
pendingAssets.push({
input: projectRoot,
glob: "*.md",
output: "."
});
pendingAssets.push({
input: ".",
glob: "LICENSE",
output: "."
});
if (generatePackageJson === false) {
pendingAssets.push({
input: projectRoot,
glob: "package.json",
output: "."
});
}
if (includeSrc === true) {
pendingAssets.push({
input: sourceRoot,
glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
output: "src/"
});
}
writeTrace(
`\u{1F4DD} Copying the following assets to the output directory:
${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${pendingAsset} -> ${outputPath}` : ` - ${pendingAsset.input}/${pendingAsset.glob} -> ${joinPaths(outputPath, pendingAsset.output)}`).join("\n")}`,
config
);
const assetHandler = new CopyAssetsHandler({
projectDir: projectRoot,
rootDir: config.workspaceRoot,
outputDir: outputPath,
assets: pendingAssets
});
await assetHandler.processAllAssetsOnce();
writeTrace("Completed copying assets to the output directory", config);
if (includeSrc === true) {
writeDebug(
`\u{1F4DD} Adding banner and writing source files: ${joinPaths(
outputPath,
"src"
)}`,
config
);
const files = await glob([
joinPaths(config.workspaceRoot, outputPath, "src/**/*.ts"),
joinPaths(config.workspaceRoot, outputPath, "src/**/*.tsx"),
joinPaths(config.workspaceRoot, outputPath, "src/**/*.js"),
joinPaths(config.workspaceRoot, outputPath, "src/**/*.jsx")
]);
await Promise.allSettled(
files.map(
async (file) => writeFile(
file,
`${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
${await readFile(file, "utf8")}
${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`
)
)
);
}
};
// ../build-tools/src/utilities/generate-package-json.ts
import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
import { Glob } from "glob";
import { existsSync, readFileSync } from "node:fs";
import { readFile as readFile2 } from "node:fs/promises";
import {
createProjectGraphAsync,
readCachedProjectGraph,
readProjectsConfigurationFromProjectGraph
} from "nx/src/project-graph/project-graph";
var addPackageDependencies = async (workspaceRoot, projectRoot, projectName, packageJson) => {
let projectGraph;
try {
projectGraph = readCachedProjectGraph();
} catch {
await createProjectGraphAsync();
projectGraph = readCachedProjectGraph();
}
if (!projectGraph) {
throw new Error(
"The Build process failed because the project graph is not available. Please run the build command again."
);
}
const projectDependencies = calculateProjectBuildableDependencies(
void 0,
projectGraph,
workspaceRoot,
projectName,
process.env.NX_TASK_TARGET_TARGET || "build",
process.env.NX_TASK_TARGET_CONFIGURATION || "production",
true
);
const localPackages = [];
for (const project of projectDependencies.dependencies.filter(
(dep) => dep.node.type === "lib" && dep.node.data?.root !== projectRoot && dep.node.data?.root !== workspaceRoot
)) {
const projectNode = project.node;
if (projectNode.data.root) {
const projectPackageJsonPath = joinPaths(
workspaceRoot,
projectNode.data.root,
"package.json"
);
if (existsSync(projectPackageJsonPath)) {
const projectPackageJsonContent = await readFile2(
projectPackageJsonPath,
"utf8"
);
const projectPackageJson = JSON.parse(projectPackageJsonContent);
if (projectPackageJson.private !== true) {
localPackages.push(projectPackageJson);
}
}
}
}
if (localPackages.length > 0) {
writeTrace(
`\u{1F4E6} Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`
);
const projectJsonFile = await readFile2(
joinPaths(projectRoot, "project.json"),
"utf8"
);
const projectJson = JSON.parse(projectJsonFile);
const projectName2 = projectJson.name;
const projectConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
if (!projectConfigurations?.projects?.[projectName2]) {
throw new Error(
"The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project."
);
}
const implicitDependencies = projectConfigurations.projects?.[projectName2].implicitDependencies?.reduce((ret, dep) => {
if (projectConfigurations.projects?.[dep]) {
const depPackageJsonPath = joinPaths(
workspaceRoot,
projectConfigurations.projects[dep].root,
"package.json"
);
if (existsSync(depPackageJsonPath)) {
const depPackageJsonContent = readFileSync(
depPackageJsonPath,
"utf8"
);
const depPackageJson = JSON.parse(depPackageJsonContent);
if (depPackageJson.private !== true && !ret.includes(depPackageJson.name)) {
ret.push(depPackageJson.name);
}
}
}
return ret;
}, []);
packageJson.dependencies = localPackages.reduce((ret, localPackage) => {
if (!ret[localPackage.name] && !implicitDependencies?.includes(localPackage.name) && packageJson.devDependencies?.[localPackage.name] === void 0) {
ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
}
return ret;
}, packageJson.dependencies ?? {});
packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
if (!ret[localPackage.name] && implicitDependencies?.includes(localPackage.name) && packageJson.dependencies?.[localPackage.name] === void 0) {
ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
}
return ret;
}, packageJson.devDependencies ?? {});
} else {
writeTrace("\u{1F4E6} No local packages dependencies to add to package.json");
}
return packageJson;
};
var addWorkspacePackageJsonFields = async (workspaceConfig, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
const workspaceRoot = workspaceConfig.workspaceRoot ? workspaceConfig.workspaceRoot : findWorkspaceRoot();
const workspacePackageJsonContent = await readFile2(
joinPaths(workspaceRoot, "package.json"),
"utf8"
);
const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
packageJson.type ??= "module";
packageJson.sideEffects ??= false;
if (includeSrc === true) {
let distSrc = sourceRoot.replace(projectRoot, "");
if (distSrc.startsWith("/")) {
distSrc = distSrc.substring(1);
}
packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
}
packageJson.files ??= ["dist/**/*"];
if (includeSrc === true && !packageJson.files.includes("src")) {
packageJson.files.push("src/**/*");
}
packageJson.publishConfig ??= {
access: "public"
};
packageJson.description ??= workspacePackageJson.description;
packageJson.homepage ??= workspacePackageJson.homepage;
packageJson.bugs ??= workspacePackageJson.bugs;
packageJson.license ??= workspacePackageJson.license;
packageJson.keywords ??= workspacePackageJson.keywords;
packageJson.funding ??= workspacePackageJson.funding;
packageJson.author ??= workspacePackageJson.author;
packageJson.maintainers ??= workspacePackageJson.maintainers;
if (!packageJson.maintainers && packageJson.author) {
packageJson.maintainers = [packageJson.author];
}
packageJson.contributors ??= workspacePackageJson.contributors;
if (!packageJson.contributors && packageJson.author) {
packageJson.contributors = [packageJson.author];
}
packageJson.repository ??= workspacePackageJson.repository;
packageJson.repository.directory ??= projectRoot ? projectRoot : joinPaths("packages", projectName);
return packageJson;
};
var addPackageJsonExport = (file, type = "module", sourceRoot) => {
let entry = file.replaceAll("\\", "/");
if (sourceRoot) {
entry = entry.replace(sourceRoot, "");
}
return {
import: {
types: `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
default: `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
},
require: {
types: `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
default: `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
},
default: {
types: `./dist/${entry}.d.${type !== "fixed" ? "ts" : "mts"}`,
default: `./dist/${entry}.${type !== "fixed" ? "js" : "mjs"}`
}
};
};
// ../build-tools/src/utilities/get-env.ts
var getEnv = (builder, options) => {
return {
STORM_BUILD: builder,
STORM_ORG: options.orgName || DEFAULT_ORGANIZATION,
STORM_NAME: options.name,
STORM_MODE: options.mode || DEFAULT_ENVIRONMENT,
STORM_PLATFORM: options.platform,
STORM_FORMAT: JSON.stringify(options.format),
STORM_TARGET: JSON.stringify(options.target),
...options.env
};
};
// ../build-tools/src/plugins/swc.ts
import { transform } from "@swc/core";
// ../build-tools/src/plugins/ts-resolve.ts
import fs from "node:fs";
import { builtinModules } from "node:module";
import path from "node:path";
import _resolve from "resolve";
// ../build-tools/src/plugins/type-definitions.ts
import { stripIndents } from "@nx/devkit";
import { relative } from "path";
// ../build-tools/src/utilities/get-entry-points.ts
import { glob as glob2 } from "glob";
// ../build-tools/src/utilities/read-nx-config.ts
import { existsSync as existsSync2 } from "node:fs";
import { readFile as readFile3 } from "node:fs/promises";
// ../build-tools/src/utilities/task-graph.ts
import {
createTaskGraph,
mapTargetDefaultsToDependencies
} from "nx/src/tasks-runner/create-task-graph";
export {
DEFAULT_JS_BANNER,
DEFAULT_CSS_BANNER,
DEFAULT_TARGET,
copyAssets,
addPackageDependencies,
addWorkspacePackageJsonFields,
addPackageJsonExport,
getEnv
};