@powerlines/engine 0.47.4 → 0.49.2

package/dist/api/build.cjs

@@ -0,0 +1,66 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-C_NdSu1c.cjs');
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core = require("@powerlines/core");
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _stryke_fs_copy_file = require("@stryke/fs/copy-file");
+let _stryke_path_append = require("@stryke/path/append");
+let _stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
+let _stryke_path_is_parent_path = require("@stryke/path/is-parent-path");
+let _stryke_path_join_paths = require("@stryke/path/join-paths");
+let _stryke_path_replace = require("@stryke/path/replace");
+let chalk = require("chalk");
+chalk = require_chunk.__toESM(chalk, 1);
+let node_fs = require("node:fs");
+
+//#region src/api/build.ts
+async function handleBuild(context, env) {
+	await context.callHook("build", {
+		environment: env,
+		order: "pre"
+	});
+	env.debug("Formatting the generated entry files before the build process starts.");
+	await (0, _powerlines_core.formatFolder)(env, env.entryPath);
+	await context.callHook("build", {
+		environment: env,
+		order: "normal"
+	});
+	if (env.config.output.copy) {
+		env.debug("Copying project's files from build output directory.");
+		const destinationPath = (0, _stryke_path_is_parent_path.isParentPath)((0, _stryke_path_append.appendPath)(env.config.output.path, env.config.cwd), (0, _stryke_path_append.appendPath)(env.config.root, env.config.cwd)) ? (0, _stryke_path_join_paths.joinPaths)(env.config.output.copy.path, (0, _stryke_path_file_path_fns.relativePath)((0, _stryke_path_append.appendPath)(env.config.root, env.config.cwd), (0, _stryke_path_append.appendPath)(env.config.output.path, env.config.cwd))) : (0, _stryke_path_join_paths.joinPaths)(env.config.output.copy.path, "dist");
+		const sourcePath = env.config.output.path;
+		if ((0, node_fs.existsSync)(sourcePath) && sourcePath !== destinationPath) {
+			env.debug(`Copying files from project's build output directory (${env.config.output.path}) to the project's copy/publish directory (${destinationPath}).`);
+			await (0, _stryke_fs_copy_file.copyFiles)(sourcePath, destinationPath);
+		} else env.warn(`The source path for the copy operation ${!(0, node_fs.existsSync)(sourcePath) ? "does not exist" : "is the same as the destination path"}. Source: ${sourcePath}, Destination: ${destinationPath}. Skipping copying of build output files.`);
+		if (env.config.output.copy.assets && Array.isArray(env.config.output.copy.assets)) await Promise.all(env.config.output.copy.assets.map(async (asset) => {
+			env.trace(`Copying asset(s): ${chalk.default.redBright(env.config.cwd === asset.input ? asset.glob : (0, _stryke_path_append.appendPath)(asset.glob, (0, _stryke_path_replace.replacePath)(asset.input, env.config.cwd)))} -> ${chalk.default.greenBright((0, _stryke_path_append.appendPath)(asset.glob, (0, _stryke_path_replace.replacePath)(asset.output, env.config.cwd)))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk.default.yellowBright(i)).join(", ")})` : ""}`);
+			await env.fs.copy(asset, asset.output);
+		}));
+	} else env.debug("No copy configuration found for the project output. Skipping the copying of build output files.");
+	await context.callHook("build", {
+		environment: env,
+		order: "post"
+	});
+}
+/**
+* Build the project
+*
+* @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.
+*/
+async function build(context) {
+	const timer = context.timer("Building");
+	await context.generateChecksum();
+	if (context.meta.checksum !== context.persistedMeta?.checksum || context.config.skipCache) {
+		context.info(!context.persistedMeta?.checksum ? "No previous build cache found. Preparing the project for the initial build." : context.meta.checksum !== context.persistedMeta.checksum ? "The project has been modified since the last time `prepare` was ran. Re-preparing the project." : "The project is configured to skip cache. Re-preparing the project.");
+		await require_api_prepare.prepare(context);
+	}
+	if (context.config.singleBuild) await handleBuild(context, await context.toEnvironment());
+	else await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		await handleBuild(context, env);
+	});
+	timer();
+}
+
+//#endregion
+exports.build = build;

package/dist/api/build.d.cts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/build.d.ts
+/**
+ * Build the project
+ *
+ * @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.
+ */
+declare function build<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { build };
+//# sourceMappingURL=build.d.cts.map

package/dist/api/build.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.cts","names":[],"sources":["../../src/api/build.ts"],"mappings":";;;;;;;AA6IA;;;iBAAsB,KAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/build.d.mts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/build.d.ts
+/**
+ * Build the project
+ *
+ * @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.
+ */
+declare function build<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { build };
+//# sourceMappingURL=build.d.mts.map

package/dist/api/build.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.mts","names":[],"sources":["../../src/api/build.ts"],"mappings":";;;;;;;AA6IA;;;iBAAsB,KAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/build.mjs

@@ -0,0 +1,64 @@
+import { prepare } from "./prepare.mjs";
+import { formatFolder } from "@powerlines/core";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+import { copyFiles } from "@stryke/fs/copy-file";
+import { appendPath } from "@stryke/path/append";
+import { relativePath } from "@stryke/path/file-path-fns";
+import { isParentPath } from "@stryke/path/is-parent-path";
+import { joinPaths } from "@stryke/path/join-paths";
+import { replacePath } from "@stryke/path/replace";
+import chalk from "chalk";
+import { existsSync } from "node:fs";
+
+//#region src/api/build.ts
+async function handleBuild(context, env) {
+	await context.callHook("build", {
+		environment: env,
+		order: "pre"
+	});
+	env.debug("Formatting the generated entry files before the build process starts.");
+	await formatFolder(env, env.entryPath);
+	await context.callHook("build", {
+		environment: env,
+		order: "normal"
+	});
+	if (env.config.output.copy) {
+		env.debug("Copying project's files from build output directory.");
+		const destinationPath = isParentPath(appendPath(env.config.output.path, env.config.cwd), appendPath(env.config.root, env.config.cwd)) ? joinPaths(env.config.output.copy.path, relativePath(appendPath(env.config.root, env.config.cwd), appendPath(env.config.output.path, env.config.cwd))) : joinPaths(env.config.output.copy.path, "dist");
+		const sourcePath = env.config.output.path;
+		if (existsSync(sourcePath) && sourcePath !== destinationPath) {
+			env.debug(`Copying files from project's build output directory (${env.config.output.path}) to the project's copy/publish directory (${destinationPath}).`);
+			await copyFiles(sourcePath, destinationPath);
+		} else env.warn(`The source path for the copy operation ${!existsSync(sourcePath) ? "does not exist" : "is the same as the destination path"}. Source: ${sourcePath}, Destination: ${destinationPath}. Skipping copying of build output files.`);
+		if (env.config.output.copy.assets && Array.isArray(env.config.output.copy.assets)) await Promise.all(env.config.output.copy.assets.map(async (asset) => {
+			env.trace(`Copying asset(s): ${chalk.redBright(env.config.cwd === asset.input ? asset.glob : appendPath(asset.glob, replacePath(asset.input, env.config.cwd)))} -> ${chalk.greenBright(appendPath(asset.glob, replacePath(asset.output, env.config.cwd)))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk.yellowBright(i)).join(", ")})` : ""}`);
+			await env.fs.copy(asset, asset.output);
+		}));
+	} else env.debug("No copy configuration found for the project output. Skipping the copying of build output files.");
+	await context.callHook("build", {
+		environment: env,
+		order: "post"
+	});
+}
+/**
+* Build the project
+*
+* @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.
+*/
+async function build(context) {
+	const timer = context.timer("Building");
+	await context.generateChecksum();
+	if (context.meta.checksum !== context.persistedMeta?.checksum || context.config.skipCache) {
+		context.info(!context.persistedMeta?.checksum ? "No previous build cache found. Preparing the project for the initial build." : context.meta.checksum !== context.persistedMeta.checksum ? "The project has been modified since the last time `prepare` was ran. Re-preparing the project." : "The project is configured to skip cache. Re-preparing the project.");
+		await prepare(context);
+	}
+	if (context.config.singleBuild) await handleBuild(context, await context.toEnvironment());
+	else await executeEnvironments(context, async (env) => {
+		await handleBuild(context, env);
+	});
+	timer();
+}
+
+//#endregion
+export { build };
+//# sourceMappingURL=build.mjs.map

