@storm-software/terraform-tools
Version:
Tools for managing Terraform infrastructure within a Nx workspace.
3,071 lines • 96.6 kB
JavaScript
import {
applyWorkspaceBaseTokens,
applyWorkspaceTokens,
correctPaths,
findWorkspaceRoot,
formatLogMessage,
getConfig,
getStopwatch,
getWorkspaceConfig,
isAbsolute,
joinPaths,
relative,
schemaRegistry,
withRunExecutor,
workspaceConfigSchema,
writeDebug,
writeError,
writeFatal,
writeInfo,
writeSuccess,
writeTrace,
writeWarning
} from "./chunk-GGQWZWZ3.mjs";
import {
__dirname
} from "./chunk-3SMBRI6D.mjs";
// src/generators/init/init.ts
import { formatFiles as formatFiles8 } from "@nx/devkit";
// ../workspace-tools/src/utils/cargo.ts
import { joinPathFragments } from "@nx/devkit";
import {
execSync,
spawn
} from "node:child_process";
import { relative as relative2 } from "node:path";
var INVALID_CARGO_ARGS = [
"allFeatures",
"allTargets",
"main",
"outputPath",
"package",
"tsConfig"
];
var buildCargoCommand = (baseCommand, options, context) => {
const args = [];
if (options.toolchain && options.toolchain !== "stable") {
args.push(`+${options.toolchain}`);
}
args.push(baseCommand);
for (const [key, value] of Object.entries(options)) {
if (key === "toolchain" || key === "release" || INVALID_CARGO_ARGS.includes(key)) {
continue;
}
if (typeof value === "boolean") {
if (value) {
args.push(`--${key}`);
}
} else if (Array.isArray(value)) {
for (const item of value) {
args.push(`--${key}`, item);
}
} else {
args.push(`--${key}`, String(value));
}
}
if (context.projectName) {
args.push("-p", context.projectName);
}
if (options.allFeatures && !args.includes("--all-features")) {
args.push("--all-features");
}
if (options.allTargets && !args.includes("--all-targets")) {
args.push("--all-targets");
}
if (options.release && !args.includes("--profile")) {
args.push("--release");
}
if (options.outputPath && !args.includes("--target-dir")) {
args.push("--target-dir", options.outputPath);
}
return args;
};
async function cargoCommand(workspaceRoot2, ...args) {
console.log(`> cargo ${args.join(" ")}`);
args.push("--color", "always");
return await Promise.resolve(runProcess(workspaceRoot2, "cargo", ...args));
}
function cargoCommandSync(args = "", options) {
const normalizedOptions = {
stdio: options?.stdio ?? "inherit",
env: {
...process.env,
...options?.env
}
};
try {
return {
output: execSync(`cargo ${args}`, {
encoding: "utf8",
windowsHide: true,
stdio: normalizedOptions.stdio,
env: normalizedOptions.env,
maxBuffer: 1024 * 1024 * 10
}),
success: true
};
} catch (e) {
return {
output: e,
success: false
};
}
}
function cargoMetadata() {
const output2 = cargoCommandSync("metadata --format-version=1", {
stdio: "pipe"
});
if (!output2.success) {
console.error("Failed to get cargo metadata");
return null;
}
return JSON.parse(output2.output);
}
function runProcess(workspaceRoot2, processCmd, ...args) {
const metadata = cargoMetadata();
const targetDir = metadata?.target_directory ?? joinPathFragments(workspaceRoot2, "dist");
return new Promise((resolve2) => {
if (process.env.VERCEL) {
return resolve2({ success: true });
}
execSync(`${processCmd} ${args.join(" ")}`, {
cwd: process.cwd(),
env: {
...process.env,
RUSTC_WRAPPER: "",
CARGO_TARGET_DIR: targetDir,
CARGO_BUILD_TARGET_DIR: targetDir
},
windowsHide: true,
stdio: ["inherit", "inherit", "inherit"]
});
resolve2({ success: true });
});
}
// ../workspace-tools/src/executors/cargo-build/executor.ts
async function cargoBuildExecutor(options, context) {
const command = buildCargoCommand("build", options, context);
return await cargoCommand(context.root, ...command);
}
var executor_default = withRunExecutor(
"Cargo - Build",
cargoBuildExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.outputPath ??= "dist/{projectRoot}/target";
options.toolchain ??= "stable";
return options;
}
}
}
);
// ../workspace-tools/src/executors/cargo-check/executor.ts
async function cargoCheckExecutor(options, context) {
const command = buildCargoCommand("check", options, context);
return await cargoCommand(context.root, ...command);
}
var executor_default2 = withRunExecutor(
"Cargo - Check",
cargoCheckExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.toolchain ??= "stable";
return options;
}
}
}
);
// ../workspace-tools/src/executors/cargo-clippy/executor.ts
async function cargoClippyExecutor(options, context) {
const command = buildCargoCommand("clippy", options, context);
return await cargoCommand(context.root, ...command);
}
var executor_default3 = withRunExecutor(
"Cargo - Clippy",
cargoClippyExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.toolchain ??= "stable";
options.fix ??= false;
return options;
}
}
}
);
// ../workspace-tools/src/executors/cargo-doc/executor.ts
async function cargoDocExecutor(options, context) {
const opts = { ...options };
opts["no-deps"] = opts.noDeps;
delete opts.noDeps;
const command = buildCargoCommand("doc", options, context);
return await cargoCommand(context.root, ...command);
}
var executor_default4 = withRunExecutor(
"Cargo - Doc",
cargoDocExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.outputPath ??= "dist/{projectRoot}/docs";
options.toolchain ??= "stable";
options.release ??= options.profile ? false : true;
options.allFeatures ??= true;
options.lib ??= true;
options.bins ??= true;
options.examples ??= true;
options.noDeps ??= false;
return options;
}
}
}
);
// ../workspace-tools/src/executors/cargo-format/executor.ts
async function cargoFormatExecutor(options, context) {
const command = buildCargoCommand("fmt", options, context);
return await cargoCommand(context.root, ...command);
}
var executor_default5 = withRunExecutor(
"Cargo - Format",
cargoFormatExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.outputPath ??= "dist/{projectRoot}/target";
options.toolchain ??= "stable";
return options;
}
}
}
);
// ../workspace-tools/src/executors/cargo-publish/executor.ts
import { joinPathFragments as joinPathFragments2 } from "@nx/devkit";
import { execSync as execSync2 } from "node:child_process";
import { readFileSync } from "node:fs";
import https from "node:https";
var LARGE_BUFFER = 1024 * 1e6;
// ../build-tools/src/config.ts
var DEFAULT_JS_BANNER = `
// ---------------------------------------
// \u26A1 Built by Storm Software
// ---------------------------------------
`;
var DEFAULT_CSS_BANNER = `
/* ---------------------------------------
\u26A1 Built by Storm Software
--------------------------------------- */
`;
var DEFAULT_ENVIRONMENT = "production";
var DEFAULT_TARGET = "esnext";
var DEFAULT_ORGANIZATION = "storm-software";
// ../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 as relative3 } from "path";
// ../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, generatePackageJson3 = true, includeSrc = false, banner, footer) => {
const pendingAssets = Array.from(assets ?? []);
pendingAssets.push({
input: projectRoot,
glob: "*.md",
output: "."
});
pendingAssets.push({
input: ".",
glob: "LICENSE",
output: "."
});
if (generatePackageJson3 === 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 as readFileSync2 } 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 (workspaceRoot2, 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,
workspaceRoot2,
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 !== workspaceRoot2
)) {
const projectNode = project.node;
if (projectNode.data.root) {
const projectPackageJsonPath = joinPaths(
workspaceRoot2,
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(
workspaceRoot2,
projectConfigurations.projects[dep].root,
"package.json"
);
if (existsSync(depPackageJsonPath)) {
const depPackageJsonContent = readFileSync2(
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 workspaceRoot2 = workspaceConfig.workspaceRoot ? workspaceConfig.workspaceRoot : findWorkspaceRoot();
const workspacePackageJsonContent = await readFile2(
joinPaths(workspaceRoot2, "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-entry-points.ts
import { glob as glob2 } from "glob";
// ../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/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";
// ../esbuild/src/assets.ts
async function copyBuildAssets(context) {
if (!context.result?.errors.length && context.options.assets?.length) {
writeDebug(
` \u{1F4CB} Copying ${context.options.assets.length} asset files to output directory: ${context.outputPath}`,
context.workspaceConfig
);
const stopwatch = getStopwatch(`${context.options.name} asset copy`);
await copyAssets(
context.workspaceConfig,
context.options.assets ?? [],
context.outputPath,
context.options.projectRoot,
context.sourceRoot,
true,
false
);
stopwatch();
}
return context;
}
// ../esbuild/src/clean.ts
import { rm } from "node:fs/promises";
async function cleanDirectories(directory) {
await rm(directory, { recursive: true, force: true });
}
// ../esbuild/src/context.ts
import {
createProjectGraphAsync as createProjectGraphAsync2,
readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph2
} from "@nx/devkit";
import defu from "defu";
import { existsSync as existsSync3 } from "node:fs";
import hf from "node:fs/promises";
import { findWorkspaceRoot as findWorkspaceRoot2 } from "nx/src/utils/find-workspace-root";
// ../esbuild/src/config.ts
var DEFAULT_BUILD_OPTIONS = {
platform: "node",
target: "node22",
format: "esm",
mode: "production",
generatePackageJson: true,
includeSrc: false,
keepNames: true,
metafile: false,
treeshake: true,
splitting: true,
shims: false,
watch: false,
bundle: true,
distDir: "dist",
loader: {
".aac": "file",
".css": "file",
".eot": "file",
".flac": "file",
".gif": "file",
".jpeg": "file",
".jpg": "file",
".mp3": "file",
".mp4": "file",
".ogg": "file",
".otf": "file",
".png": "file",
".svg": "file",
".ttf": "file",
".wav": "file",
".webm": "file",
".webp": "file",
".woff": "file",
".woff2": "file"
},
banner: {
js: DEFAULT_JS_BANNER,
css: DEFAULT_CSS_BANNER
}
};
// ../esbuild/src/context.ts
async function resolveContext(userOptions) {
const projectRoot = userOptions.projectRoot;
const workspaceRoot2 = findWorkspaceRoot2(projectRoot);
if (!workspaceRoot2) {
throw new Error("Cannot find Nx workspace root");
}
const workspaceConfig = await getWorkspaceConfig(true, {
workspaceRoot: workspaceRoot2.dir
});
writeDebug(" \u2699\uFE0F Resolving build options", workspaceConfig);
const stopwatch = getStopwatch("Build options resolution");
const projectGraph = await createProjectGraphAsync2({
exitOnError: true
});
const projectJsonPath = joinPaths(
workspaceRoot2.dir,
projectRoot,
"project.json"
);
if (!existsSync3(projectJsonPath)) {
throw new Error("Cannot find project.json configuration");
}
const projectJsonFile = await hf.readFile(projectJsonPath, "utf8");
const projectJson = JSON.parse(projectJsonFile);
const projectName = projectJson.name || userOptions.name;
const projectConfigurations = readProjectsConfigurationFromProjectGraph2(projectGraph);
if (!projectConfigurations?.projects?.[projectName]) {
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 options = defu(userOptions, DEFAULT_BUILD_OPTIONS);
options.name ??= projectName;
const packageJsonPath = joinPaths(
workspaceRoot2.dir,
options.projectRoot,
"package.json"
);
if (!existsSync3(packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const env = getEnv("esbuild", options);
const define = defu(options.define ?? {}, env ?? {});
const resolvedOptions = {
...options,
tsconfig: userOptions.tsconfig === null ? void 0 : userOptions.tsconfig ? userOptions.tsconfig : joinPaths(workspaceRoot2.dir, projectRoot, "tsconfig.json"),
metafile: userOptions.mode === "development",
clean: false,
env,
define: {
STORM_FORMAT: JSON.stringify(options.format),
...Object.keys(define).filter((key) => define[key] !== void 0).reduce((res, key) => {
const value = JSON.stringify(define[key]);
const safeKey = key.replaceAll("(", "").replaceAll(")", "");
return {
...res,
[`process.env.${safeKey}`]: value,
[`import.meta.env.${safeKey}`]: value
};
}, {})
}
};
stopwatch();
const context = {
options: resolvedOptions,
clean: userOptions.clean !== false,
workspaceConfig,
projectConfigurations,
projectName,
projectGraph,
sourceRoot: resolvedOptions.sourceRoot || projectJson.sourceRoot || joinPaths(resolvedOptions.projectRoot, "src"),
outputPath: resolvedOptions.outputPath || joinPaths(
workspaceConfig.workspaceRoot,
"dist",
resolvedOptions.projectRoot
),
minify: resolvedOptions.minify || resolvedOptions.mode === "production"
};
context.options.esbuildPlugins = [...context.options.esbuildPlugins ?? []];
if (context.options.verbose) {
writeDebug(
` \u2699\uFE0F Build options resolved:
${formatLogMessage(context.options)}`,
workspaceConfig
);
}
return context;
}
// ../esbuild/src/package-json.ts
import { writeJsonFile } from "@nx/devkit";
import { existsSync as existsSync4 } from "node:fs";
import hf2 from "node:fs/promises";
async function generatePackageJson(context) {
if (context.options.generatePackageJson !== false && existsSync4(joinPaths(context.options.projectRoot, "package.json"))) {
writeDebug(" \u270D\uFE0F Writing package.json file", context.workspaceConfig);
const stopwatch = getStopwatch("Write package.json file");
const packageJsonPath = joinPaths(
context.options.projectRoot,
"project.json"
);
if (!existsSync4(packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const packageJsonFile = await hf2.readFile(
joinPaths(
context.workspaceConfig.workspaceRoot,
context.options.projectRoot,
"package.json"
),
"utf8"
);
let packageJson = JSON.parse(packageJsonFile);
if (!packageJson) {
throw new Error("Cannot find package.json configuration file");
}
packageJson = await addPackageDependencies(
context.workspaceConfig.workspaceRoot,
context.options.projectRoot,
context.projectName,
packageJson
);
packageJson = await addWorkspacePackageJsonFields(
context.workspaceConfig,
context.options.projectRoot,
context.sourceRoot,
context.projectName,
false,
packageJson
);
if (context.options.entry) {
packageJson.exports ??= {};
packageJson.exports["./package.json"] ??= "./package.json";
const entryPoints = Array.isArray(context.options.entry) ? context.options.entry : Object.keys(context.options.entry);
if (entryPoints.length > 0) {
const defaultEntry = entryPoints.includes("index") ? `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index` : `.${context.options.distDir ? `/${context.options.distDir}` : ""}/${entryPoints[0]}`;
const isEsm = Array.isArray(context.options.format) ? context.options.format.includes("esm") : context.options.format === "esm";
const isCjs = Array.isArray(context.options.format) ? context.options.format.includes("cjs") : context.options.format === "cjs";
const isDts = context.options.dts || context.options.experimentalDts;
packageJson.exports["."] ??= `${defaultEntry}.${isEsm ? "mjs" : isCjs ? "cjs" : "js"}`;
for (const entryPoint of entryPoints) {
packageJson.exports[`./${entryPoint}`] ??= {};
if (isEsm) {
if (isDts) {
packageJson.exports[`./${entryPoint}`].import = {
types: `./dist/${entryPoint}.d.mts`,
default: `./dist/${entryPoint}.mjs`
};
} else {
packageJson.exports[`./${entryPoint}`].import = `./dist/${entryPoint}.mjs`;
}
if (isDts) {
packageJson.exports[`./${entryPoint}`].default = {
types: `./dist/${entryPoint}.d.mts`,
default: `./dist/${entryPoint}.mjs`
};
} else {
packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.mjs`;
}
}
if (isCjs) {
if (isDts) {
packageJson.exports[`./${entryPoint}`].require = {
types: `./dist/${entryPoint}.d.cts`,
default: `./dist/${entryPoint}.cjs`
};
} else {
packageJson.exports[`./${entryPoint}`].require = `./dist/${entryPoint}.cjs`;
}
if (!isEsm) {
if (isDts) {
packageJson.exports[`./${entryPoint}`].default = {
types: `./dist/${entryPoint}.d.cts`,
default: `./dist/${entryPoint}.cjs`
};
} else {
packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.cjs`;
}
}
}
if (!isEsm && !isCjs) {
if (isDts) {
packageJson.exports[`./${entryPoint}`].default = {
types: `./dist/${entryPoint}.d.ts`,
default: `./dist/${entryPoint}.js`
};
} else {
packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.js`;
}
}
}
if (isEsm) {
packageJson.module = `${defaultEntry}.mjs`;
} else {
packageJson.main = `${defaultEntry}.cjs`;
}
if (isDts) {
packageJson.types = `${defaultEntry}.d.${isEsm ? "mts" : isCjs ? "cts" : "ts"}`;
}
packageJson.exports = Object.keys(packageJson.exports).reduce(
(ret, key) => {
if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
ret[key.replace("/index", "")] = packageJson.exports[key];
}
return ret;
},
packageJson.exports
);
}
}
await writeJsonFile(
joinPaths(context.outputPath, "package.json"),
packageJson
);
stopwatch();
}
return context;
}
// ../tsup/src/index.ts
import { build as tsup } from "tsup";
async function build(options) {
if (!options.silent) {
writeDebug(
` \u{1F680} Running ${options.name || "tsup"} build`,
options.workspaceConfig
);
}
const stopwatch = getStopwatch(`${options.name || "tsup"} build`);
await tsup(options);
if (!options.silent) {
stopwatch();
}
}
// ../esbuild/src/tsup.ts
async function executeTsup(context) {
writeDebug(
` \u{1F680} Running ${context.options.name} build`,
context.workspaceConfig
);
const stopwatch = getStopwatch(`${context.options.name} build`);
await build({
...context.options,
outDir: context.options.distDir ? joinPaths(context.outputPath, context.options.distDir) : context.outputPath,
workspaceConfig: context.workspaceConfig
});
stopwatch();
return context;
}
// ../esbuild/src/build.ts
async function reportResults(context) {
if (context.result?.errors.length === 0) {
if (context.result.warnings.length > 0) {
writeWarning(
` \u{1F6A7} The following warnings occurred during the build: ${context.result.warnings.map((warning) => warning.text).join("\n")}`,
context.workspaceConfig
);
}
writeSuccess(
` \u{1F4E6} The ${context.options.name} build completed successfully`,
context.workspaceConfig
);
} else if (context.result?.errors && context.result?.errors.length > 0) {
writeError(
` \u274C The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`,
context.workspaceConfig
);
throw new Error(
`The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`
);
}
}
async function cleanOutputPath(context) {
if (context.clean !== false && context.outputPath) {
writeDebug(
` \u{1F9F9} Cleaning ${context.options.name} output path: ${context.outputPath}`,
context.workspaceConfig
);
const stopwatch = getStopwatch(`${context.options.name} output clean`);
await cleanDirectories(context.outputPath);
stopwatch();
}
return context;
}
async function build2(options) {
writeDebug(` \u26A1 Executing Storm ESBuild pipeline`);
const stopwatch = getStopwatch("ESBuild pipeline");
try {
const opts = Array.isArray(options) ? options : [options];
if (opts.length === 0) {
throw new Error("No build options were provided");
}
const context = await resolveContext(options);
await cleanOutputPath(context);
await Promise.all([
// dependencyCheck(context.options),
generatePackageJson(context),
copyBuildAssets(context),
executeTsup(context)
]);
await reportResults(context);
writeSuccess(" \u{1F3C1} ESBuild pipeline build completed successfully");
} catch (error) {
writeFatal(
"Fatal errors that the build process could not recover from have occured. The build process has been terminated."
);
throw error;
} finally {
stopwatch();
}
}
// ../workspace-tools/src/executors/esbuild/executor.ts
async function esbuildExecutorFn(options, context, config) {
writeInfo("\u{1F4E6} Running Storm ESBuild executor on the workspace", config);
if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
throw new Error(
"The Build process failed because the context is not valid. Please run this command from a workspace."
);
}
await build2({
...options,
projectRoot: (
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
context.projectsConfigurations.projects?.[context.projectName].root
),
name: context.projectName,
sourceRoot: context.projectsConfigurations.projects?.[context.projectName]?.sourceRoot,
format: options.format,
platform: options.platform
});
return {
success: true
};
}
var executor_default6 = withRunExecutor(
"Storm ESBuild build",
esbuildExecutorFn,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: async (options) => {
options.entry ??= ["src/index.ts"];
options.outputPath ??= "dist/{projectRoot}";
options.tsconfig ??= "{projectRoot}/tsconfig.json";
return options;
}
}
}
);
// ../workspace-tools/src/executors/napi/executor.ts
import { createJiti } from "jiti";
import { fileExists } from "nx/src/utils/fileutils";
async function napiExecutor(options, context, config) {
const jiti = createJiti(config.workspaceRoot, {
fsCache: config.skipCache ? false : joinPaths(
config.workspaceRoot,
config.directories.cache || "node_modules/.cache/storm",
"jiti"
),
interopDefault: true
});
const { NapiCli } = await jiti.import(
jiti.esmResolve("@napi-rs/cli")
);
if (!context.projectGraph?.nodes[context.projectName ?? ""]) {
throw new Error(
"The Napi Build process failed because the project could not be found in the project graph. Please run this command from a workspace root directory."
);
}
const projectRoot = context.projectGraph?.nodes[context.projectName ?? ""].data.root;
const packageJson = joinPaths(projectRoot ?? ".", "package.json");
if (!fileExists(packageJson)) {
throw new Error(`Could not find package.json at ${packageJson}`);
}
const napi = new NapiCli();
const normalizedOptions = { ...options };
const metadata = cargoMetadata();
normalizedOptions.targetDir = options.targetDir || metadata?.target_directory || joinPaths(config.workspaceRoot, "dist", "target");
normalizedOptions.outputDir = options.outputPath;
normalizedOptions.packageJsonPath = options.packageJsonPath || packageJson;
if (options.cwd) {
normalizedOptions.cwd = correctPaths(options.cwd);
} else {
normalizedOptions.cwd = correctPaths(projectRoot);
const absoluteProjectRoot = joinPaths(
config.workspaceRoot,
projectRoot || "."
);
if (normalizedOptions.outputDir) {
normalizedOptions.outputDir = relative(
absoluteProjectRoot,
correctPaths(
isAbsolute(normalizedOptions.outputDir) ? normalizedOptions.outputDir : joinPaths(config.workspaceRoot, normalizedOptions.outputDir)
)
);
}
if (normalizedOptions.packageJsonPath) {
normalizedOptions.packageJsonPath = relative(
absoluteProjectRoot,
correctPaths(
isAbsolute(normalizedOptions.packageJsonPath) ? normalizedOptions.packageJsonPath : joinPaths(config.workspaceRoot, normalizedOptions.packageJsonPath)
)
);
}
if (normalizedOptions.configPath) {
normalizedOptions.configPath = relative(
absoluteProjectRoot,
correctPaths(
isAbsolute(normalizedOptions.configPath) ? normalizedOptions.configPath : joinPaths(config.workspaceRoot, normalizedOptions.configPath)
)
);
}
if (normalizedOptions.manifestPath) {
normalizedOptions.manifestPath = relative(
absoluteProjectRoot,
correctPaths(
isAbsolute(normalizedOptions.manifestPath) ? normalizedOptions.manifestPath : joinPaths(config.workspaceRoot, normalizedOptions.manifestPath)
)
);
}
}
if (process.env.VERCEL) {
return { success: true };
}
const { task } = await napi.build(normalizedOptions);
return { success: true, terminalOutput: await task };
}
var executor_default7 = withRunExecutor(
"Napi - Build Bindings",
napiExecutor,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.outputPath ??= "{sourceRoot}";
options.toolchain ??= "stable";
options.dtsCache ??= true;
options.platform ??= true;
options.constEnum ??= false;
options.verbose ??= false;
options.jsBinding ??= "binding.js";
options.dts ??= "binding.d.ts";
return options;
}
}
}
);
// ../npm-tools/src/helpers/get-registry.ts
import { exec } from "node:child_process";
// ../pnpm-tools/src/helpers/replace-deps-aliases.ts
import {
createProjectGraphAsync as createProjectGraphAsync3,
readCachedProjectGraph as readCachedProjectGraph2
} from "@nx/devkit";
import { existsSync as existsSync6 } from "node:fs";
import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
import { format } from "prettier";
// ../npm-tools/src/helpers/get-version.ts
import { exec as exec2 } from "node:child_process";
// ../pnpm-tools/src/helpers/catalog.ts
import { coerce, gt, valid } from "semver";
// ../pnpm-tools/src/helpers/pnpm-workspace.ts
import { existsSync as existsSync5 } from "node:fs";
import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
import { parse, stringify } from "yaml";
// ../workspace-tools/src/executors/npm-publish/executor.ts
import { execSync as execSync3 } from "node:child_process";
import { readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
import { format as format3 } from "prettier";
// ../workspace-tools/src/utils/package-helpers.ts
import {
joinPathFragments as joinPathFragments3,
readJsonFile
} from "@nx/devkit";
import { execFileSync } from "child_process";
import { existsSync as existsSync7 } from "node:fs";
import { readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
import { dirname, resolve } from "path";
import { format as format2 } from "prettier";
// ../workspace-tools/src/utils/project-tags.ts
var ProjectTagConstants = {
Language: {
TAG_ID: "language",
TYPESCRIPT: "typescript",
RUST: "rust"
},
ProjectType: {
TAG_ID: "type",
LIBRARY: "library",
APPLICATION: "application"
},
ProjectLinking: {
TAG_ID: "project-linking",
REFERENCE: "reference",
ALIAS: "alias"
},
DistStyle: {
TAG_ID: "dist-style",
NORMAL: "normal",
CLEAN: "clean"
},
Provider: {
TAG_ID: "provider"
},
Platform: {
TAG_ID: "platform",
NODE: "node",
BROWSER: "browser",
NEUTRAL: "neutral",
WORKER: "worker"
},
Registry: {
TAG_ID: "registry",
CARGO: "cargo",
NPM: "npm",
CONTAINER: "container",
CYCLONE: "cyclone"
},
Plugin: {
TAG_ID: "plugin"
},
Builder: {
TAG_ID: "builder",
TSC: "tsc",
TSUP: "tsup",
TSDOWN: "tsdown",
VITE: "vite",
ROLLDOWN: "rolldown"
}
};
var formatProjectTag = (variant, value) => {
return `${variant}:${value}`;
};
var hasProjectTag = (project, variant) => {
project.tags = project.tags ?? [];
const prefix = formatProjectTag(variant, "");
return project.tags.some(
(tag) => tag.startsWith(prefix) && tag.length > prefix.length
);
};
var addProjectTag = (project, variant, value, options = {
overwrite: false
}) => {
project.tags = project.tags ?? [];
if (options.overwrite || !hasProjectTag(project, variant)) {
project.tags = project.tags.filter(
(tag) => !tag.startsWith(formatProjectTag(variant, ""))
);
project.tags.push(formatProjectTag(variant, value));
}
};
// ../workspace-tools/src/executors/npm-publish/executor.ts
var LARGE_BUFFER2 = 1024 * 1e6;
// ../workspace-tools/src/executors/size-limit/executor.ts
import { joinPathFragments as joinPathFragments4 } from "@nx/devkit";
import esBuildPlugin from "@size-limit/esbuild";
import esBuildWhyPlugin from "@size-limit/esbuild-why";
import filePlugin from "@size-limit/file";
import sizeLimit from "size-limit";
async function sizeLimitExecutorFn(options, context, config) {
if (!context?.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName]) {
throw new Error(
"The Size-Limit process failed because the context is not valid. Please run this command from a workspace."
);
}
writeInfo(`\u{1F4CF} Running Size-Limit on ${context.projectName}`, config);
sizeLimit([filePlugin, esBuildPlugin, esBuildWhyPlugin], {
checks: options.entry ?? context.projectsConfigurations.projects[context.projectName]?.sourceRoot ?? joinPathFragments4(
context.projectsConfigurations.projects[context.projectName]?.root ?? "./",
"src"
)
}).then((result) => {
writeInfo(
`\u{1F4CF} ${context.projectName} Size-Limit result: ${JSON.stringify(result)}`,
config
);
});
return {
success: true
};
}
var executor_default8 = withRunExecutor(
"Size-Limit Performance Test Executor",
sizeLimitExecutorFn,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
return options;
}
}
}
);
// ../tsdown/src/build.ts
import {
createProjectGraphAsync as createProjectGraphAsync4,
readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph3,
writeJsonFile as writeJsonFile2
} from "@nx/devkit";
import defu2 from "defu";
import { existsSync as existsSync8 } from "node:fs";
import hf3 from "node:fs/promises";
import { build as tsdown } from "tsdown";
// ../tsdown/src/clean.ts
import { rm as rm2 } from "node:fs/promises";
async function cleanDirectories2(name = "TSDown", directory, config) {
await rm2(directory, { recursive: true, force: true });
}
// ../tsdown/src/config.ts
function getDefaultOptions(config) {
return {
entry: ["./src/*.ts"],
platform: "node",
target: "esnext",
mode: "production",
dts: true,
unused: {
level: "error",
ignore: ["typescript"]
},
publint: true,
fixedExtension: true,
...config
};
}
function toTSDownFormat(format4) {
if (!format4 || Array.isArray(format4) && format4.length === 0) {
return ["cjs", "es"];
} else if (format4 === "esm") {
return "es";
} else if (Array.isArray(format4)) {
return format4.map((f) => f === "esm" ? "es" : f);
}
return format4;
}
// ../tsdown/src/build.ts
var resolveOptions = async (userOptions) => {
const options = getDefaultOptions(userOptions);
const workspaceRoot2 = findWorkspaceRoot(options.projectRoot);
if (!workspaceRoot2) {
throw new Error("Cannot find Nx workspace root");
}
const workspaceConfig = await getWorkspaceConfig(options.debug === true, {
workspaceRoot: workspaceRoot2
});
writeDebug(" \u2699\uFE0F Resolving build options", workspaceConfig);
const stopwatch = getStopwatch("Build options resolution");
const projectGraph = await createProjectGraphAsync4({
exitOnError: true
});
const projectJsonPath = joinPaths(
workspaceRoot2,
options.projectRoot,
"project.json"
);
if (!existsSync8(projectJsonPath)) {
throw new Error("Cannot find project.json configuration");
}
const projectJsonFile = await hf3.readFile(projectJsonPath, "utf8");
const projectJson = JSON.parse(projectJsonFile);
const projectName = projectJson.name;
const projectConfigurations = readProjectsConfigurationFromProjectGraph3(projectGraph);
if (!projectConfigurations?.projects?.[projectName]) {
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 packageJsonPath = joinPaths(
workspaceRoot2,
options.projectRoot,
"package.json"
);
if (!existsSync8(packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const debug = options.debug ?? (options.mode || workspaceConfig.mode) === "development";
const sourceRoot = projectJson.sourceRoot || joinPaths(options.projectRoot, "src");
const result = {
name: projectName,
mode: "production",
target: DEFAULT_TARGET,
generatePackageJson: true,
outDir: joinPaths("dist", options.projectRoot),
minify: !debug,
plugins: [],
assets: [],
dts: true,
shims: true,
silent: !debug,
logLevel: workspaceConfig.logLevel === "success" || workspaceConfig.logLevel === "debug" || workspaceConfig.logLevel === "trace" || workspaceConfig.logLevel === "all" ? "info" : workspaceConfig.logLevel === "fatal" ? "error" : workspaceConfig.logLevel,
sourcemap: debug ? "inline" : false,
clean: false,
fixedExtension: true,
nodeProtocol: true,
tsconfig: joinPaths(options.projectRoot, "tsconfig.json"),
debug,
sourceRoot,
cwd: workspaceConfig.workspaceRoot,
entry: {
["index"]: joinPaths(sourceRoot, "index.ts")
},
workspace: true,
...options,
treeshake: options.treeShaking !== false,
format: toTSDownFormat(options.format),
workspaceConfig,
projectName,
projectGraph,
projectConfigurations
};
result.env = defu2(
options.env,
getEnv("tsdown", result)
);
stopwatch();
return result;
};
async function generatePackageJson2(options) {
if (options.generatePackageJson !== false && existsSync8(joinPaths(options.projectRoot, "package.json"))) {
writeDebug(" \u270D\uFE0F Writing package.json file", options.workspaceConfig);
const stopwatch = getStopwatch("Write package.json file");
const packageJsonPath = joinPaths(options.projectRoot, "project.json");
if (!existsSync8(packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const packageJsonFile = await hf3.readFile(
joinPaths(
options.workspaceConfig.workspaceRoot,
options.projectRoot,
"package.json"
),
"utf8"
);
if (!packageJsonFile) {
throw new Error("Cannot find package.json configuration file");
}
let packageJson = JSON.parse(packageJsonFile);
packageJson = await addPackageDependencies(
options.workspaceConfig.workspaceRoot,
options.projectRoot,
options.projectName,
packageJson
);
packageJson = await addWorkspacePackageJsonFields(
options.workspaceConfig,
options.projectRoot,
options.sourceRoot,
options.projectName,
false,
packageJson
);
packageJson.exports ??= {};
packageJson.exports["./package.json"] ??= "./package.json";
packageJson.exports["."] ??= addPackageJsonExport(
"index",
packageJson.type,
options.sourceRoot
);
let entry = [{ in: "./src/index.ts", out: "./src/index.ts" }];
if (options.entry) {
if (Array.isArray(options.entry)) {
entry = options.entry.map(
(entryPoint) => typeof entryPoint === "string" ? { in: entryPoint, out: entryPoint } : entryPoint
);
}
for (const entryPoint of entry) {
const split = entryPoint.out.split(".");
split.pop();
const entry2 = split.join(".").replaceAll("\\", "/");
packageJson.exports[`./${entry2}`] ??= addPackageJsonExport(
entry2,
options.fixedExtension ? "fixed" : packageJson.type,
options.sourceRoot
);
}
}
packageJson.main = !options.fixedExtension && packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
packageJson.module = !options.fixedExtension && packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
packageJson.types = `./dist/index.d.${!options.fixedExtension ? "ts" : "mts"}`;
packageJson.exports = Object.keys(packageJson.exports).reduce(
(ret, key) => {
if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
ret[key.replace("/index", "")] = packageJson.exports[key];
}
return ret;
},
packageJson.exports
);
await writeJsonFile2(joinPaths(options.outDir, "package.json"), packageJson);
stopwatch();
}
return options;
}
async function executeTSDown(options) {
writeDebug(` \u{1F680} Running ${options.name} build`, options.workspaceConfig);
const stopwatch = getStopwatch(`${options.name} build`);
await tsdown({
...options,
entry: options.entry,
config: false
});
stopwatch();
return options;
}
async function copyBuildAssets2(options) {
writeDebug(
` \u{1F4CB} Copying asset files to output directory: ${options.outDir}`,
options.workspaceConfig
);
const stopwatch = getStopwatch(`${options.name} asset copy`);
await copyAssets(
options.workspaceConfig,
options.assets ?? [],
options.outDir,
options.projectRoot,
options.sourceRoot,
true,
false
);
stopwatch();
return options;
}
async function reportResults2(options) {
writeSuccess(
` \u{1F4E6} The ${options.name} build completed successfully`,
options.workspaceConfig
);
}
async function cleanOutputPath2(options) {
if (options.clean !== false && options.workspaceConfig) {
writeDebug(
` \u{1F9F9} Cleaning ${options.name} output path: ${options.workspaceConfig}`,
options.workspaceConfig
);
const stopwatch = getStopwatch(`${options.name} output clean`);
await cleanDirectories2(
options.name,
options.outDir,
options.workspaceConfig
);
stopwatch();
}
return options;
}
async function build3(options) {
writeDebug(` \u26A1 Executing Storm TSDown pipeline`);
const stopwatch = getStopwatch("TSDown pipeline");
try {
const opts = Array.isArray(options) ? options : [options];
if (opts.length === 0) {
throw new Error("No build options were provided");
}
const resolved = await Promise.all(
opts.map(async (opt) => await resolveOptions(opt))
);
if (resolved.length > 0) {
await cleanOutputPath2(resolved[0]);
await generatePackageJson2(resolved[0]);
await Promise.all(
resolved.map(async (opt) => {
await executeTSDown(opt);
await copyBuildAssets2(opt);
await reportResults2(opt);
})
);
} else {
writeWarning(
" \u{1F6A7} No options were passed to TSBuild. Please check the parameters passed to the `build` function."
);
}
writeSuccess(" \u{1F3C1} TSDown pipeline build completed successfully");
} catch (error) {
writeFatal(
"Fatal errors that the build process could not recover from have occured. The build process has been terminated."
);
throw error;
} finally {
stopwatch();
}
}
// ../workspace-tools/src/executors/tsdown/executor.ts
async function tsdownExecutorFn(options, context, config) {
writeInfo("\u{1F4E6} Running Storm TSDown executor on the workspace", config);
if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
throw new Error(
"The Build process failed because the context is not valid. Please run this command from a workspace."
);
}
await build3({
...options,
projectRoot: (
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
context.projectsConfigurations.projects?.[context.projectName].root
),
name: context.projectName,
sourceRoot: context.projectsConfigurations.projects?.[context.projectName]?.sourceRoot,
format: options.format,
platform: options.platform
});
return {
success: true
};
}
var executor_default9 = withRunExecutor(
"Storm TSDown build",
tsdownExecutorFn,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: async (options) => {
options.entry ??= ["src/index.ts"];
options.outputPath ??= "dist/{projectRoot}";
options.tsconfig ??= "{projectRoot}/tsconfig.json";
return options;
}
}
}
);
// ../workspace-tools/src/executors/typia/executor.ts
import { removeSync } from "fs-extra";
import { TypiaProgrammer } from "typia/lib/programmers/TypiaProgrammer.js";
async function typiaExecutorFn(options, _, config) {
if (options.clean !== false) {
writeInfo(`\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
removeSync(options.outputPath);
}
await Promise.all(
options.entry.map((entry) => {
writeInfo(`\u{1F680} Running Typia on entry: ${entry}`, config);
return TypiaProgrammer.build({
input: entry,
output: options.outputPath,
project: options.tsconfig
});
})
);
return {
success: true
};
}
var executor_default10 = withRunExecutor(
"Typia runtime validation generator",
typiaExecutorFn,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: (options) => {
options.entry ??= ["{sourceRoot}/index.ts"];
options.outputPath ??= "{sourceRoot}/__generated__/typia";
options.tsconfig ??= "{projectRoot}/tsconfig.json";
options.clean ??= true;
return options;
}
}
}
);
// ../workspace-tools/src/executors/unbuild/executor.ts
import { defu as defu3 } from "defu";
import { createJiti as createJiti2 } from "jiti";
async function unbuildExecutorFn(options, context, config) {
writeInfo("\u{1F4E6} Running Storm Unbuild executor on the workspace", config);
if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName]) {
throw new Error(
"The Build process failed because the context is not valid. Please run this command from a workspace root directory."
);
}
if (!context.projectsConfigurations.projects[context.projectName].root) {
throw new Error(
"The Build process failed because the project root is not valid. Please run this command from a workspace root directory."
);
}
if (!context.projectsConfigurations.projects[context.projectName].sourceRoot) {
throw new Error(
"The Build process failed because the project's source root is not valid. Please run this command from a workspace root directory."
);
}
const jiti = createJiti2(config.workspaceRoot, {
fsCache: config.skipCache ? false : joinPaths(
config.workspaceRoot,
config.directories.cache || "node_modules/.cache/storm",
"jiti"
),
interopDefault: true
});
const stormUnbuild = await jiti.import(
jiti.esmResolve("@storm-software/unbuild/build")
);
await stormUnbuild.build(
defu3(
{
...options,
projectRoot: context.projectsConfigurations.projects[context.projectName].root,
projectName: context.projectName,
sourceRoot: context.projectsConfigurations.projects[context.projectName].sourceRoot,
platform: options.platform
},
{
stubOptions: {
jiti: {
fsCache: config.skipCache ? false : joinPaths(
config.workspaceRoot,
config.directories.cache || "node_modules/.cache/storm",
"jiti"
)
}
},
rollup: {
emitCJS: true,
watch: false,
dts: {
respectExternal: true
},
esbuild: {
target: options.target,
format: "esm",
platform: options.platform,
minify: options.minify ?? !options.debug,
sourcemap: options.sourcemap ?? options.debug,
treeShaking: options.treeShaking
}
}
}
)
);
return {
success: true
};
}
var executor_default11 = withRunExecutor(
"TypeScript Unbuild build",
unbuildExecutorFn,
{
skipReadingConfig: false,
hooks: {
applyDefaultOptions: async (options, config) => {
options.debug ??= false;
options.treeShaking ??= true;
options.buildOnly ??= false;
options.platform ??= "neutral";
options.entry ??= ["{sourceRoot}"];
options.tsconfig ??= "{projectRoot}/tsconfig.json";
return options;
}
}
}
);
// ../workspace-tools/src/generators/browser-library/generator.ts
import {
formatFiles as formatFiles2,
generateFiles,
names as names2,
offsetFromRoot as offsetFromRoot2
} from "@nx/devkit";
// ../workspace-tools/src/base/base-generator.ts
var withRunGenerator = (name, generatorFn, generatorOptions = {
skipReadingConfig: false
}) => async (tree, _options) => {
const stopwatch = getStopwatch(name);
let options = _options;
let config;
try {
writeInfo(`\u26A1 Running the ${name} generator...
`, config);
const workspaceRoot2 = findWorkspaceRoot();
if (!generatorOptions.skipReadingConfig) {
writeDebug(
`Loading the Storm Config from environment variables and storm.config.js file...
- workspaceRoot: ${workspaceRoot2}`,
config
);
config = await getConfig(workspaceRoot2);
}
if (generatorOptions?.hooks?.applyDefaultOptions) {
writeDebug("Running the applyDefaultOptions hook...", config);
options = await Promise.resolve(
generatorOptions.hooks.applyDefaultOptions(options, config)
);
writeDebug("Completed the applyDefaultOptions hook", config);
}
writeTrace(
`Generator schema options \u2699\uFE0F
${Object.keys(options ?? {}).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`,
config
);
const tokenized = await applyWorkspaceTokens(
options,
{ workspaceRoot: tree.root, config },
applyWorkspaceBaseTokens
);
if (generatorOptions?.hooks?.preProcess) {
writeDebug("Running the preProcess hook...", config);
await Promise.resolve(
generatorOptions.hooks.preProcess(tokenized, config)
);
writeDebug("Completed the preProcess hook", config);
}
const result = await Promise.resolve(
generatorFn(tree, tokenized, config)
);
if (result) {
if (result.success === false || result.error && result?.error?.message && typeof result?.error?.message === "string" && result?.error?.name && typeof result?.error?.name === "string") {
throw new Error(`The ${name} generator failed to run`, {
cause: result?.error
});
} else if (result.success && result.data) {
return result;
}
}
if (generatorOptions?.hooks?.postProcess) {
writeDebug("Running the postProcess hook...", config);
await Promise.resolve(generatorOptions.hooks.postProcess(config));
writeDebug("Completed the postProcess hook", config);
}
return () => {
writeSuccess(`Completed running the ${name} generator!
`, config);
};
} catch (error) {
return () => {
writeFatal(
"A fatal error occurred while running the generator - the process was forced to terminate",
config
);
writeError(
`An exception was thrown in the generator's process
- Details: ${error.message}
- Stacktrace: ${error.stack}`,
config
);
};
} finally {
stopwatch();
}
};
// ../workspace-tools/src/base/typescript-library-generator.ts
import {
addDependenciesToPackageJson,
addProjectConfiguration,
ensurePackage,
formatFiles,
names,
offsetFromRoot,
readJson,
updateJson,
writeJson
} from "@nx/devkit";
import { determineProjectNameAndRootOptions } from "@nx/devkit/src/generators/project-name-and-root-utils";
import {
addTsConfigPath,
getRelativePathToRootTsConfig,
tsConfigBaseOptions
} from "@nx/js";
import jsInitGenerator from "@nx/js/src/generators/init/init";
import setupVerdaccio from "@nx/js/src/generators/setup-verdaccio/generator";
// ../workspace-tools/src/utils/versions.ts
var typesNodeVersion = "20.9.0";
var nxVersion = "^18.0.4";
var nodeVersion = "20.11.0";
var pnpmVersion = "8.10.2";
// ../workspace-tools/src/base/typescript-library-generator.ts
async function typeScriptLibraryGeneratorFn(tree, options, config) {
const normalized = await normalizeOptions(tree, { ...options });
const tasks = [];
tasks.push(
await jsInitGenerator(tree, {
...normalized,
tsConfigName: normalized.rootProject ? "tsconfig.json" : "tsconfig.base.json"
})
);
tasks.push(
addDependenciesToPackageJson(
tree,
{},
{
"@storm-software/workspace-tools": "latest",
"@storm-software/testing-tools": "latest",
...options.devDependencies ?? {}
}
)
);
if (normalized.publishable) {
tasks.push(await setupVerdaccio(tree, { ...normalized, skipFormat: true }));
}
const projectConfig = {
root: normalized.directory,
projectType: "library",
sourceRoot: joinPaths(normalized.directory ?? "", "src"),
targets: {
build: {
executor: options.buildExecutor,
outputs: ["{options.outputPath}"],
options: {
entry: [joinPaths(normalized.projectRoot, "src", "index.ts")],
outputPath: getOutputPath(normalized),
tsconfig: joinPaths(normalized.projectRoot, "tsconfig.json"),
project: joinPaths(normalized.projectRoot, "package.json"),
defaultConfiguration: "production",
platform: "neutral",
assets: [
{
input: normalized.projectRoot,
glob: "*.md",
output: "/"
},
{
input: "",
glob: "LICENSE",
output: "/"
}
]
},
configurations: {
production: {
debug: false,
verbose: false
},
development: {
debug: true,
verbose: true
}
}
}
}
};
if (options.platform) {
projectConfig.targets.build.options.platform = options.platform === "worker" ? "node" : options.platform;
}
addProjectTag(
projectConfig,
ProjectTagConstants.Platform.TAG_ID,
options.platform === "node" ? ProjectTagConstants.Platform.NODE : options.platform === "worker" ? ProjectTagConstants.Platform.WORKER : options.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL,
{ overwrite: false }
);
createProjectTsConfigJson(tree, normalized);
addProjectConfiguration(tree, normalized.name, projectConfig);
let repository = {
type: "github",
url: config?.repository || `https://github.com/${(typeof config?.organization === "string" ? config?.organization : config?.organization?.name) || "storm-software"}/${config?.namespace || config?.name || "repository"}.git`
};
let description = options.description || "A package developed by Storm Software used to create modern, scalable web applications.";
if (tree.exists("package.json")) {
const packageJson = readJson(tree, "package.json");
if (packageJson?.repository) {
repository = packageJson.repository;
}
if (packageJson?.description) {
description = packageJson.description;
}
}
if (!normalized.importPath) {
normalized.importPath = normalized.name;
}
const packageJsonPath = joinPaths(normalized.projectRoot, "package.json");
if (tree.exists(packageJsonPath)) {
updateJson(tree, packageJsonPath, (json) => {
if (!normalized.importPath) {
normalized.importPath = normalized.name;
}
json.name = normalized.importPath;
json.version = "0.0.1";
if (json.private && (normalized.publishable || normalized.rootProject)) {
json.private = void 0;
}
return {
...json,
version: "0.0.1",
description,
repository: {
...repository,
directory: normalized.projectRoot
},
type: "module",
dependencies: {
...json.dependencies
},
publishConfig: {
access: "public"
}
};
});
} else {
writeJson(tree, packageJsonPath, {
name: normalized.importPath,
version: "0.0.1",
description,
repository: {
...repository,
directory: normalized.projectRoot
},
private: !normalized.publishable || normalized.rootProject,
type: "module",
publishConfig: {
access: "public"
}
});
}
if (tree.exists("package.json") && normalized.importPath) {
updateJson(tree, "package.json", (json) => ({
...json,
pnpm: {
...json?.pnpm,
overrides: {
...json?.pnpm?.overrides,
[normalized.importPath ?? ""]: "workspace:*"
}
}
}));
}
addTsConfigPath(tree, normalized.importPath, [
joinPaths(
normalized.projectRoot,
"./src",
`index.${normalized.js ? "js" : "ts"}`
)
]);
addTsConfigPath(tree, joinPaths(normalized.importPath, "/*"), [
joinPaths(normalized.projectRoot, "./src", "/*")
]);
if (tree.exists("package.json")) {
const packageJson = readJson(tree, "package.json");
if (packageJson?.repository) {
repository = packageJson.repository;
}
if (packageJson?.description) {
description = packageJson.description;
}
}
const tsconfigPath = joinPaths(normalized.projectRoot, "tsconfig.json");
if (tree.exists(tsconfigPath)) {
updateJson(tree, tsconfigPath, (json) => {
json.composite ??= true;
return json;
});
} else {
writeJson(tree, tsconfigPath, {
extends: `${offsetFromRoot(normalized.projectRoot)}tsconfig.base.json`,
composite: true,
compilerOptions: {
outDir: `${offsetFromRoot(normalized.projectRoot)}dist/out-tsc`
},
files: [],
include: ["src/**/*.ts", "src/**/*.js"],
exclude: ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
});
}
await formatFiles(tree);
return null;
}
function getOutputPath(options) {
const parts = ["dist"];
if (options.projectRoot === ".") {
parts.push(options.name);
} else {
parts.push(options.projectRoot);
}
return joinPaths(...parts);
}
function createProjectTsConfigJson(tree, options) {
const tsconfig = {
extends: options.rootProject ? void 0 : getRelativePathToRootTsConfig(tree, options.projectRoot),
...options?.tsconfigOptions ?? {},
compilerOptions: {
...options.rootProject ? tsConfigBaseOptions : {},
outDir: joinPaths(offsetFromRoot(options.projectRoot), "dist/out-tsc"),
noEmit: true,
...options?.tsconfigOptions?.compilerOptions ?? {}
},
files: [...options?.tsconfigOptions?.files ?? []],
include: [
...options?.tsconfigOptions?.include ?? [],
"src/**/*.ts",
"src/**/*.js",
"bin/**/*"
],
exclude: [
...options?.tsconfigOptions?.exclude ?? [],
"jest.config.ts",
"src/**/*.spec.ts",
"src/**/*.test.ts"
]
};
writeJson(tree, joinPaths(options.projectRoot, "tsconfig.json"), tsconfig);
}
async function normalizeOptions(tree, options, config) {
let importPath = options.importPath;
if (!importPath && config?.namespace) {
importPath = `@${config?.namespace}/${options.name}`;
}
if (options.publishable) {
if (!importPath) {
throw new Error(
`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`
);
}
}
let bundler = "tsc";
if (options.publishable === false && options.buildable === false) {
bundler = "none";
}
const { Linter } = ensurePackage("@nx/eslint", nxVersion);
const rootProject = false;
const {
projectName,
names: projectNames,
projectRoot,
importPath: normalizedImportPath
} = await determineProjectNameAndRootOptions(tree, {
name: options.name,
projectType: "library",
directory: options.directory,
importPath,
rootProject
});
const normalized = names(projectNames.projectFileName);
const fileName = normalized.fileName;
return {
js: false,
pascalCaseFiles: false,
skipFormat: false,
skipTsConfig: false,
includeBabelRc: false,
unitTestRunner: "jest",
linter: Linter.EsLint,
testEnvironment: "node",
config: "project",
compiler: "tsc",
bundler,
skipTypeCheck: false,
minimal: false,
hasPlugin: false,
isUsingTsSolutionConfig: false,
projectPackageManagerWorkspaceState: "included",
...options,
fileName,
name: projectName,
projectNames,
projectRoot,
parsedTags: options.tags ? options.tags.split(",").map((s) => s.trim()) : [],
importPath: normalizedImportPath,
rootProject,
shouldUseSwcJest: false
};
}
// ../workspace-tools/src/generators/browser-library/generator.ts
async function browserLibraryGeneratorFn(tree, schema, config) {
const filesDir = joinPaths(
__dirname,
"src",
"generators",
"browser-library",
"files"
);
const tsLibraryGeneratorOptions = {
buildExecutor: "@storm-software/workspace-tools:unbuild",
platform: "browser",
devDependencies: {
"@types/react": "^18.3.6",
"@types/react-dom": "^18.3.0"
},
peerDependencies: {
react: "^18.3.0",
"react-dom": "^18.3.0",
"react-native": "*"
},
peerDependenciesMeta: {
"react-dom": {
optional: true
},
"react-native": {
optional: true
}
},
...schema,
description: schema.description,
directory: schema.directory
};
const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
const { className, name, propertyName } = names2(
options.projectNames.projectFileName
);
generateFiles(tree, filesDir, options.projectRoot, {
...schema,
dot: ".",
className,
name,
namespace: process.env.STORM_NAMESPACE ?? "storm-software",
description: schema.description ?? "",
propertyName,
js: !!options.js,
cliCommand: "nx",
strict: void 0,
tmpl: "",
offsetFromRoot: offsetFromRoot2(options.projectRoot),
buildable: options.bundler && options.bundler !== "none",
hasUnitTestRunner: options.unitTestRunner !== "none",
tsConfigOptions: {
compilerOptions: {
jsx: "react",
types: [
"node",
"@nx/react/typings/cssmodule.d.ts",
"@nx/react/typings/image.d.ts"
]
}
}
});
await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
await formatFiles2(tree);
return null;
}
var generator_default = withRunGenerator(
"TypeScript Library Creator (Browser Platform)",
browserLibraryGeneratorFn,
{
hooks: {
applyDefaultOptions: (options) => {
options.description ??= "A library used by Storm Software to support browser applications";
options.platform ??= "browser";
return options;
}
}
}
);
// ../workspace-tools/src/generators/config-schema/generator.ts
import { formatFiles as formatFiles3, writeJson as writeJson2 } from "@nx/devkit";
import * as z from "zod";
async function configSchemaGeneratorFn(tree, options, config) {
writeInfo(
"\u{1F4E6} Running Storm Workspace Configuration JSON Schema generator",
config
);
writeTrace(
`Determining the Storm Workspace Configuration JSON Schema...`,
config
);
const jsonSchema = z.toJSONSchema(workspaceConfigSchema, {
target: "draft-7",
metadata: schemaRegistry
});
jsonSchema.$id ??= "https://public.storm-cdn.com/schemas/storm-workspace.schema.json";
jsonSchema.title ??= "Storm Workspace Configuration JSON Schema";
jsonSchema.description ??= "This JSON Schema defines the structure of the Storm Workspace configuration file (`storm-workspace.json`). It is used to validate the configuration file and ensure that it adheres to the expected format.";
writeTrace(jsonSchema, config);
if (!options.outputFile) {
throw new Error(
"The `outputFile` option is required. Please specify the output file path."
);
}
const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(
config?.workspaceRoot ?? findWorkspaceRoot(),
options.outputFile.startsWith("./") ? "" : "./"
);
writeTrace(
`\u{1F4DD} Writing Storm Configuration JSON Schema to "${outputPath}"`,
config
);
writeJson2(tree, outputPath, jsonSchema, { spaces: 2 });
await formatFiles3(tree);
writeSuccess(
"\u{1F680} Storm Configuration JSON Schema creation has completed successfully!",
config
);
return {
success: true
};
}
var generator_default2 = withRunGenerator(
"Configuration Schema Creator",
configSchemaGeneratorFn,
{
hooks: {
applyDefaultOptions: (options) => {
options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
return options;
}
}
}
);
// ../workspace-tools/src/generators/init/init.ts
import {
addDependenciesToPackageJson as addDependenciesToPackageJson2,
formatFiles as formatFiles4
} from "@nx/devkit";
async function initGenerator(tree, schema) {
const task = addDependenciesToPackageJson2(
tree,
{
nx: "^19.6.2",
"@nx/workspace": "^19.6.2",
"@nx/js": "^19.6.2",
"@storm-software/eslint": "latest",
"@storm-software/prettier": "latest",
"@storm-software/config-tools": "latest",
"@storm-software/testing-tools": "latest",
"@storm-software/git-tools": "latest",
"@storm-software/linting-tools": "latest"
},
{}
);
if (!schema.skipFormat) {
await formatFiles4(tree);
}
return task;
}
// ../workspace-tools/src/generators/neutral-library/generator.ts
import {
formatFiles as formatFiles5,
generateFiles as generateFiles2,
names as names3,
offsetFromRoot as offsetFromRoot3
} from "@nx/devkit";
async function neutralLibraryGeneratorFn(tree, schema, config) {
const filesDir = joinPaths(
__dirname,
"src",
"generators",
"neutral-library",
"files"
);
const tsLibraryGeneratorOptions = {
...schema,
platform: "neutral",
devDependencies: {},
buildExecutor: "@storm-software/workspace-tools:unbuild"
};
const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
const { className, name, propertyName } = names3(
options.projectNames.projectFileName
);
generateFiles2(tree, filesDir, options.projectRoot, {
...schema,
dot: ".",
className,
name,
namespace: process.env.STORM_NAMESPACE ?? "storm-software",
description: schema.description ?? "",
propertyName,
js: !!options.js,
cliCommand: "nx",
strict: void 0,
tmpl: "",
offsetFromRoot: offsetFromRoot3(options.projectRoot),
buildable: options.bundler && options.bundler !== "none",
hasUnitTestRunner: options.unitTestRunner !== "none"
});
await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
await formatFiles5(tree);
return null;
}
var generator_default3 = withRunGenerator(
"TypeScript Library Creator (Neutral Platform)",
neutralLibraryGeneratorFn,
{
hooks: {
applyDefaultOptions: (options) => {
options.description ??= "A library used by Storm Software to support either browser or NodeJs applications";
options.platform = "neutral";
return options;
}
}
}
);
// ../workspace-tools/src/generators/node-library/generator.ts
import {
formatFiles as formatFiles6,
generateFiles as generateFiles3,
names as names4,
offsetFromRoot as offsetFromRoot4
} from "@nx/devkit";
async function nodeLibraryGeneratorFn(tree, schema, config) {
const filesDir = joinPaths(
__dirname,
"src",
"generators",
"node-library",
"files"
);
const tsLibraryGeneratorOptions = {
platform: "node",
devDependencies: {
"@types/node": typesNodeVersion
},
buildExecutor: "@storm-software/workspace-tools:unbuild",
...schema,
directory: schema.directory,
description: schema.description
};
const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
const { className, name, propertyName } = names4(options.name);
generateFiles3(tree, filesDir, options.projectRoot, {
...schema,
dot: ".",
className,
name,
namespace: process.env.STORM_NAMESPACE ?? "storm-software",
description: schema.description ?? "",
propertyName,
js: !!options.js,
cliCommand: "nx",
strict: void 0,
tmpl: "",
offsetFromRoot: offsetFromRoot4(options.projectRoot),
buildable: options.bundler && options.bundler !== "none",
hasUnitTestRunner: options.unitTestRunner !== "none"
});
await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
await formatFiles6(tree);
return null;
}
var generator_default4 = withRunGenerator(
"TypeScript Library Creator (NodeJs Platform)",
nodeLibraryGeneratorFn,
{
hooks: {
applyDefaultOptions: (options) => {
options.description ??= "A library used by Storm Software to support NodeJs applications";
options.platform ??= "node";
return options;
}
}
}
);
// ../workspace-tools/src/generators/preset/generator.ts
import {
addDependenciesToPackageJson as addDependenciesToPackageJson3,
addProjectConfiguration as addProjectConfiguration2,
formatFiles as formatFiles7,
generateFiles as generateFiles4,
joinPathFragments as joinPathFragments5,
updateJson as updateJson2
} from "@nx/devkit";
import * as path2 from "node:path";
async function presetGeneratorFn(tree, options) {
const projectRoot = ".";
options.description ??= `\u26A1The ${options.namespace ? options.namespace : options.name} monorepo contains utility applications, tools, and various libraries to create modern and scalable web applications.`;
options.namespace ??= options.organization;
addProjectConfiguration2(tree, `@${options.namespace}/${options.name}`, {
root: projectRoot,
projectType: "application",
targets: {
"local-registry": {
executor: "@nx/js:verdaccio",
options: {
port: 4873,
config: ".verdaccio/config.yml",
storage: "tmp/local-registry/storage"
}
}
}
});
updateJson2(tree, "package.json", (json) => {
json.scripts = json.scripts || {};
json.version = "0.0.0";
json.triggerEmptyDevReleaseByIncrementingThisNumber = 0;
json.private = true;
json.keywords ??= [
options.name,
options.namespace,
"storm",
"storm-stack",
"storm-ops",
"rust",
"nx",
"graphql",
"sullivanpj",
"monorepo"
];
json.homepage ??= "https://stormsoftware.com";
json.bugs ??= {
url: `https://github.com/${options.organization}/${options.name}/issues`,
email: "support@stormsoftware.com"
};
json.license = "Apache-2.0";
json.author ??= {
name: "Storm Software",
email: "contact@stormsoftware.com",
url: "https://stormsoftware.com"
};
json.maintainers ??= [
{
name: "Storm Software",
email: "contact@stormsoftware.com",
url: "https://stormsoftware.com"
},
{
name: "Pat Sullivan",
email: "admin@stormsoftware.com",
url: "https://patsullivan.org"
}
];
json.funding ??= {
type: "github",
url: "https://github.com/sponsors/storm-software"
};
json.namespace ??= `@${options.namespace}`;
json.description ??= options.description;
options.repositoryUrl ??= `https://github.com/${options.organization}/${options.name}`;
json.repository ??= {
type: "github",
url: `${options.repositoryUrl}.git`
};
json.packageManager ??= "pnpm@10.3.0";
json.engines ??= {
node: ">=20.11.0",
pnpm: ">=10.3.0"
};
json.prettier = "@storm-software/prettier/config.json";
json.nx ??= {
includedScripts: [
"lint-sherif",
"lint-knip",
"lint-ls",
"lint",
"format",
"format-sherif",
"format-readme",
"format-prettier",
"format-toml",
"commit",
"release"
]
};
json.scripts.adr = "pnpm log4brains adr new";
json.scripts["adr-preview"] = "pnpm log4brains preview";
json.scripts.prepare = "pnpm add lefthook -w && pnpm lefthook install";
json.scripts.preinstall = "npx -y only-allow pnpm";
json.scripts["install-csb"] = "corepack enable && pnpm install --no-frozen-lockfile";
json.scripts.clean = "rimraf dist && rimraf --glob packages/**/dist && rimraf --glob tools/**/dist && rimraf --glob docs/**/dist && rimraf --glob apps/**/dist && rimraf --glob libs/**/dist";
json.scripts.nuke = "nx clear-cache && rimraf .nx/cache && rimraf .nx/workspace-data && pnpm clean && rimraf pnpm-lock.yaml && rimraf --glob packages/**/node_modules && rimraf --glob tools/**/node_modules && rimraf node_modules";
json.scripts.prebuild = "pnpm clean";
json.scripts.build = "nx affected -t build --parallel=5";
json.scripts["build-all"] = "nx run-many -t build --all --parallel=5";
json.scripts["build-prod"] = "nx run-many -t build --all --prod --parallel=5";
json.scripts["build-tools"] = "nx run-many -t build --projects=tools/* --parallel=5";
json.scripts["build-docs"] = "nx run-many -t build --projects=docs/* --parallel=5";
if (!options.includeApps) {
json.scripts["build-packages"] = "nx run-many -t build --projects=packages/* --parallel=5";
} else {
json.scripts["build-apps"] = "nx run-many -t build --projects=apps/* --parallel=5";
json.scripts["build-libs"] = "nx run-many -t build --projects=libs/* --parallel=5";
json.scripts["build-storybook"] = "storybook build -s public";
}
json.scripts.nx = "nx";
json.scripts.graph = "nx graph";
json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
if (options.includeApps) {
json.scripts.start = "nx serve";
json.scripts.storybook = "pnpm storybook dev -p 6006";
}
json.scripts.help = "nx help";
json.scripts["dep-graph"] = "nx dep-graph";
json.scripts["local-registry"] = `nx local-registry @${options.namespace}/${options.name}`;
json.scripts.e2e = "nx e2e";
if (options.includeApps) {
json.scripts.test = "nx test && pnpm test-storybook";
json.scripts["test-storybook"] = "pnpm test-storybook";
} else {
json.scripts.test = "nx test";
}
json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
json.scripts.commit = "pnpm storm-git commit";
json.scripts["api-extractor"] = 'pnpm storm-docs api-extractor --outputPath="docs/api-reference" --clean';
json.scripts.release = "pnpm storm-git release";
json.scripts.format = "nx format:write";
json.scripts["format-sherif"] = "pnpm exec sherif -f -i typescript -i react -i react-dom";
json.scripts["format-toml"] = 'pnpm exec taplo format --config="./node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="./node_modules/.cache/storm/taplo"';
json.scripts["format-readme"] = 'pnpm storm-git readme --templates="tools/readme-templates"';
json.scripts["format-prettier"] = "pnpm exec prettier --write --ignore-unknown --no-error-on-unmatched-pattern --cache && git update-index";
json.scripts.lint = "pnpm storm-lint all --skip-cspell";
json.scripts["lint-knip"] = "pnpm exec knip";
json.scripts["lint-sherif"] = "pnpm exec sherif -i typescript -i react -i react-dom";
json.scripts["lint-ls"] = 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/ls-lint.yml"';
json.packageManager ??= `pnpm@${pnpmVersion}`;
json.engines = {
node: `>=${nodeVersion}`,
pnpm: `>=${pnpmVersion}`
};
return json;
});
generateFiles4(tree, path2.join(__dirname, "files"), projectRoot, {
...options,
pnpmVersion,
nodeVersion
});
await formatFiles7(tree);
let dependencies = {
"@ls-lint/ls-lint": "2.2.3",
"@ltd/j-toml": "1.38.0",
"@nx/devkit": "^20.2.2",
"@nx/eslint-plugin": "^20.2.2",
"@nx/js": "^20.2.2",
"@nx/workspace": "^20.2.2",
"@storm-software/config": "latest",
"@storm-software/git-tools": "latest",
"@storm-software/linting-tools": "latest",
"@storm-software/testing-tools": "latest",
"@storm-software/workspace-tools": "latest",
"@storm-software/eslint": "latest",
"@storm-software/cspell": "latest",
"@storm-software/prettier": "latest",
"@taplo/cli": "0.7.0",
"@types/node": "^20.14.10",
copyfiles: "2.4.1",
eslint: "9.5.0",
jest: "29.7.0",
"jest-environment-node": "29.7.0",
knip: "5.25.2",
lefthook: "1.6.18",
nx: "^20.2.2",
prettier: "3.3.2",
"prettier-plugin-prisma": "5.0.0",
rimraf: "5.0.7",
sherif: "0.10.0",
"ts-jest": "29.1.5",
"ts-node": "10.9.2",
tslib: "2.6.3",
typescript: "5.5.3",
verdaccio: "5.31.1"
};
if (options.includeApps) {
dependencies = {
...dependencies,
react: "latest",
"react-dom": "latest",
storybook: "latest",
"@storybook/addons": "latest",
"@nx/react": "latest",
"@nx/next": "latest",
"@nx/node": "latest",
"@nx/storybook": "latest",
"jest-environment-jsdom": "29.7.0"
};
}
if (options.includeRust) {
dependencies = {
...dependencies,
"@monodon/rust": "1.4.0"
};
}
if (options.nxCloud) {
dependencies = {
...dependencies,
"nx-cloud": "latest"
};
}
await Promise.resolve(
addDependenciesToPackageJson3(
tree,
dependencies,
{},
joinPathFragments5(projectRoot, "package.json")
)
);
return null;
}
var generator_default5 = withRunGenerator(
"Storm Workspace Preset Generator",
presetGeneratorFn
);
// ../workspace-tools/src/base/base-executor.untyped.ts
import { defineUntypedSchema } from "untyped";
var base_executor_untyped_default = defineUntypedSchema({
$schema: {
id: "baseExecutor",
title: "Base Executor",
description: "A base type definition for an executor schema"
},
outputPath: {
$schema: {
title: "Output Path",
type: "string",
format: "path",
description: "The output path for the build"
},
$default: "dist/{projectRoot}"
}
});
// ../workspace-tools/src/base/base-generator.untyped.ts
import { defineUntypedSchema as defineUntypedSchema2 } from "untyped";
var base_generator_untyped_default = defineUntypedSchema2({
$schema: {
id: "BaseGeneratorSchema",
title: "Base Generator",
description: "A type definition for the base Generator schema"
},
directory: {
$schema: {
title: "Directory",
type: "string",
description: "The directory to create the library in"
}
}
});
// ../workspace-tools/src/base/cargo-base-executor.untyped.ts
import { defineUntypedSchema as defineUntypedSchema3 } from "untyped";
var cargo_base_executor_untyped_default = defineUntypedSchema3({
...base_executor_untyped_default,
$schema: {
id: "cargoBaseExecutor",
title: "Cargo Base Executor",
description: "A base type definition for a Cargo/rust related executor schema"
},
package: {
$schema: {
title: "Cargo.toml Path",
type: "string",
format: "path",
description: "The path to the Cargo.toml file"
},
$default: "{projectRoot}/Cargo.toml"
},
toolchain: {
$schema: {
title: "Toolchain",
description: "The type of toolchain to use for the build",
enum: ["stable", "beta", "nightly"],
default: "stable"
},
$default: "stable"
},
target: {
$schema: {
title: "Target",
type: "string",
description: "The target to build"
}
},
allTargets: {
$schema: {
title: "All Targets",
type: "boolean",
description: "Build all targets"
}
},
profile: {
$schema: {
title: "Profile",
type: "string",
description: "The profile to build"
}
},
release: {
$schema: {
title: "Release",
type: "boolean",
description: "Build in release mode"
}
},
features: {
$schema: {
title: "Features",
type: "string",
description: "The features to build",
oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
}
},
allFeatures: {
$schema: {
title: "All Features",
type: "boolean",
description: "Build all features"
}
}
});
// ../workspace-tools/src/base/typescript-build-executor.untyped.ts
import { defineUntypedSchema as defineUntypedSchema4 } from "untyped";
var typescript_build_executor_untyped_default = defineUntypedSchema4({
...base_executor_untyped_default,
$schema: {
id: "TypeScriptBuildExecutorSchema",
title: "TypeScript Build Executor",
description: "A type definition for the base TypeScript build executor schema",
required: ["entry", "tsconfig"]
},
entry: {
$schema: {
title: "Entry File(s)",
format: "path",
type: "array",
description: "The entry file or files to build",
items: { type: "string" }
},
$default: ["{sourceRoot}/index.ts"]
},
tsconfig: {
$schema: {
title: "TSConfig Path",
type: "string",
format: "path",
description: "The path to the tsconfig file"
},
$default: "{projectRoot}/tsconfig.json"
},
bundle: {
$schema: {
title: "Bundle",
type: "boolean",
description: "Bundle the output"
}
},
minify: {
$schema: {
title: "Minify",
type: "boolean",
description: "Minify the output"
}
},
debug: {
$schema: {
title: "Debug",
type: "boolean",
description: "Debug the output"
}
},
sourcemap: {
$schema: {
title: "Sourcemap",
type: "boolean",
description: "Generate a sourcemap"
}
},
silent: {
$schema: {
title: "Silent",
type: "boolean",
description: "Should the build run silently - only report errors back to the user"
},
$default: false
},
target: {
$schema: {
title: "Target",
type: "string",
description: "The target to build",
enum: [
"es3",
"es5",
"es6",
"es2015",
"es2016",
"es2017",
"es2018",
"es2019",
"es2020",
"es2021",
"es2022",
"es2023",
"es2024",
"esnext",
"node12",
"node14",
"node16",
"node18",
"node20",
"node22",
"browser",
"chrome58",
"chrome59",
"chrome60"
]
},
$default: "esnext",
$resolve: (val = "esnext") => typeof val === "string" ? val.toLowerCase() : val
},
format: {
$schema: {
title: "Format",
type: "array",
description: "The format to build",
items: {
type: "string",
enum: ["cjs", "esm", "iife"]
}
},
$resolve: (val = ["cjs", "esm"]) => [].concat(val)
},
platform: {
$schema: {
title: "Platform",
type: "string",
description: "The platform to build",
enum: ["neutral", "node", "browser"]
},
$default: "neutral"
},
external: {
$schema: {
title: "External",
type: "array",
description: "The external dependencies"
},
$resolve: (val = []) => [].concat(val)
},
define: {
$schema: {
title: "Define",
type: "object",
tsType: "Record<string, string>",
description: "The define values"
},
$resolve: (val = {}) => val,
$default: {}
},
env: {
$schema: {
title: "Environment Variables",
type: "object",
tsType: "Record<string, string>",
description: "The environment variable values"
},
$resolve: (val = {}) => val,
$default: {}
}
});
// ../workspace-tools/src/base/typescript-library-generator.untyped.ts
import { defineUntypedSchema as defineUntypedSchema5 } from "untyped";
var typescript_library_generator_untyped_default = defineUntypedSchema5({
...base_generator_untyped_default,
$schema: {
id: "TypeScriptLibraryGeneratorSchema",
title: "TypeScript Library Generator",
description: "A type definition for the base TypeScript Library Generator schema",
required: ["directory", "name"]
},
name: {
$schema: {
title: "Name",
type: "string",
description: "The name of the library"
}
},
description: {
$schema: {
title: "Description",
type: "string",
description: "The description of the library"
}
},
buildExecutor: {
$schema: {
title: "Build Executor",
type: "string",
description: "The executor to use for building the library"
},
$default: "@storm-software/workspace-tools:unbuild"
},
platform: {
$schema: {
title: "Platform",
type: "string",
description: "The platform to target with the library",
enum: ["neutral", "node", "worker", "browser"]
},
$default: "neutral"
},
importPath: {
$schema: {
title: "Import Path",
type: "string",
description: "The import path for the library"
}
},
tags: {
$schema: {
title: "Tags",
type: "string",
description: "The tags for the library"
}
},
unitTestRunner: {
$schema: {
title: "Unit Test Runner",
type: "string",
enum: ["jest", "vitest", "none"],
description: "The unit test runner to use"
}
},
testEnvironment: {
$schema: {
title: "Test Environment",
type: "string",
enum: ["jsdom", "node"],
description: "The test environment to use"
}
},
pascalCaseFiles: {
$schema: {
title: "Pascal Case Files",
type: "boolean",
description: "Use PascalCase for file names"
},
$default: false
},
strict: {
$schema: {
title: "Strict",
type: "boolean",
description: "Enable strict mode"
},
$default: true
},
publishable: {
$schema: {
title: "Publishable",
type: "boolean",
description: "Make the library publishable"
},
$default: false
},
buildable: {
$schema: {
title: "Buildable",
type: "boolean",
description: "Make the library buildable"
},
$default: true
}
});
// ../workspace-tools/src/release/js-version-actions.ts
import JsVersionActions from "@nx/js/src/release/version-actions.js";
// ../workspace-tools/src/release/rust-version-actions.ts
import {
joinPathFragments as joinPathFragments6
} from "@nx/devkit";
import { VersionActions } from "nx/release";
// ../workspace-tools/src/utils/registry-helpers.ts
import https2 from "node:https";
// ../workspace-tools/src/utils/create-cli-options.ts
import { names as names5 } from "@nx/devkit";
// ../workspace-tools/src/utils/get-project-configurations.ts
import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";
// ../workspace-tools/src/utils/lock-file.ts
import {
output,
readJsonFile as readJsonFile2,
workspaceRoot
} from "@nx/devkit";
import { existsSync as existsSync9 } from "node:fs";
import { join as join2 } from "node:path";
import {
getNpmLockfileDependencies,
getNpmLockfileNodes
} from "nx/src/plugins/js/lock-file/npm-parser";
import {
getPnpmLockfileDependencies,
getPnpmLockfileNodes
} from "nx/src/plugins/js/lock-file/pnpm-parser";
import {
getYarnLockfileDependencies,
getYarnLockfileNodes
} from "nx/src/plugins/js/lock-file/yarn-parser";
var YARN_LOCK_FILE = "yarn.lock";
var NPM_LOCK_FILE = "package-lock.json";
var PNPM_LOCK_FILE = "pnpm-lock.yaml";
var YARN_LOCK_PATH = join2(workspaceRoot, YARN_LOCK_FILE);
var NPM_LOCK_PATH = join2(workspaceRoot, NPM_LOCK_FILE);
var PNPM_LOCK_PATH = join2(workspaceRoot, PNPM_LOCK_FILE);
// ../workspace-tools/src/utils/plugin-helpers.ts
import {
readJsonFile as readJsonFile3
} from "@nx/devkit";
import defu4 from "defu";
import { existsSync as existsSync10 } from "node:fs";
import { dirname as dirname2, join as join3 } from "node:path";
// ../workspace-tools/src/utils/typia-transform.ts
import transform2 from "typia/lib/transform";
// src/generators/init/init.ts
async function initGenerator2(tree, schema) {
const task = initGenerator(tree, { skipFormat: !!schema.skipFormat });
if (!schema.skipFormat) {
await formatFiles8(tree);
}
return task;
}
var init_default = initGenerator2;
export {
initGenerator2 as initGenerator,
init_default
};