@storm-software/cloudflare-tools
Version:
A Nx plugin package that contains various executors, generators, and utilities that assist in managing Cloudflare services.
1,314 lines (1,215 loc) • 111 kB
JavaScript
"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
var _chunkXKQ3HGETjs = require('./chunk-XKQ3HGET.js');
var _chunkWROOA5AXjs = require('./chunk-WROOA5AX.js');
var _chunkOZPXCCZBjs = require('./chunk-OZPXCCZB.js');
// ../config-tools/src/utilities/apply-workspace-tokens.ts
var applyWorkspaceBaseTokens = async (option, tokenParams) => {
let result = option;
if (!result) {
return result;
}
if (tokenParams) {
const optionKeys = Object.keys(tokenParams);
if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
for (const optionKey of optionKeys) {
if (result.includes(`{${optionKey}}`)) {
result = result.replaceAll(
`{${optionKey}}`,
_optionalChain([tokenParams, 'optionalAccess', _2 => _2[optionKey]]) || ""
);
}
}
}
}
if (tokenParams.config) {
const configKeys = Object.keys(tokenParams.config);
if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
for (const configKey of configKeys) {
if (result.includes(`{${configKey}}`)) {
result = result.replaceAll(
`{${configKey}}`,
tokenParams.config[configKey] || ""
);
}
}
}
}
if (result.includes("{workspaceRoot}")) {
result = result.replaceAll(
"{workspaceRoot}",
_nullishCoalesce(_nullishCoalesce(tokenParams.workspaceRoot, () => ( _optionalChain([tokenParams, 'access', _3 => _3.config, 'optionalAccess', _4 => _4.workspaceRoot]))), () => ( _chunkWROOA5AXjs.findWorkspaceRoot.call(void 0, )))
);
}
return result;
};
var applyWorkspaceProjectTokens = (option, tokenParams) => {
return applyWorkspaceBaseTokens(option, tokenParams);
};
var applyWorkspaceTokens = async (options, tokenParams, tokenizerFn) => {
if (!options) {
return {};
}
const result = {};
for (const option of Object.keys(options)) {
if (typeof options[option] === "string") {
result[option] = await Promise.resolve(
tokenizerFn(options[option], tokenParams)
);
} else if (Array.isArray(options[option])) {
result[option] = await Promise.all(
options[option].map(
async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, tokenParams)) : item
)
);
} else if (typeof options[option] === "object") {
result[option] = await applyWorkspaceTokens(
options[option],
tokenParams,
tokenizerFn
);
} else {
result[option] = options[option];
}
}
return result;
};
// ../workspace-tools/src/base/base-executor.ts
var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
var withRunExecutor = (name, executorFn, executorOptions = {}) => async (_options, context) => {
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, name);
let options = _options;
let config = {};
try {
if (!_optionalChain([context, 'access', _5 => _5.projectsConfigurations, 'optionalAccess', _6 => _6.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."
);
}
const workspaceRoot2 = _chunkWROOA5AXjs.findWorkspaceRoot.call(void 0, );
const projectRoot = context.projectsConfigurations.projects[context.projectName].root || workspaceRoot2;
const sourceRoot = context.projectsConfigurations.projects[context.projectName].sourceRoot || projectRoot || workspaceRoot2;
const projectName = context.projectName;
config.workspaceRoot = workspaceRoot2;
_chunkOZPXCCZBjs.writeInfo.call(void 0,
`${_chunkOZPXCCZBjs.brandIcon.call(void 0, config)} Running the ${name} executor for ${projectName} `,
config
);
if (!executorOptions.skipReadingConfig) {
_chunkOZPXCCZBjs.writeTrace.call(void 0,
`Loading the Storm Config from environment variables and storm.config.js file...
- workspaceRoot: ${workspaceRoot2}
- projectRoot: ${projectRoot}
- sourceRoot: ${sourceRoot}
- projectName: ${projectName}
`,
config
);
config = await _chunkWROOA5AXjs.getConfig.call(void 0, workspaceRoot2);
}
if (_optionalChain([executorOptions, 'optionalAccess', _7 => _7.hooks, 'optionalAccess', _8 => _8.applyDefaultOptions])) {
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
options = await Promise.resolve(
executorOptions.hooks.applyDefaultOptions(options, config)
);
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
}
_chunkOZPXCCZBjs.writeTrace.call(void 0,
`Executor schema options \u2699\uFE0F
${_chunkOZPXCCZBjs.formatLogMessage.call(void 0, options)}
`,
config
);
const tokenized = await applyWorkspaceTokens(
options,
_defu.defu.call(void 0,
{ workspaceRoot: workspaceRoot2, projectRoot, sourceRoot, projectName, config },
config,
context.projectsConfigurations.projects[context.projectName]
),
applyWorkspaceProjectTokens
);
_chunkOZPXCCZBjs.writeTrace.call(void 0,
`Executor schema tokenized options \u2699\uFE0F
${_chunkOZPXCCZBjs.formatLogMessage.call(void 0, tokenized)}
`,
config
);
if (_optionalChain([executorOptions, 'optionalAccess', _9 => _9.hooks, 'optionalAccess', _10 => _10.preProcess])) {
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
await Promise.resolve(
executorOptions.hooks.preProcess(tokenized, config)
);
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
}
const ret = executorFn(tokenized, context, config);
if (_isFunction(_optionalChain([ret, 'optionalAccess', _11 => _11.next]))) {
const asyncGen = ret;
for await (const iter of asyncGen) {
void iter;
}
}
const result = await Promise.resolve(
ret
);
if (result && (!result.success || result.error && _optionalChain([result, 'optionalAccess', _12 => _12.error, 'optionalAccess', _13 => _13.message]) && typeof _optionalChain([result, 'optionalAccess', _14 => _14.error, 'optionalAccess', _15 => _15.message]) === "string" && _optionalChain([result, 'optionalAccess', _16 => _16.error, 'optionalAccess', _17 => _17.name]) && typeof _optionalChain([result, 'optionalAccess', _18 => _18.error, 'optionalAccess', _19 => _19.name]) === "string")) {
throw new Error(
`Failure determined while running the ${name} executor
${_chunkOZPXCCZBjs.formatLogMessage.call(void 0,
result
)}`,
{
cause: _optionalChain([result, 'optionalAccess', _20 => _20.error])
}
);
}
if (_optionalChain([executorOptions, 'optionalAccess', _21 => _21.hooks, 'optionalAccess', _22 => _22.postProcess])) {
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
await Promise.resolve(executorOptions.hooks.postProcess(config));
_chunkOZPXCCZBjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
}
_chunkOZPXCCZBjs.writeSuccess.call(void 0, `Completed running the ${name} task executor!
`, config);
return {
success: true
};
} catch (error) {
_chunkOZPXCCZBjs.writeFatal.call(void 0,
"A fatal error occurred while running the executor - the process was forced to terminate",
config
);
_chunkOZPXCCZBjs.writeError.call(void 0,
`An exception was thrown in the executor's process
- Details: ${error.message}
- Stacktrace: ${error.stack}`,
config
);
return {
success: false
};
} finally {
stopwatch();
}
};
var _isFunction = (value) => {
try {
return value instanceof Function || typeof value === "function" || !!(_optionalChain([value, 'optionalAccess', _23 => _23.constructor]) && _optionalChain([value, 'optionalAccess', _24 => _24.call]) && _optionalChain([value, 'optionalAccess', _25 => _25.apply]));
} catch (e) {
return false;
}
};
// ../workspace-tools/src/utils/cargo.ts
var _devkit = require('@nx/devkit');
var _child_process = require('child_process');
var _path = require('path'); var path2 = _interopRequireWildcard(_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).filter(
([key2]) => key2 && key2 !== "_"
)) {
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}`, String(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: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.stdio]), () => ( "inherit")),
env: {
...process.env,
..._optionalChain([options, 'optionalAccess', _27 => _27.env])
}
};
try {
return {
output: _child_process.execSync.call(void 0, `cargo ${args}`, {
encoding: "utf8",
windowsHide: true,
stdio: normalizedOptions.stdio,
env: normalizedOptions.env,
maxBuffer: 1024 * 1024 * 10
}),
success: true
};
} catch (e) {
return {
output: e.message,
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 = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _28 => _28.target_directory]), () => ( _devkit.joinPathFragments.call(void 0, workspaceRoot2, "dist")));
return new Promise((resolve) => {
if (process.env.VERCEL) {
return resolve({ success: true });
}
_child_process.execSync.call(void 0, `${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"]
});
resolve({ 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
var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
var _https = require('https'); var _https2 = _interopRequireDefault(_https);
var LARGE_BUFFER = 1024 * 1e6;
// ../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/plugins/swc.ts
var _core = require('@swc/core');
// ../build-tools/src/plugins/ts-resolve.ts
var _module = require('module');
var _resolve2 = require('resolve'); var _resolve3 = _interopRequireDefault(_resolve2);
// ../build-tools/src/plugins/type-definitions.ts
// ../build-tools/src/utilities/copy-assets.ts
var _copyassetshandler = require('@nx/js/src/utils/assets/copy-assets-handler');
var _glob = require('glob');
var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
var copyAssets = async (config, assets, outputPath, projectRoot, sourceRoot, generatePackageJson3 = true, includeSrc = false, banner, footer) => {
const pendingAssets = Array.from(_nullishCoalesce(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/"
});
}
_chunkOZPXCCZBjs.writeTrace.call(void 0,
`\u{1F4DD} Copying the following assets to the output directory:
${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${pendingAsset} -> ${outputPath}` : ` - ${pendingAsset.input}/${pendingAsset.glob} -> ${_chunkOZPXCCZBjs.joinPaths.call(void 0, outputPath, pendingAsset.output)}`).join("\n")}`,
config
);
const assetHandler = new (0, _copyassetshandler.CopyAssetsHandler)({
projectDir: projectRoot,
rootDir: config.workspaceRoot,
outputDir: outputPath,
assets: pendingAssets
});
await assetHandler.processAllAssetsOnce();
_chunkOZPXCCZBjs.writeTrace.call(void 0, "Completed copying assets to the output directory", config);
if (includeSrc === true) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
`\u{1F4DD} Adding banner and writing source files: ${_chunkOZPXCCZBjs.joinPaths.call(void 0,
outputPath,
"src"
)}`,
config
);
const files = await _glob.glob.call(void 0, [
_chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.ts"),
_chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.tsx"),
_chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.js"),
_chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.jsx")
]);
await Promise.allSettled(
files.map(
async (file) => _promises.writeFile.call(void 0,
file,
`${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
${await _promises.readFile.call(void 0, file, "utf8")}
${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`
)
)
);
}
};
// ../build-tools/src/utilities/generate-package-json.ts
var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
var _projectgraph = require('nx/src/project-graph/project-graph');
var addPackageDependencies = async (workspaceRoot2, projectRoot, projectName, packageJson) => {
let projectGraph;
try {
projectGraph = _projectgraph.readCachedProjectGraph.call(void 0, );
} catch (e2) {
await _projectgraph.createProjectGraphAsync.call(void 0, );
projectGraph = _projectgraph.readCachedProjectGraph.call(void 0, );
}
if (!projectGraph) {
throw new Error(
"The Build process failed because the project graph is not available. Please run the build command again."
);
}
const projectDependencies = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0,
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" && _optionalChain([dep, 'access', _29 => _29.node, 'access', _30 => _30.data, 'optionalAccess', _31 => _31.root]) !== projectRoot && _optionalChain([dep, 'access', _32 => _32.node, 'access', _33 => _33.data, 'optionalAccess', _34 => _34.root]) !== workspaceRoot2
)) {
const projectNode = project.node;
if (projectNode.data.root) {
const projectPackageJsonPath = _chunkOZPXCCZBjs.joinPaths.call(void 0,
workspaceRoot2,
projectNode.data.root,
"package.json"
);
if (_fs.existsSync.call(void 0, projectPackageJsonPath)) {
const projectPackageJsonContent = await _promises.readFile.call(void 0,
projectPackageJsonPath,
"utf8"
);
const projectPackageJson = JSON.parse(projectPackageJsonContent);
if (projectPackageJson.private !== true) {
localPackages.push(projectPackageJson);
}
}
}
}
if (localPackages.length > 0) {
_chunkOZPXCCZBjs.writeTrace.call(void 0,
`\u{1F4E6} Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`
);
const projectJsonFile = await _promises.readFile.call(void 0,
_chunkOZPXCCZBjs.joinPaths.call(void 0, projectRoot, "project.json"),
"utf8"
);
const projectJson = JSON.parse(projectJsonFile);
const projectName2 = projectJson.name;
const projectConfigurations = _projectgraph.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
if (!_optionalChain([projectConfigurations, 'optionalAccess', _35 => _35.projects, 'optionalAccess', _36 => _36[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 = _optionalChain([projectConfigurations, 'access', _37 => _37.projects, 'optionalAccess', _38 => _38[projectName2], 'access', _39 => _39.implicitDependencies, 'optionalAccess', _40 => _40.reduce, 'call', _41 => _41((ret, dep) => {
if (_optionalChain([projectConfigurations, 'access', _42 => _42.projects, 'optionalAccess', _43 => _43[dep]])) {
const depPackageJsonPath = _chunkOZPXCCZBjs.joinPaths.call(void 0,
workspaceRoot2,
projectConfigurations.projects[dep].root,
"package.json"
);
if (_fs.existsSync.call(void 0, depPackageJsonPath)) {
const depPackageJsonContent = _fs.readFileSync.call(void 0,
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] && !_optionalChain([implicitDependencies, 'optionalAccess', _44 => _44.includes, 'call', _45 => _45(localPackage.name)]) && _optionalChain([packageJson, 'access', _46 => _46.devDependencies, 'optionalAccess', _47 => _47[localPackage.name]]) === void 0) {
ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
}
return ret;
}, _nullishCoalesce(packageJson.dependencies, () => ( {})));
packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
if (!ret[localPackage.name] && _optionalChain([implicitDependencies, 'optionalAccess', _48 => _48.includes, 'call', _49 => _49(localPackage.name)]) && _optionalChain([packageJson, 'access', _50 => _50.dependencies, 'optionalAccess', _51 => _51[localPackage.name]]) === void 0) {
ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
}
return ret;
}, _nullishCoalesce(packageJson.devDependencies, () => ( {})));
} else {
_chunkOZPXCCZBjs.writeTrace.call(void 0, "\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 : _chunkWROOA5AXjs.findWorkspaceRoot.call(void 0, );
const workspacePackageJsonContent = await _promises.readFile.call(void 0,
_chunkOZPXCCZBjs.joinPaths.call(void 0, 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 ??= `${_chunkOZPXCCZBjs.joinPaths.call(void 0, 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 : _chunkOZPXCCZBjs.joinPaths.call(void 0, "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
// ../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
// ../build-tools/src/utilities/task-graph.ts
var _createtaskgraph = require('nx/src/tasks-runner/create-task-graph');
// ../esbuild/src/assets.ts
async function copyBuildAssets(context) {
if (!_optionalChain([context, 'access', _52 => _52.result, 'optionalAccess', _53 => _53.errors, 'access', _54 => _54.length]) && _optionalChain([context, 'access', _55 => _55.options, 'access', _56 => _56.assets, 'optionalAccess', _57 => _57.length])) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
` \u{1F4CB} Copying ${context.options.assets.length} asset files to output directory: ${context.outputPath}`,
context.workspaceConfig
);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, `${context.options.name} asset copy`);
await copyAssets(
context.workspaceConfig,
_nullishCoalesce(context.options.assets, () => ( [])),
context.outputPath,
context.options.projectRoot,
context.sourceRoot,
true,
false
);
stopwatch();
}
return context;
}
// ../esbuild/src/clean.ts
async function cleanDirectories(directory) {
await _promises.rm.call(void 0, directory, { recursive: true, force: true });
}
// ../esbuild/src/context.ts
var _findworkspaceroot = require('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 = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
if (!workspaceRoot2) {
throw new Error("Cannot find Nx workspace root");
}
const workspaceConfig = await _chunkWROOA5AXjs.getWorkspaceConfig.call(void 0, true, {
workspaceRoot: workspaceRoot2.dir
});
_chunkOZPXCCZBjs.writeDebug.call(void 0, " \u2699\uFE0F Resolving build options", workspaceConfig);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, "Build options resolution");
const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
exitOnError: true
});
const projectJsonPath = _chunkOZPXCCZBjs.joinPaths.call(void 0,
workspaceRoot2.dir,
projectRoot,
"project.json"
);
if (!_fs.existsSync.call(void 0, projectJsonPath)) {
throw new Error("Cannot find project.json configuration");
}
const projectJsonFile = await _promises2.default.readFile(projectJsonPath, "utf8");
const projectJson = JSON.parse(projectJsonFile);
const projectName = projectJson.name || userOptions.name;
const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
if (!_optionalChain([projectConfigurations, 'optionalAccess', _58 => _58.projects, 'optionalAccess', _59 => _59[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 = _defu2.default.call(void 0, userOptions, DEFAULT_BUILD_OPTIONS);
options.name ??= projectName;
const packageJsonPath = _chunkOZPXCCZBjs.joinPaths.call(void 0,
workspaceRoot2.dir,
options.projectRoot,
"package.json"
);
if (!_fs.existsSync.call(void 0, packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const env = getEnv("esbuild", options);
const define = _defu2.default.call(void 0, _nullishCoalesce(options.define, () => ( {})), _nullishCoalesce(env, () => ( {})));
const resolvedOptions = {
...options,
tsconfig: userOptions.tsconfig === null ? void 0 : userOptions.tsconfig ? userOptions.tsconfig : _chunkOZPXCCZBjs.joinPaths.call(void 0, 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 || _chunkOZPXCCZBjs.joinPaths.call(void 0, resolvedOptions.projectRoot, "src"),
outputPath: resolvedOptions.outputPath || _chunkOZPXCCZBjs.joinPaths.call(void 0,
workspaceConfig.workspaceRoot,
"dist",
resolvedOptions.projectRoot
),
minify: resolvedOptions.minify || resolvedOptions.mode === "production"
};
context.options.esbuildPlugins = [..._nullishCoalesce(context.options.esbuildPlugins, () => ( []))];
if (context.options.verbose) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
` \u2699\uFE0F Build options resolved:
${_chunkOZPXCCZBjs.formatLogMessage.call(void 0, context.options)}`,
workspaceConfig
);
}
return context;
}
// ../esbuild/src/package-json.ts
async function generatePackageJson(context) {
if (context.options.generatePackageJson !== false && _fs.existsSync.call(void 0, _chunkOZPXCCZBjs.joinPaths.call(void 0, context.options.projectRoot, "package.json"))) {
_chunkOZPXCCZBjs.writeDebug.call(void 0, " \u270D\uFE0F Writing package.json file", context.workspaceConfig);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, "Write package.json file");
const packageJsonPath = _chunkOZPXCCZBjs.joinPaths.call(void 0,
context.options.projectRoot,
"project.json"
);
if (!_fs.existsSync.call(void 0, packageJsonPath)) {
throw new Error("Cannot find package.json configuration");
}
const packageJsonFile = await _promises2.default.readFile(
_chunkOZPXCCZBjs.joinPaths.call(void 0,
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 _devkit.writeJsonFile.call(void 0,
_chunkOZPXCCZBjs.joinPaths.call(void 0, context.outputPath, "package.json"),
packageJson
);
stopwatch();
}
return context;
}
// ../tsup/src/index.ts
var _tsup = require('tsup');
async function build(options) {
if (!options.silent) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
` \u{1F680} Running ${options.name || "tsup"} build`,
options.workspaceConfig
);
}
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, `${options.name || "tsup"} build`);
await _tsup.build.call(void 0, options);
if (!options.silent) {
stopwatch();
}
}
// ../esbuild/src/tsup.ts
async function executeTsup(context) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
` \u{1F680} Running ${context.options.name} build`,
context.workspaceConfig
);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, `${context.options.name} build`);
await build({
...context.options,
outDir: context.options.distDir ? _chunkOZPXCCZBjs.joinPaths.call(void 0, context.outputPath, context.options.distDir) : context.outputPath,
workspaceConfig: context.workspaceConfig
});
stopwatch();
return context;
}
// ../esbuild/src/build.ts
async function reportResults(context) {
if (_optionalChain([context, 'access', _60 => _60.result, 'optionalAccess', _61 => _61.errors, 'access', _62 => _62.length]) === 0) {
if (context.result.warnings.length > 0) {
_chunkOZPXCCZBjs.writeWarning.call(void 0,
` \u{1F6A7} The following warnings occurred during the build: ${context.result.warnings.map((warning) => warning.text).join("\n")}`,
context.workspaceConfig
);
}
_chunkOZPXCCZBjs.writeSuccess.call(void 0,
` \u{1F4E6} The ${context.options.name} build completed successfully`,
context.workspaceConfig
);
} else if (_optionalChain([context, 'access', _63 => _63.result, 'optionalAccess', _64 => _64.errors]) && _optionalChain([context, 'access', _65 => _65.result, 'optionalAccess', _66 => _66.errors, 'access', _67 => _67.length]) > 0) {
_chunkOZPXCCZBjs.writeError.call(void 0,
` \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) {
_chunkOZPXCCZBjs.writeDebug.call(void 0,
` \u{1F9F9} Cleaning ${context.options.name} output path: ${context.outputPath}`,
context.workspaceConfig
);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, `${context.options.name} output clean`);
await cleanDirectories(context.outputPath);
stopwatch();
}
return context;
}
async function build2(options) {
_chunkOZPXCCZBjs.writeDebug.call(void 0, ` ${_chunkOZPXCCZBjs.brandIcon.call(void 0, )} Executing Storm ESBuild pipeline`);
const stopwatch = _chunkOZPXCCZBjs.getStopwatch.call(void 0, "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);
_chunkOZPXCCZBjs.writeSuccess.call(void 0, " \u{1F3C1} ESBuild pipeline build completed successfully");
} catch (error) {
_chunkOZPXCCZBjs.writeFatal.call(void 0,
"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) {
_chunkOZPXCCZBjs.writeInfo.call(void 0, "\u{1F4E6} Running Storm ESBuild executor on the workspace", config);
if (!_optionalChain([context, 'access', _68 => _68.projectsConfigurations, 'optionalAccess', _69 => _69.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !_optionalChain([context, 'access', _70 => _70.projectsConfigurations, 'access', _71 => _71.projects, 'access', _72 => _72[context.projectName], 'optionalAccess', _73 => _73.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
_optionalChain([context, 'access', _74 => _74.projectsConfigurations, 'access', _75 => _75.projects, 'optionalAccess', _76 => _76[context.projectName], 'access', _77 => _77.root])
),
name: context.projectName,
sourceRoot: _optionalChain([context, 'access', _78 => _78.projectsConfigurations, 'access', _79 => _79.projects, 'optionalAccess', _80 => _80[context.projectName], 'optionalAccess', _81 => _81.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
var _jiti = require('jiti');
var _fileutils = require('nx/src/utils/fileutils');
async function napiExecutor(options, context, config) {
const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
fsCache: config.skipCache ? false : _chunkOZPXCCZBjs.joinPaths.call(void 0,
config.workspaceRoot,
config.directories.cache || "node_modules/.cache/storm",
"jiti"
),
interopDefault: true
});
const { NapiCli } = await jiti.import(
jiti.esmResolve("@napi-rs/cli")
);
if (!_optionalChain([context, 'access', _82 => _82.projectGraph, 'optionalAccess', _83 => _83.nodes, 'access', _84 => _84[_nullishCoalesce(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 = _optionalChain([context, 'access', _85 => _85.projectGraph, 'optionalAccess', _86 => _86.nodes, 'access', _87 => _87[_nullishCoalesce(context.projectName, () => ( ""))], 'optionalAccess', _88 => _88.data, 'access', _89 => _89.root]);
const packageJson = _chunkOZPXCCZBjs.joinPaths.call(void 0, _nullishCoalesce(projectRoot, () => ( ".")), "package.json");
if (!_fileutils.fileExists.call(void 0, 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 || _optionalChain([metadata, 'optionalAccess', _90 => _90.target_directory]) || _chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, "dist", "target");
normalizedOptions.outputDir = options.outputPath;
normalizedOptions.packageJsonPath ??= packageJson;
if (options.cwd) {
normalizedOptions.cwd = _chunkOZPXCCZBjs.correctPaths.call(void 0, options.cwd);
} else {
const absoluteProjectRoot = _chunkOZPXCCZBjs.correctPaths.call(void 0,
_chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot || ".")
);
normalizedOptions.cwd = absoluteProjectRoot;
if (normalizedOptions.outputDir) {
normalizedOptions.outputDir = _chunkOZPXCCZBjs.relative.call(void 0,
normalizedOptions.cwd,
_chunkOZPXCCZBjs.correctPaths.call(void 0,
_chunkOZPXCCZBjs.isAbsolute.call(void 0, normalizedOptions.outputDir) ? normalizedOptions.outputDir : _chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.outputDir)
)
);
}
if (normalizedOptions.packageJsonPath) {
normalizedOptions.packageJsonPath = _chunkOZPXCCZBjs.relative.call(void 0,
normalizedOptions.cwd,
_chunkOZPXCCZBjs.correctPaths.call(void 0,
_chunkOZPXCCZBjs.isAbsolute.call(void 0, normalizedOptions.packageJsonPath) ? normalizedOptions.packageJsonPath : _chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.packageJsonPath)
)
);
}
if (normalizedOptions.configPath) {
normalizedOptions.configPath = _chunkOZPXCCZBjs.relative.call(void 0,
normalizedOptions.cwd,
_chunkOZPXCCZBjs.correctPaths.call(void 0,
_chunkOZPXCCZBjs.isAbsolute.call(void 0, normalizedOptions.configPath) ? normalizedOptions.configPath : _chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.configPath)
)
);
}
if (normalizedOptions.manifestPath) {
normalizedOptions.manifestPath = _chunkOZPXCCZBjs.relative.call(void 0,
normalizedOptions.cwd,
_chunkOZPXCCZBjs.correctPaths.call(void 0,
_chunkOZPXCCZBjs.isAbsolute.call(void 0, normalizedOptions.manifestPath) ? normalizedOptions.manifestPath : _chunkOZPXCCZBjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.manifestPath)
)
);
}
}
if (process.env.VERCEL) {
return { success: true };
}
_chunkOZPXCCZBjs.writeDebug.call(void 0,
`Normalized Napi Options:
packageJsonPath: ${normalizedOptions.packageJsonPath}
outputDir: ${normalizedOptions.outputDir}
targetDir: ${normalizedOptions.targetDir}
manifestPath: ${normalizedOptions.manifestPath}
configPath: ${normalizedOptions.configPath}
cwd: ${normalizedOptions.cwd}`,
config
);
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
// ../pnpm-tools/src/helpers/replace-deps-aliases.ts
var _prettier = require('prettier');
//