package/dist/api/build.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.mjs","names":[],"sources":["../../src/api/build.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport {\n  EnvironmentContext,\n  ExecutionContext,\n  formatFolder\n} from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { copyFiles } from \"@stryke/fs/copy-file\";\nimport { appendPath } from \"@stryke/path/append\";\nimport { relativePath } from \"@stryke/path/file-path-fns\";\nimport { isParentPath } from \"@stryke/path/is-parent-path\";\nimport { joinPaths } from \"@stryke/path/join-paths\";\nimport { replacePath } from \"@stryke/path/replace\";\nimport chalk from \"chalk\";\nimport { existsSync } from \"node:fs\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\nasync function handleBuild<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(\n  context: ExecutionContext<TResolvedConfig, TSystemContext>,\n  env: EnvironmentContext<TResolvedConfig, TSystemContext>\n) {\n  await context.callHook(\"build\", {\n    environment: env,\n    order: \"pre\"\n  });\n\n  env.debug(\n    \"Formatting the generated entry files before the build process starts.\"\n  );\n  await formatFolder(env, env.entryPath);\n\n  await context.callHook(\"build\", {\n    environment: env,\n    order: \"normal\"\n  });\n\n  if (env.config.output.copy) {\n    env.debug(\"Copying project's files from build output directory.\");\n\n    const destinationPath = isParentPath(\n      appendPath(env.config.output.path, env.config.cwd),\n      appendPath(env.config.root, env.config.cwd)\n    )\n      ? joinPaths(\n          env.config.output.copy.path,\n          relativePath(\n            appendPath(env.config.root, env.config.cwd),\n            appendPath(env.config.output.path, env.config.cwd)\n          )\n        )\n      : joinPaths(env.config.output.copy.path, \"dist\");\n    const sourcePath = env.config.output.path;\n\n    if (existsSync(sourcePath) && sourcePath !== destinationPath) {\n      env.debug(\n        `Copying files from project's build output directory (${\n          env.config.output.path\n        }) to the project's copy/publish directory (${destinationPath}).`\n      );\n\n      await copyFiles(sourcePath, destinationPath);\n    } else {\n      env.warn(\n        `The source path for the copy operation ${\n          !existsSync(sourcePath)\n            ? \"does not exist\"\n            : \"is the same as the destination path\"\n        }. Source: ${sourcePath}, Destination: ${\n          destinationPath\n        }. Skipping copying of build output files.`\n      );\n    }\n\n    if (\n      env.config.output.copy.assets &&\n      Array.isArray(env.config.output.copy.assets)\n    ) {\n      await Promise.all(\n        env.config.output.copy.assets.map(async asset => {\n          env.trace(\n            `Copying asset(s): ${chalk.redBright(\n              env.config.cwd === asset.input\n                ? asset.glob\n                : appendPath(\n                    asset.glob,\n                    replacePath(asset.input, env.config.cwd)\n                  )\n            )} -> ${chalk.greenBright(\n              appendPath(asset.glob, replacePath(asset.output, env.config.cwd))\n            )} ${\n              Array.isArray(asset.ignore) && asset.ignore.length > 0\n                ? ` (ignoring: ${asset.ignore\n                    .map(i => chalk.yellowBright(i))\n                    .join(\", \")})`\n                : \"\"\n            }`\n          );\n\n          await env.fs.copy(asset, asset.output);\n        })\n      );\n    }\n  } else {\n    env.debug(\n      \"No copy configuration found for the project output. Skipping the copying of build output files.\"\n    );\n  }\n\n  await context.callHook(\"build\", {\n    environment: env,\n    order: \"post\"\n  });\n}\n\n/**\n * Build the project\n *\n * @param context - The execution context for the build process, which provides access to the project configuration, environment, and utility functions for performing the build. The context is used to manage the state and behavior of the build process, allowing for hooks to be called at different stages of the build and for environment-specific configurations to be applied.\n */\nexport async function build<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Building\");\n\n  await context.generateChecksum();\n  if (\n    context.meta.checksum !== context.persistedMeta?.checksum ||\n    context.config.skipCache\n  ) {\n    context.info(\n      !context.persistedMeta?.checksum\n        ? \"No previous build cache found. Preparing the project for the initial build.\"\n        : context.meta.checksum !== context.persistedMeta.checksum\n          ? \"The project has been modified since the last time `prepare` was ran. Re-preparing the project.\"\n          : \"The project is configured to skip cache. Re-preparing the project.\"\n    );\n\n    await prepare<TResolvedConfig, TSystemContext>(context);\n  }\n\n  if (context.config.singleBuild) {\n    await handleBuild<TResolvedConfig, TSystemContext>(\n      context,\n      await context.toEnvironment()\n    );\n  } else {\n    await executeEnvironments(context, async env => {\n      await handleBuild<TResolvedConfig, TSystemContext>(context, env);\n    });\n  }\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;;AAoCA,eAAe,YAIb,SACA,KACA;CACA,MAAM,QAAQ,SAAS,SAAS;EAC9B,aAAa;EACb,OAAO;CACT,CAAC;CAED,IAAI,MACF,uEACF;CACA,MAAM,aAAa,KAAK,IAAI,SAAS;CAErC,MAAM,QAAQ,SAAS,SAAS;EAC9B,aAAa;EACb,OAAO;CACT,CAAC;CAED,IAAI,IAAI,OAAO,OAAO,MAAM;EAC1B,IAAI,MAAM,sDAAsD;EAEhE,MAAM,kBAAkB,aACtB,WAAW,IAAI,OAAO,OAAO,MAAM,IAAI,OAAO,GAAG,GACjD,WAAW,IAAI,OAAO,MAAM,IAAI,OAAO,GAAG,CAC5C,IACI,UACE,IAAI,OAAO,OAAO,KAAK,MACvB,aACE,WAAW,IAAI,OAAO,MAAM,IAAI,OAAO,GAAG,GAC1C,WAAW,IAAI,OAAO,OAAO,MAAM,IAAI,OAAO,GAAG,CACnD,CACF,IACA,UAAU,IAAI,OAAO,OAAO,KAAK,MAAM,MAAM;EACjD,MAAM,aAAa,IAAI,OAAO,OAAO;EAErC,IAAI,WAAW,UAAU,KAAK,eAAe,iBAAiB;GAC5D,IAAI,MACF,wDACE,IAAI,OAAO,OAAO,KACnB,6CAA6C,gBAAgB,GAChE;GAEA,MAAM,UAAU,YAAY,eAAe;EAC7C,OACE,IAAI,KACF,0CACE,CAAC,WAAW,UAAU,IAClB,mBACA,sCACL,YAAY,WAAW,iBACtB,gBACD,0CACH;EAGF,IACE,IAAI,OAAO,OAAO,KAAK,UACvB,MAAM,QAAQ,IAAI,OAAO,OAAO,KAAK,MAAM,GAE3C,MAAM,QAAQ,IACZ,IAAI,OAAO,OAAO,KAAK,OAAO,IAAI,OAAM,UAAS;GAC/C,IAAI,MACF,qBAAqB,MAAM,UACzB,IAAI,OAAO,QAAQ,MAAM,QACrB,MAAM,OACN,WACE,MAAM,MACN,YAAY,MAAM,OAAO,IAAI,OAAO,GAAG,CACzC,CACN,EAAE,MAAM,MAAM,YACZ,WAAW,MAAM,MAAM,YAAY,MAAM,QAAQ,IAAI,OAAO,GAAG,CAAC,CAClE,EAAE,GACA,MAAM,QAAQ,MAAM,MAAM,KAAK,MAAM,OAAO,SAAS,IACjD,eAAe,MAAM,OAClB,KAAI,MAAK,MAAM,aAAa,CAAC,CAAC,EAC9B,KAAK,IAAI,EAAE,KACd,IAER;GAEA,MAAM,IAAI,GAAG,KAAK,OAAO,MAAM,MAAM;EACvC,CAAC,CACH;CAEJ,OACE,IAAI,MACF,iGACF;CAGF,MAAM,QAAQ,SAAS,SAAS;EAC9B,aAAa;EACb,OAAO;CACT,CAAC;AACH;;;;;;AAOA,eAAsB,MAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,UAAU;CAEtC,MAAM,QAAQ,iBAAiB;CAC/B,IACE,QAAQ,KAAK,aAAa,QAAQ,eAAe,YACjD,QAAQ,OAAO,WACf;EACA,QAAQ,KACN,CAAC,QAAQ,eAAe,WACpB,gFACA,QAAQ,KAAK,aAAa,QAAQ,cAAc,WAC9C,mGACA,oEACR;EAEA,MAAM,QAAyC,OAAO;CACxD;CAEA,IAAI,QAAQ,OAAO,aACjB,MAAM,YACJ,SACA,MAAM,QAAQ,cAAc,CAC9B;MAEA,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,YAA6C,SAAS,GAAG;CACjE,CAAC;CAGH,MAAM;AACR"}

package/dist/api/clean.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _stryke_path_join = require("@stryke/path/join");
+
+//#region src/api/clean.ts
+/**
+* Clean any previously prepared artifacts
+*
+* @param context - The execution context for the clean process, which provides access to the project configuration, environment, and utility functions for performing the clean operation. The context is used to manage the state and behavior of the clean process, allowing for hooks to be called at different stages of the clean and for environment-specific configurations to be applied.
+*/
+async function clean(context) {
+	const timer = context.timer("Cleaning");
+	await require_api_prepare.prepare(context, true);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		env.debug("Cleaning the project's dist and artifacts directories.");
+		await env.fs.remove((0, _stryke_path_join.joinPaths)(env.config.cwd, env.config.output.path));
+		await env.fs.remove((0, _stryke_path_join.joinPaths)(env.config.cwd, env.config.root, env.config.output.artifactsPath));
+		await context.callHook("clean", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+exports.clean = clean;

package/dist/api/clean.d.cts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/clean.d.ts
+/**
+ * Clean any previously prepared artifacts
+ *
+ * @param context - The execution context for the clean process, which provides access to the project configuration, environment, and utility functions for performing the clean operation. The context is used to manage the state and behavior of the clean process, allowing for hooks to be called at different stages of the clean and for environment-specific configurations to be applied.
+ */
+declare function clean<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { clean };
+//# sourceMappingURL=clean.d.cts.map

package/dist/api/clean.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.cts","names":[],"sources":["../../src/api/clean.ts"],"mappings":";;;;;;;AA8BA;;;iBAAsB,KAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/clean.d.mts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/clean.d.ts
+/**
+ * Clean any previously prepared artifacts
+ *
+ * @param context - The execution context for the clean process, which provides access to the project configuration, environment, and utility functions for performing the clean operation. The context is used to manage the state and behavior of the clean process, allowing for hooks to be called at different stages of the clean and for environment-specific configurations to be applied.
+ */
+declare function clean<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { clean };
+//# sourceMappingURL=clean.d.mts.map

package/dist/api/clean.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.mts","names":[],"sources":["../../src/api/clean.ts"],"mappings":";;;;;;;AA8BA;;;iBAAsB,KAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/clean.mjs

@@ -0,0 +1,28 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+import { joinPaths } from "@stryke/path/join";
+
+//#region src/api/clean.ts
+/**
+* Clean any previously prepared artifacts
+*
+* @param context - The execution context for the clean process, which provides access to the project configuration, environment, and utility functions for performing the clean operation. The context is used to manage the state and behavior of the clean process, allowing for hooks to be called at different stages of the clean and for environment-specific configurations to be applied.
+*/
+async function clean(context) {
+	const timer = context.timer("Cleaning");
+	await prepare(context, true);
+	await executeEnvironments(context, async (env) => {
+		env.debug("Cleaning the project's dist and artifacts directories.");
+		await env.fs.remove(joinPaths(env.config.cwd, env.config.output.path));
+		await env.fs.remove(joinPaths(env.config.cwd, env.config.root, env.config.output.artifactsPath));
+		await context.callHook("clean", {
+			environment: env,
+			sequential: false
+		});
+	});
+	timer();
+}
+
+//#endregion
+export { clean };
+//# sourceMappingURL=clean.mjs.map

package/dist/api/clean.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.mjs","names":[],"sources":["../../src/api/clean.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { joinPaths } from \"@stryke/path/join\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Clean any previously prepared artifacts\n *\n * @param context - The execution context for the clean process, which provides access to the project configuration, environment, and utility functions for performing the clean operation. The context is used to manage the state and behavior of the clean process, allowing for hooks to be called at different stages of the clean and for environment-specific configurations to be applied.\n */\nexport async function clean<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Cleaning\");\n\n  await prepare<TResolvedConfig, TSystemContext>(context, true);\n  await executeEnvironments(context, async env => {\n    env.debug(\"Cleaning the project's dist and artifacts directories.\");\n\n    await env.fs.remove(joinPaths(env.config.cwd, env.config.output.path));\n    await env.fs.remove(\n      joinPaths(\n        env.config.cwd,\n        env.config.root,\n        env.config.output.artifactsPath\n      )\n    );\n\n    await context.callHook(\"clean\", {\n      environment: env,\n      sequential: false\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;AA8BA,eAAsB,MAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,UAAU;CAEtC,MAAM,QAAyC,SAAS,IAAI;CAC5D,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,IAAI,MAAM,wDAAwD;EAElE,MAAM,IAAI,GAAG,OAAO,UAAU,IAAI,OAAO,KAAK,IAAI,OAAO,OAAO,IAAI,CAAC;EACrE,MAAM,IAAI,GAAG,OACX,UACE,IAAI,OAAO,KACX,IAAI,OAAO,MACX,IAAI,OAAO,OAAO,aACpB,CACF;EAEA,MAAM,QAAQ,SAAS,SAAS;GAC9B,aAAa;GACb,YAAY;EACd,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/create.cjs

@@ -0,0 +1,59 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-C_NdSu1c.cjs');
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+let _stryke_path_join = require("@stryke/path/join");
+let _stryke_fs_list_files = require("@stryke/fs/list-files");
+let handlebars = require("handlebars");
+handlebars = require_chunk.__toESM(handlebars, 1);
+
+//#region src/api/create.ts
+/**
+* Create a new Powerlines project
+*
+* @param context - The execution context for the create process, which provides access to the project configuration, environment, and utility functions for performing the create operation. The context is used to manage the state and behavior of the create process, allowing for hooks to be called at different stages of the create and for environment-specific configurations to be applied.
+*/
+async function create(context) {
+	const timer = context.timer("Create a New Project Generation");
+	await require_api_prepare.prepare(context, true);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		env.debug("Initializing the processing options for the project.");
+		await context.callHook("create", {
+			environment: env,
+			order: "pre"
+		});
+		const files = await (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_join.joinPaths)(env.powerlinesPath, "files/common/**/*.hbs"));
+		for (const file of files) {
+			env.trace(`Adding template file to project: ${file}`);
+			const template = handlebars.default.compile(file);
+			await env.fs.write((0, _stryke_path_join.joinPaths)(env.config.root, file.replace(".hbs", "")), template(env));
+		}
+		await context.callHook("create", {
+			environment: env,
+			order: "normal"
+		});
+		if (env.config.projectType === "application") {
+			const appFiles = await (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_join.joinPaths)(env.powerlinesPath, "files/application/**/*.hbs"));
+			for (const file of appFiles) {
+				env.trace(`Adding application template file: ${file}`);
+				const template = handlebars.default.compile(file);
+				await env.fs.write((0, _stryke_path_join.joinPaths)(env.config.root, file.replace(".hbs", "")), template(env));
+			}
+		} else {
+			const libFiles = await (0, _stryke_fs_list_files.listFiles)((0, _stryke_path_join.joinPaths)(env.powerlinesPath, "files/library/**/*.hbs"));
+			for (const file of libFiles) {
+				env.trace(`Adding library template file: ${file}`);
+				const template = handlebars.default.compile(file);
+				await env.fs.write((0, _stryke_path_join.joinPaths)(env.config.root, file.replace(".hbs", "")), template(env));
+			}
+		}
+		await context.callHook("create", {
+			environment: env,
+			order: "post"
+		});
+	});
+	timer();
+}
+
+//#endregion
+exports.create = create;

package/dist/api/create.d.cts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/create.d.ts
+/**
+ * Create a new Powerlines project
+ *
+ * @param context - The execution context for the create process, which provides access to the project configuration, environment, and utility functions for performing the create operation. The context is used to manage the state and behavior of the create process, allowing for hooks to be called at different stages of the create and for environment-specific configurations to be applied.
+ */
+declare function create<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { create };
+//# sourceMappingURL=create.d.cts.map

package/dist/api/create.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.cts","names":[],"sources":["../../src/api/create.ts"],"mappings":";;;;;;;AAgCA;;;iBAAsB,MAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/create.d.mts

@@ -0,0 +1,14 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/create.d.ts
+/**
+ * Create a new Powerlines project
+ *
+ * @param context - The execution context for the create process, which provides access to the project configuration, environment, and utility functions for performing the create operation. The context is used to manage the state and behavior of the create process, allowing for hooks to be called at different stages of the create and for environment-specific configurations to be applied.
+ */
+declare function create<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { create };
+//# sourceMappingURL=create.d.mts.map

package/dist/api/create.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.mts","names":[],"sources":["../../src/api/create.ts"],"mappings":";;;;;;;AAgCA;;;iBAAsB,MAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/create.mjs

@@ -0,0 +1,57 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+import { joinPaths } from "@stryke/path/join";
+import { listFiles } from "@stryke/fs/list-files";
+import Handlebars from "handlebars";
+
+//#region src/api/create.ts
+/**
+* Create a new Powerlines project
+*
+* @param context - The execution context for the create process, which provides access to the project configuration, environment, and utility functions for performing the create operation. The context is used to manage the state and behavior of the create process, allowing for hooks to be called at different stages of the create and for environment-specific configurations to be applied.
+*/
+async function create(context) {
+	const timer = context.timer("Create a New Project Generation");
+	await prepare(context, true);
+	await executeEnvironments(context, async (env) => {
+		env.debug("Initializing the processing options for the project.");
+		await context.callHook("create", {
+			environment: env,
+			order: "pre"
+		});
+		const files = await listFiles(joinPaths(env.powerlinesPath, "files/common/**/*.hbs"));
+		for (const file of files) {
+			env.trace(`Adding template file to project: ${file}`);
+			const template = Handlebars.compile(file);
+			await env.fs.write(joinPaths(env.config.root, file.replace(".hbs", "")), template(env));
+		}
+		await context.callHook("create", {
+			environment: env,
+			order: "normal"
+		});
+		if (env.config.projectType === "application") {
+			const appFiles = await listFiles(joinPaths(env.powerlinesPath, "files/application/**/*.hbs"));
+			for (const file of appFiles) {
+				env.trace(`Adding application template file: ${file}`);
+				const template = Handlebars.compile(file);
+				await env.fs.write(joinPaths(env.config.root, file.replace(".hbs", "")), template(env));
+			}
+		} else {
+			const libFiles = await listFiles(joinPaths(env.powerlinesPath, "files/library/**/*.hbs"));
+			for (const file of libFiles) {
+				env.trace(`Adding library template file: ${file}`);
+				const template = Handlebars.compile(file);
+				await env.fs.write(joinPaths(env.config.root, file.replace(".hbs", "")), template(env));
+			}
+		}
+		await context.callHook("create", {
+			environment: env,
+			order: "post"
+		});
+	});
+	timer();
+}
+
+//#endregion
+export { create };
+//# sourceMappingURL=create.mjs.map

package/dist/api/create.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.mjs","names":[],"sources":["../../src/api/create.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { listFiles } from \"@stryke/fs/list-files\";\nimport { joinPaths } from \"@stryke/path/join\";\nimport Handlebars from \"handlebars\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Create a new Powerlines project\n *\n * @param context - The execution context for the create process, which provides access to the project configuration, environment, and utility functions for performing the create operation. The context is used to manage the state and behavior of the create process, allowing for hooks to be called at different stages of the create and for environment-specific configurations to be applied.\n */\nexport async function create<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Create a New Project Generation\");\n\n  await prepare<TResolvedConfig, TSystemContext>(context, true);\n  await executeEnvironments(context, async env => {\n    env.debug(\"Initializing the processing options for the project.\");\n\n    await context.callHook(\"create\", {\n      environment: env,\n      order: \"pre\"\n    });\n\n    const files = await listFiles(\n      joinPaths(env.powerlinesPath, \"files/common/**/*.hbs\")\n    );\n    for (const file of files) {\n      env.trace(`Adding template file to project: ${file}`);\n\n      const template = Handlebars.compile(file);\n      await env.fs.write(\n        joinPaths(env.config.root, file.replace(\".hbs\", \"\")),\n        template(env)\n      );\n    }\n\n    await context.callHook(\"create\", {\n      environment: env,\n      order: \"normal\"\n    });\n\n    if (env.config.projectType === \"application\") {\n      const appFiles = await listFiles(\n        joinPaths(env.powerlinesPath, \"files/application/**/*.hbs\")\n      );\n      for (const file of appFiles) {\n        env.trace(`Adding application template file: ${file}`);\n\n        const template = Handlebars.compile(file);\n        await env.fs.write(\n          joinPaths(env.config.root, file.replace(\".hbs\", \"\")),\n          template(env)\n        );\n      }\n    } else {\n      const libFiles = await listFiles(\n        joinPaths(env.powerlinesPath, \"files/library/**/*.hbs\")\n      );\n      for (const file of libFiles) {\n        env.trace(`Adding library template file: ${file}`);\n\n        const template = Handlebars.compile(file);\n        await env.fs.write(\n          joinPaths(env.config.root, file.replace(\".hbs\", \"\")),\n          template(env)\n        );\n      }\n    }\n\n    await context.callHook(\"create\", {\n      environment: env,\n      order: \"post\"\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,eAAsB,OAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,iCAAiC;CAE7D,MAAM,QAAyC,SAAS,IAAI;CAC5D,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,IAAI,MAAM,sDAAsD;EAEhE,MAAM,QAAQ,SAAS,UAAU;GAC/B,aAAa;GACb,OAAO;EACT,CAAC;EAED,MAAM,QAAQ,MAAM,UAClB,UAAU,IAAI,gBAAgB,uBAAuB,CACvD;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,MAAM,oCAAoC,MAAM;GAEpD,MAAM,WAAW,WAAW,QAAQ,IAAI;GACxC,MAAM,IAAI,GAAG,MACX,UAAU,IAAI,OAAO,MAAM,KAAK,QAAQ,QAAQ,EAAE,CAAC,GACnD,SAAS,GAAG,CACd;EACF;EAEA,MAAM,QAAQ,SAAS,UAAU;GAC/B,aAAa;GACb,OAAO;EACT,CAAC;EAED,IAAI,IAAI,OAAO,gBAAgB,eAAe;GAC5C,MAAM,WAAW,MAAM,UACrB,UAAU,IAAI,gBAAgB,4BAA4B,CAC5D;GACA,KAAK,MAAM,QAAQ,UAAU;IAC3B,IAAI,MAAM,qCAAqC,MAAM;IAErD,MAAM,WAAW,WAAW,QAAQ,IAAI;IACxC,MAAM,IAAI,GAAG,MACX,UAAU,IAAI,OAAO,MAAM,KAAK,QAAQ,QAAQ,EAAE,CAAC,GACnD,SAAS,GAAG,CACd;GACF;EACF,OAAO;GACL,MAAM,WAAW,MAAM,UACrB,UAAU,IAAI,gBAAgB,wBAAwB,CACxD;GACA,KAAK,MAAM,QAAQ,UAAU;IAC3B,IAAI,MAAM,iCAAiC,MAAM;IAEjD,MAAM,WAAW,WAAW,QAAQ,IAAI;IACxC,MAAM,IAAI,GAAG,MACX,UAAU,IAAI,OAAO,MAAM,KAAK,QAAQ,QAAQ,EAAE,CAAC,GACnD,SAAS,GAAG,CACd;GACF;EACF;EAEA,MAAM,QAAQ,SAAS,UAAU;GAC/B,aAAa;GACb,OAAO;EACT,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/deploy.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+
+//#region src/api/deploy.ts
+/**
+* Deploy the project's source files to the target environment.
+*
+* @remarks
+* This function serves as the main entry point for the deployment process, orchestrating the execution of deployment hooks across different environments defined in the project configuration. It ensures that all relevant deployment operations are performed in a structured manner, allowing for pre-deployment, main deployment, and post-deployment hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the deployment operation, providing insights into the performance of the deployment process.
+*
+* @param context - The execution context for the deploy process, which provides access to the project configuration, environment, and utility functions for performing the deploy operation. The context is used to manage the state and behavior of the deploy process, allowing for hooks to be called at different stages of the deploy and for environment-specific configurations to be applied.
+*/
+async function deploy(context) {
+	const timer = context.timer("Deployment");
+	await require_api_prepare.prepare(context);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		await context.callHook("deploy", { environment: env });
+	});
+	timer();
+}
+
+//#endregion
+exports.deploy = deploy;

package/dist/api/deploy.d.cts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-DKEmqMrh.cjs";
+import { r as EngineSystemContext } from "../context-D0_a0kRO.cjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/deploy.d.ts
+/**
+ * Deploy the project's source files to the target environment.
+ *
+ * @remarks
+ * This function serves as the main entry point for the deployment process, orchestrating the execution of deployment hooks across different environments defined in the project configuration. It ensures that all relevant deployment operations are performed in a structured manner, allowing for pre-deployment, main deployment, and post-deployment hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the deployment operation, providing insights into the performance of the deployment process.
+ *
+ * @param context - The execution context for the deploy process, which provides access to the project configuration, environment, and utility functions for performing the deploy operation. The context is used to manage the state and behavior of the deploy process, allowing for hooks to be called at different stages of the deploy and for environment-specific configurations to be applied.
+ */
+declare function deploy<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { deploy };
+//# sourceMappingURL=deploy.d.cts.map

package/dist/api/deploy.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.cts","names":[],"sources":["../../src/api/deploy.ts"],"mappings":";;;;;;;AAgCA;;;;;;iBAAsB,MAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/deploy.d.mts

@@ -0,0 +1,17 @@
+import { r as EngineResolvedConfig } from "../config-ByLyzMI0.mjs";
+import { r as EngineSystemContext } from "../context-DcXV6_GL.mjs";
+import { ExecutionContext } from "@powerlines/core";
+
+//#region src/api/deploy.d.ts
+/**
+ * Deploy the project's source files to the target environment.
+ *
+ * @remarks
+ * This function serves as the main entry point for the deployment process, orchestrating the execution of deployment hooks across different environments defined in the project configuration. It ensures that all relevant deployment operations are performed in a structured manner, allowing for pre-deployment, main deployment, and post-deployment hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the deployment operation, providing insights into the performance of the deployment process.
+ *
+ * @param context - The execution context for the deploy process, which provides access to the project configuration, environment, and utility functions for performing the deploy operation. The context is used to manage the state and behavior of the deploy process, allowing for hooks to be called at different stages of the deploy and for environment-specific configurations to be applied.
+ */
+declare function deploy<TResolvedConfig extends EngineResolvedConfig, TSystemContext extends EngineSystemContext>(context: ExecutionContext<TResolvedConfig, TSystemContext>): Promise<void>;
+//#endregion
+export { deploy };
+//# sourceMappingURL=deploy.d.mts.map

package/dist/api/deploy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.mts","names":[],"sources":["../../src/api/deploy.ts"],"mappings":";;;;;;;AAgCA;;;;;;iBAAsB,MAAA,yBACI,oBAAA,yBACD,mBAAA,CAAA,CACvB,OAAA,EAAS,gBAAA,CAAiB,eAAA,EAAiB,cAAA,IAAe,OAAA"}

package/dist/api/deploy.mjs

@@ -0,0 +1,24 @@
+import { prepare } from "./prepare.mjs";
+import { executeEnvironments } from "@powerlines/core/lib/environment";
+
+//#region src/api/deploy.ts
+/**
+* Deploy the project's source files to the target environment.
+*
+* @remarks
+* This function serves as the main entry point for the deployment process, orchestrating the execution of deployment hooks across different environments defined in the project configuration. It ensures that all relevant deployment operations are performed in a structured manner, allowing for pre-deployment, main deployment, and post-deployment hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the deployment operation, providing insights into the performance of the deployment process.
+*
+* @param context - The execution context for the deploy process, which provides access to the project configuration, environment, and utility functions for performing the deploy operation. The context is used to manage the state and behavior of the deploy process, allowing for hooks to be called at different stages of the deploy and for environment-specific configurations to be applied.
+*/
+async function deploy(context) {
+	const timer = context.timer("Deployment");
+	await prepare(context);
+	await executeEnvironments(context, async (env) => {
+		await context.callHook("deploy", { environment: env });
+	});
+	timer();
+}
+
+//#endregion
+export { deploy };
+//# sourceMappingURL=deploy.mjs.map

package/dist/api/deploy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.mjs","names":[],"sources":["../../src/api/deploy.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { ExecutionContext } from \"@powerlines/core\";\nimport { executeEnvironments } from \"@powerlines/core/lib/environment\";\nimport { EngineResolvedConfig } from \"../types/config\";\nimport { EngineSystemContext } from \"../types/context\";\nimport { prepare } from \"./prepare\";\n\n/**\n * Deploy the project's source files to the target environment.\n *\n * @remarks\n * This function serves as the main entry point for the deployment process, orchestrating the execution of deployment hooks across different environments defined in the project configuration. It ensures that all relevant deployment operations are performed in a structured manner, allowing for pre-deployment, main deployment, and post-deployment hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the deployment operation, providing insights into the performance of the deployment process.\n *\n * @param context - The execution context for the deploy process, which provides access to the project configuration, environment, and utility functions for performing the deploy operation. The context is used to manage the state and behavior of the deploy process, allowing for hooks to be called at different stages of the deploy and for environment-specific configurations to be applied.\n */\nexport async function deploy<\n  TResolvedConfig extends EngineResolvedConfig,\n  TSystemContext extends EngineSystemContext\n>(context: ExecutionContext<TResolvedConfig, TSystemContext>) {\n  const timer = context.timer(\"Deployment\");\n\n  await prepare<TResolvedConfig, TSystemContext>(context);\n  await executeEnvironments(context, async env => {\n    await context.callHook(\"deploy\", {\n      environment: env\n    });\n  });\n\n  timer();\n}\n"],"mappings":";;;;;;;;;;;;AAgCA,eAAsB,OAGpB,SAA4D;CAC5D,MAAM,QAAQ,QAAQ,MAAM,YAAY;CAExC,MAAM,QAAyC,OAAO;CACtD,MAAM,oBAAoB,SAAS,OAAM,QAAO;EAC9C,MAAM,QAAQ,SAAS,UAAU,EAC/B,aAAa,IACf,CAAC;CACH,CAAC;CAED,MAAM;AACR"}

package/dist/api/docs.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_api_prepare = require('./prepare.cjs');
+let _powerlines_core_lib_environment = require("@powerlines/core/lib/environment");
+
+//#region src/api/docs.ts
+/**
+* Generate the project's documentation.
+*
+* @remarks
+* This function serves as the main entry point for the documentation generation process, orchestrating the execution of documentation hooks across different environments defined in the project configuration. It ensures that all relevant documentation operations are performed in a structured manner, allowing for pre-documentation, main documentation, and post-documentation hooks to be executed at the appropriate stages of the process. The function also utilizes a timer to measure the duration of the documentation operation, providing insights into the performance of the documentation process.
+*
+* @param context - The execution context for the documentation process, which provides access to the project configuration, environment, and utility functions for performing the documentation operation. The context is used to manage the state and behavior of the documentation process, allowing for hooks to be called at different stages of the documentation and for environment-specific configurations to be applied.
+*/
+async function docs(context) {
+	const timer = context.timer("Documentation");
+	await require_api_prepare.prepare(context);
+	await (0, _powerlines_core_lib_environment.executeEnvironments)(context, async (env) => {
+		await context.callHook("docs", { environment: env });
+	});
+	timer();
+}
+
+//#endregion
+exports.docs = docs;