@shell-shock/core 0.17.8 → 0.17.10

package/dist/_virtual/_rolldown/runtime.cjs

@@ -1 +1,29 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));exports.__toESM=s;
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/api.cjs

@@ -1 +1,148 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require(`./_virtual/_rolldown/runtime.cjs`);const e=require(`./plugin.cjs`);let t=require(`powerlines`);var n=class n{#e;static async fromOptions(r){return new n(await(0,t.createAPI)({...r,framework:`shell-shock`},{plugins:[e.default()]}))}get context(){return this.#e.context}constructor(e){this.#e=e}async clean(e){return this.#e.clean(e)}async prepare(e){return this.#e.prepare(e)}async lint(e){return this.#e.lint(e)}async build(e){return this.#e.build(e)}async docs(e){return this.#e.docs(e)}async finalize(){return this.#e.finalize()}static __type=[`#powerlines`,`options`,()=>n,`fromOptions`,`Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.`,`powerlines`,`constructor`,`inlineConfig`,`clean`,"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",`prepare`,"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",`lint`,"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",`build`,"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",`docs`,"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",`finalize`,`Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.`,`ShellShockAPI`,`The Shell Shock API class.`,'!3!P!2"P7#`0$s?%!P!2&"0\'P!2($`0)?*P!2($`0+?,P!2($`0-?.P!2($`0/?0P!2($`01?2P$`03?45w5?6']};async function r(e){return n.fromOptions({framework:`shell-shock`,cwd:process.cwd(),...e})}r.__type=[`options`,()=>n,`createShellShock`,`Creates a new {@link ShellShockAPI} instance.`,'P!2!P7"`/#?$'],exports.ShellShockAPI=n,exports.createShellShock=r;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_plugin = require('./plugin.cjs');
+let powerlines_api = require("powerlines/api");
+
+//#region src/api.ts
+/**
+* The Shell Shock API class.
+*
+* @remarks
+* This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+*/
+var ShellShockAPI = class ShellShockAPI {
+	#powerlines;
+	/**
+	* Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+	*
+	* @param options - The user configuration options.
+	* @returns A promise that resolves to a {@link ShellShockAPI} instance.
+	*/
+	static async from(options) {
+		const { name, root, cwd, mode, logLevel, organization, configFile, ...pluginOptions } = options;
+		return new ShellShockAPI(await powerlines_api.PowerlinesAPI.from({
+			name,
+			root,
+			cwd: cwd || process.cwd(),
+			mode,
+			logLevel,
+			organization,
+			configFile,
+			framework: "shell-shock"
+		}, {
+			plugins: [require_plugin.default(pluginOptions)],
+			framework: "shell-shock"
+		}));
+	}
+	/**
+	* Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+	*
+	* @returns The current build context.
+	*/
+	get context() {
+		return this.#powerlines.context;
+	}
+	constructor(powerlines) {
+		this.#powerlines = powerlines;
+	}
+	/**
+	* Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+	*
+	* @param inlineConfig - The inline configuration options for the clean operation.
+	* @returns A promise that resolves when the clean operation is complete.
+	*/
+	async clean(inlineConfig) {
+		return this.#powerlines.clean(inlineConfig);
+	}
+	/**
+	* Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+	*
+	* @param inlineConfig - The inline configuration options for the prepare operation.
+	* @returns A promise that resolves when the prepare operation is complete.
+	*/
+	async prepare(inlineConfig) {
+		return this.#powerlines.prepare(inlineConfig);
+	}
+	/**
+	* Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+	*
+	* @param inlineConfig - The inline configuration options for the lint operation.
+	* @returns A promise that resolves when the lint operation is complete.
+	*/
+	async lint(inlineConfig) {
+		return this.#powerlines.lint(inlineConfig);
+	}
+	/**
+	* Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+	*
+	* @param inlineConfig - The inline configuration options for the build operation.
+	* @returns A promise that resolves when the build operation is complete.
+	*/
+	async build(inlineConfig) {
+		return this.#powerlines.build(inlineConfig);
+	}
+	/**
+	* Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+	*
+	* @param inlineConfig - The inline configuration options for the documentation operation.
+	* @returns A promise that resolves when the documentation generation is complete.
+	*/
+	async docs(inlineConfig) {
+		return this.#powerlines.docs(inlineConfig);
+	}
+	/**
+	* Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+	*
+	* @returns A promise that resolves when the finalize operation is complete.
+	*/
+	async finalize() {
+		return this.#powerlines.finalize();
+	}
+	static __type = [
+		"#powerlines",
+		"EngineOptions",
+		"options",
+		() => ShellShockAPI,
+		"from",
+		"Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.",
+		"powerlines",
+		"constructor",
+		"inlineConfig",
+		"clean",
+		"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",
+		"prepare",
+		"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",
+		"lint",
+		"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",
+		"build",
+		"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",
+		"docs",
+		"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",
+		"finalize",
+		"Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.",
+		"ShellShockAPI",
+		"The Shell Shock API class.",
+		"!3!P\"w\"2#P7$`0%s?&!P!2'\"0(P!2)$`0*?+P!2)$`0,?-P!2)$`0.?/P!2)$`00?1P!2)$`02?3P$`04?55w6?7"
+	];
+};
+/**
+* Creates a new {@link ShellShockAPI} instance.
+*
+* @param options - The user configuration options.
+* @returns A promise that resolves to a {@link ShellShockAPI} instance.
+*/
+async function createShellShock(options) {
+	return ShellShockAPI.from(options);
+}
+createShellShock.__type = [
+	"EngineOptions",
+	"options",
+	() => ShellShockAPI,
+	"createShellShock",
+	"Creates a new {@link ShellShockAPI} instance.",
+	"P\"w!2\"P7#`/$?%"
+];
+
+//#endregion
+exports.ShellShockAPI = ShellShockAPI;
+exports.createShellShock = createShellShock;

package/dist/api.d.cts

@@ -1,6 +1,6 @@
-import * as _$powerlines from "powerlines";
-import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, EngineOptions, LintInlineConfig, PrepareInlineConfig } from "powerlines";
-import { PartialKeys } from "@stryke/types";
+import { EngineOptions as EngineOptions$1 } from "./types/config.cjs";
+import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, LintInlineConfig, PrepareInlineConfig } from "powerlines";
+import { PowerlinesExecutionContext } from "powerlines/context";
 
 //#region src/api.d.ts
 /**
@@ -17,13 +17,13 @@ declare class ShellShockAPI {
    * @param options - The user configuration options.
    * @returns A promise that resolves to a {@link ShellShockAPI} instance.
    */
-  static fromOptions(options: EngineOptions): Promise<ShellShockAPI>;
+  static from(options: EngineOptions$1): Promise<ShellShockAPI>;
   /**
    * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
    *
    * @returns The current build context.
    */
-  get context(): _$powerlines.ExecutionContext<_$powerlines.ResolvedConfig>;
+  get context(): PowerlinesExecutionContext;
   private constructor();
   /**
    * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
@@ -73,7 +73,7 @@ declare class ShellShockAPI {
  * @param options - The user configuration options.
  * @returns A promise that resolves to a {@link ShellShockAPI} instance.
  */
-declare function createShellShock(options: PartialKeys<EngineOptions, "cwd" | "framework">): Promise<ShellShockAPI>;
+declare function createShellShock(options: EngineOptions$1): Promise<ShellShockAPI>;
 //#endregion
 export { ShellShockAPI, createShellShock };
 //# sourceMappingURL=api.d.cts.map

package/dist/api.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.cts","names":[],"sources":["../src/api.ts"],"mappings":";;;;;;;;AAqCA;;;cAAa,aAAA;EAAA;EAWR;;;;;;EAAA,OAFiB,WAAA,CAClB,OAAA,EAAS,aAAA,GACR,OAAA,CAAQ,aAAA;EAkDqB;;;;;EAAA,IAlCrB,OAAA,CAAA,GAAO,YAAA,CAAA,gBAAA,CAhBR,YAAA,CAgBQ,cAAA;EAAA,QAIX,WAAA,CAAA;EA2DyB;;;;;;EAjDnB,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EA9B1C;;;;;;EAwCE,OAAA,CAAQ,YAAA,EAAc,mBAAA,GAAsB,OAAA;EAVtC;;;;;;EAoBN,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EAAnB;;;;;;EAUnB,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAUxC;;;;;;EAAA,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EASnB;AAWlC;;;;EAXe,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;;;iBAWL,gBAAA,CACpB,OAAA,EAAS,WAAA,CAAY,aAAA,yBACpB,OAAA,CAAQ,aAAA"}
+{"version":3,"file":"api.d.cts","names":[],"sources":["../src/api.ts"],"mappings":";;;;;;;AAoCA;;;;cAAa,aAAA;EAAA;EA8CW;;;;;;EAAA,OArCF,IAAA,CAAK,OAAA,EAAS,eAAA,GAAgB,OAAA,CAAQ,aAAA;EAiFzB;;;;;EAAA,IA5CtB,OAAA,CAAA,GAAW,0BAAA;EAAA,QAIf,WAAA,CAAA;;;;;;;EAUM,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAd/B;;;;;;EAwBT,OAAA,CAAQ,YAAA,EAAc,mBAAA,GAAsB,OAAA;EAAtB;;;;;;EAUtB,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EAUtC;;;;;;EAAA,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAUF;;;;;AAoBrD;EApBe,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;;;;;;EAStC,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;;;iBAWL,gBAAA,CACpB,OAAA,EAAS,eAAA,GACR,OAAA,CAAQ,aAAA"}

package/dist/api.d.mts

@@ -1,6 +1,6 @@
-import * as _$powerlines from "powerlines";
-import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, EngineOptions, LintInlineConfig, PrepareInlineConfig } from "powerlines";
-import { PartialKeys } from "@stryke/types";
+import { EngineOptions as EngineOptions$1 } from "./types/config.mjs";
+import { BuildInlineConfig, CleanInlineConfig, DocsInlineConfig, LintInlineConfig, PrepareInlineConfig } from "powerlines";
+import { PowerlinesExecutionContext } from "powerlines/context";
 
 //#region src/api.d.ts
 /**
@@ -17,13 +17,13 @@ declare class ShellShockAPI {
    * @param options - The user configuration options.
    * @returns A promise that resolves to a {@link ShellShockAPI} instance.
    */
-  static fromOptions(options: EngineOptions): Promise<ShellShockAPI>;
+  static from(options: EngineOptions$1): Promise<ShellShockAPI>;
   /**
    * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
    *
    * @returns The current build context.
    */
-  get context(): _$powerlines.ExecutionContext<_$powerlines.ResolvedConfig>;
+  get context(): PowerlinesExecutionContext;
   private constructor();
   /**
    * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
@@ -73,7 +73,7 @@ declare class ShellShockAPI {
  * @param options - The user configuration options.
  * @returns A promise that resolves to a {@link ShellShockAPI} instance.
  */
-declare function createShellShock(options: PartialKeys<EngineOptions, "cwd" | "framework">): Promise<ShellShockAPI>;
+declare function createShellShock(options: EngineOptions$1): Promise<ShellShockAPI>;
 //#endregion
 export { ShellShockAPI, createShellShock };
 //# sourceMappingURL=api.d.mts.map

package/dist/api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.mts","names":[],"sources":["../src/api.ts"],"mappings":";;;;;;;;AAqCA;;;cAAa,aAAA;EAAA;EAWR;;;;;;EAAA,OAFiB,WAAA,CAClB,OAAA,EAAS,aAAA,GACR,OAAA,CAAQ,aAAA;EAkDqB;;;;;EAAA,IAlCrB,OAAA,CAAA,GAAO,YAAA,CAAA,gBAAA,CAhBR,YAAA,CAgBQ,cAAA;EAAA,QAIX,WAAA,CAAA;EA2DyB;;;;;;EAjDnB,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EA9B1C;;;;;;EAwCE,OAAA,CAAQ,YAAA,EAAc,mBAAA,GAAsB,OAAA;EAVtC;;;;;;EAoBN,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EAAnB;;;;;;EAUnB,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAUxC;;;;;;EAAA,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EASnB;AAWlC;;;;EAXe,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;;;iBAWL,gBAAA,CACpB,OAAA,EAAS,WAAA,CAAY,aAAA,yBACpB,OAAA,CAAQ,aAAA"}
+{"version":3,"file":"api.d.mts","names":[],"sources":["../src/api.ts"],"mappings":";;;;;;;AAoCA;;;;cAAa,aAAA;EAAA;EA8CW;;;;;;EAAA,OArCF,IAAA,CAAK,OAAA,EAAS,eAAA,GAAgB,OAAA,CAAQ,aAAA;EAiFzB;;;;;EAAA,IA5CtB,OAAA,CAAA,GAAW,0BAAA;EAAA,QAIf,WAAA,CAAA;;;;;;;EAUM,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAd/B;;;;;;EAwBT,OAAA,CAAQ,YAAA,EAAc,mBAAA,GAAsB,OAAA;EAAtB;;;;;;EAUtB,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;EAUtC;;;;;;EAAA,KAAA,CAAM,YAAA,EAAc,iBAAA,GAAoB,OAAA;EAUF;;;;;AAoBrD;EApBe,IAAA,CAAK,YAAA,EAAc,gBAAA,GAAmB,OAAA;;;;;;EAStC,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;;;iBAWL,gBAAA,CACpB,OAAA,EAAS,eAAA,GACR,OAAA,CAAQ,aAAA"}

package/dist/api.mjs

@@ -1,2 +1,146 @@
-import e from"./plugin.mjs";import{createAPI as t}from"powerlines";var n=class n{#e;static async fromOptions(r){return new n(await t({...r,framework:`shell-shock`},{plugins:[e()]}))}get context(){return this.#e.context}constructor(e){this.#e=e}async clean(e){return this.#e.clean(e)}async prepare(e){return this.#e.prepare(e)}async lint(e){return this.#e.lint(e)}async build(e){return this.#e.build(e)}async docs(e){return this.#e.docs(e)}async finalize(){return this.#e.finalize()}static __type=[`#powerlines`,`options`,()=>n,`fromOptions`,`Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.`,`powerlines`,`constructor`,`inlineConfig`,`clean`,"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",`prepare`,"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",`lint`,"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",`build`,"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",`docs`,"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",`finalize`,`Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.`,`ShellShockAPI`,`The Shell Shock API class.`,'!3!P!2"P7#`0$s?%!P!2&"0\'P!2($`0)?*P!2($`0+?,P!2($`0-?.P!2($`0/?0P!2($`01?2P$`03?45w5?6']};async function r(e){return n.fromOptions({framework:`shell-shock`,cwd:process.cwd(),...e})}r.__type=[`options`,()=>n,`createShellShock`,`Creates a new {@link ShellShockAPI} instance.`,'P!2!P7"`/#?$'];export{n as ShellShockAPI,r as createShellShock};
+import plugin from "./plugin.mjs";
+import { PowerlinesAPI } from "powerlines/api";
+
+//#region src/api.ts
+/**
+* The Shell Shock API class.
+*
+* @remarks
+* This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.
+*/
+var ShellShockAPI = class ShellShockAPI {
+	#powerlines;
+	/**
+	* Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.
+	*
+	* @param options - The user configuration options.
+	* @returns A promise that resolves to a {@link ShellShockAPI} instance.
+	*/
+	static async from(options) {
+		const { name, root, cwd, mode, logLevel, organization, configFile, ...pluginOptions } = options;
+		return new ShellShockAPI(await PowerlinesAPI.from({
+			name,
+			root,
+			cwd: cwd || process.cwd(),
+			mode,
+			logLevel,
+			organization,
+			configFile,
+			framework: "shell-shock"
+		}, {
+			plugins: [plugin(pluginOptions)],
+			framework: "shell-shock"
+		}));
+	}
+	/**
+	* Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.
+	*
+	* @returns The current build context.
+	*/
+	get context() {
+		return this.#powerlines.context;
+	}
+	constructor(powerlines) {
+		this.#powerlines = powerlines;
+	}
+	/**
+	* Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.
+	*
+	* @param inlineConfig - The inline configuration options for the clean operation.
+	* @returns A promise that resolves when the clean operation is complete.
+	*/
+	async clean(inlineConfig) {
+		return this.#powerlines.clean(inlineConfig);
+	}
+	/**
+	* Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.
+	*
+	* @param inlineConfig - The inline configuration options for the prepare operation.
+	* @returns A promise that resolves when the prepare operation is complete.
+	*/
+	async prepare(inlineConfig) {
+		return this.#powerlines.prepare(inlineConfig);
+	}
+	/**
+	* Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.
+	*
+	* @param inlineConfig - The inline configuration options for the lint operation.
+	* @returns A promise that resolves when the lint operation is complete.
+	*/
+	async lint(inlineConfig) {
+		return this.#powerlines.lint(inlineConfig);
+	}
+	/**
+	* Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.
+	*
+	* @param inlineConfig - The inline configuration options for the build operation.
+	* @returns A promise that resolves when the build operation is complete.
+	*/
+	async build(inlineConfig) {
+		return this.#powerlines.build(inlineConfig);
+	}
+	/**
+	* Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.
+	*
+	* @param inlineConfig - The inline configuration options for the documentation operation.
+	* @returns A promise that resolves when the documentation generation is complete.
+	*/
+	async docs(inlineConfig) {
+		return this.#powerlines.docs(inlineConfig);
+	}
+	/**
+	* Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.
+	*
+	* @returns A promise that resolves when the finalize operation is complete.
+	*/
+	async finalize() {
+		return this.#powerlines.finalize();
+	}
+	static __type = [
+		"#powerlines",
+		"EngineOptions",
+		"options",
+		() => ShellShockAPI,
+		"from",
+		"Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.",
+		"powerlines",
+		"constructor",
+		"inlineConfig",
+		"clean",
+		"Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.",
+		"prepare",
+		"Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.",
+		"lint",
+		"Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.",
+		"build",
+		"Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.",
+		"docs",
+		"Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.",
+		"finalize",
+		"Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.",
+		"ShellShockAPI",
+		"The Shell Shock API class.",
+		"!3!P\"w\"2#P7$`0%s?&!P!2'\"0(P!2)$`0*?+P!2)$`0,?-P!2)$`0.?/P!2)$`00?1P!2)$`02?3P$`04?55w6?7"
+	];
+};
+/**
+* Creates a new {@link ShellShockAPI} instance.
+*
+* @param options - The user configuration options.
+* @returns A promise that resolves to a {@link ShellShockAPI} instance.
+*/
+async function createShellShock(options) {
+	return ShellShockAPI.from(options);
+}
+createShellShock.__type = [
+	"EngineOptions",
+	"options",
+	() => ShellShockAPI,
+	"createShellShock",
+	"Creates a new {@link ShellShockAPI} instance.",
+	"P\"w!2\"P7#`/$?%"
+];
+
+//#endregion
+export { ShellShockAPI, createShellShock };
 //# sourceMappingURL=api.mjs.map

package/dist/api.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"api.mjs","names":[],"sources":["../src/api.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                  ⚡ Storm Software - Shell Shock\n\n This code was released as part of the Shell Shock project. Shell Shock\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/shell-shock.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/shell-shock\n Documentation:            https://docs.stormsoftware.com/projects/shell-shock\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { PartialKeys } from \"@stryke/types\";\nimport type {\n  BuildInlineConfig,\n  CleanInlineConfig,\n  DocsInlineConfig,\n  EngineOptions,\n  LintInlineConfig,\n  PowerlinesAPI,\n  PrepareInlineConfig\n} from \"powerlines\";\nimport { createAPI } from \"powerlines\";\nimport { plugin } from \"./plugin\";\n\n/**\n * The Shell Shock API class.\n *\n * @remarks\n * This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.\n */\nexport class ShellShockAPI {\n  #powerlines: PowerlinesAPI;\n\n  /**\n   * Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.\n   *\n   * @param options - The user configuration options.\n   * @returns A promise that resolves to a {@link ShellShockAPI} instance.\n   */\n  public static async fromOptions(\n    options: EngineOptions\n  ): Promise<ShellShockAPI> {\n    const powerlines = await createAPI(\n      { ...options, framework: \"shell-shock\" },\n      {\n        plugins: [plugin()]\n      }\n    );\n\n    return new ShellShockAPI(powerlines);\n  }\n\n  /**\n   * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.\n   *\n   * @returns The current build context.\n   */\n  public get context() {\n    return this.#powerlines.context;\n  }\n\n  private constructor(powerlines: PowerlinesAPI) {\n    this.#powerlines = powerlines;\n  }\n\n  /**\n   * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.\n   *\n   * @param inlineConfig - The inline configuration options for the clean operation.\n   * @returns A promise that resolves when the clean operation is complete.\n   */\n  public async clean(inlineConfig: CleanInlineConfig): Promise<void> {\n    return this.#powerlines.clean(inlineConfig);\n  }\n\n  /**\n   * Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.\n   *\n   * @param inlineConfig - The inline configuration options for the prepare operation.\n   * @returns A promise that resolves when the prepare operation is complete.\n   */\n  public async prepare(inlineConfig: PrepareInlineConfig): Promise<void> {\n    return this.#powerlines.prepare(inlineConfig);\n  }\n\n  /**\n   * Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.\n   *\n   * @param inlineConfig - The inline configuration options for the lint operation.\n   * @returns A promise that resolves when the lint operation is complete.\n   */\n  public async lint(inlineConfig: LintInlineConfig): Promise<void> {\n    return this.#powerlines.lint(inlineConfig);\n  }\n\n  /**\n   * Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.\n   *\n   * @param inlineConfig - The inline configuration options for the build operation.\n   * @returns A promise that resolves when the build operation is complete.\n   */\n  public async build(inlineConfig: BuildInlineConfig): Promise<void> {\n    return this.#powerlines.build(inlineConfig);\n  }\n\n  /**\n   * Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.\n   *\n   * @param inlineConfig - The inline configuration options for the documentation operation.\n   * @returns A promise that resolves when the documentation generation is complete.\n   */\n  public async docs(inlineConfig: DocsInlineConfig): Promise<void> {\n    return this.#powerlines.docs(inlineConfig);\n  }\n\n  /**\n   * Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.\n   *\n   * @returns A promise that resolves when the finalize operation is complete.\n   */\n  public async finalize(): Promise<void> {\n    return this.#powerlines.finalize();\n  }\n}\n\n/**\n * Creates a new {@link ShellShockAPI} instance.\n *\n * @param options - The user configuration options.\n * @returns A promise that resolves to a {@link ShellShockAPI} instance.\n */\nexport async function createShellShock(\n  options: PartialKeys<EngineOptions, \"cwd\" | \"framework\">\n): Promise<ShellShockAPI> {\n  return ShellShockAPI.fromOptions({\n    framework: \"shell-shock\",\n    cwd: process.cwd(),\n    ...options\n  });\n}\n"],"mappings":"mEAyBA,IAAE,EAAF,MAAE,CAAa,CACb,GAOD,aAAA,YAAA,EAAA,CAOG,OAAA,IAAA,EAAA,MANA,EAAA,CACD,GAAK,EACN,UAAA,cACF,CAAO,CACJ,QAAY,CAAA,GAAA,CAAA,CAAA,CAAA,CAEX,CAOF,IAAE,SAAS,CACT,OAAC,MAAA,EAAuB,QAE1B,YAAS,EAAS,CAChB,MAAA,EAAE,EAQJ,MAAE,MAAA,EAAA,CACA,OAAM,MAAA,EAAkB,MAAA,EAAe,CAQzC,MAAA,QAAQ,EAAY,CAClB,OAAM,MAAA,EAAa,QAAU,EAAA,CAQ/B,MAAE,KAAA,EAAA,CACF,OAAO,MAAA,EAAY,KAAY,EAAE,CAQjC,MAAI,MAAQ,EAAc,CACxB,OAAA,MAAA,EAAA,MAAA,EAAA,CAQF,MAAI,KAAM,EAAe,CACvB,OAAE,MAAA,EAAsB,KAAC,EAAiB,CAO5C,MAAG,UAAa,CACf,OAAA,MAAA,EAAA,UAAA,CAED,OAAI,OAAU,CAAA,cAAa,cAAkB,EAAmB,cAAQ,uNAAA,aAAA,cAAA,eAAA,QAAA,sPAAA,UAAA,0PAAA,OAAA,mOAAA,QAAA,+OAAA,OAAA,+QAAA,WAAA,0LAAA,gBAAA,6BAAA,0FAAA,EAQ1E,eAAG,EAAA,EAAA,CACD,OAAI,EAAM,YAAmB,CAC3B,UAAW,cACX,IAAA,QAAA,KAAA,CACF,GAAA,EACC,CAAC"}
+{"version":3,"file":"api.mjs","names":[],"sources":["../src/api.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                  ⚡ Storm Software - Shell Shock\n\n This code was released as part of the Shell Shock project. Shell Shock\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/shell-shock.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/shell-shock\n Documentation:            https://docs.stormsoftware.com/projects/shell-shock\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type {\n  BuildInlineConfig,\n  CleanInlineConfig,\n  DocsInlineConfig,\n  LintInlineConfig,\n  PrepareInlineConfig\n} from \"powerlines\";\nimport { PowerlinesAPI } from \"powerlines/api\";\nimport type { PowerlinesExecutionContext } from \"powerlines/context\";\nimport { plugin } from \"./plugin\";\nimport type { EngineOptions } from \"./types/config\";\n\n/**\n * The Shell Shock API class.\n *\n * @remarks\n * This class provides methods to interact with the Shell Shock build system, including cleaning, preparing, linting, building, generating documentation, and finalizing projects.\n */\nexport class ShellShockAPI {\n  #powerlines: PowerlinesAPI;\n\n  /**\n   * Creates a new instance of the {@link ShellShockAPI} class using the provided configuration options. This method initializes the underlying Powerlines API with the appropriate plugins and settings for Shell Shock.\n   *\n   * @param options - The user configuration options.\n   * @returns A promise that resolves to a {@link ShellShockAPI} instance.\n   */\n  public static async from(options: EngineOptions): Promise<ShellShockAPI> {\n    const {\n      name,\n      root,\n      cwd,\n      mode,\n      logLevel,\n      organization,\n      configFile,\n      ...pluginOptions\n    } = options;\n\n    const powerlines = await PowerlinesAPI.from(\n      {\n        name,\n        root,\n        cwd: cwd || process.cwd(),\n        mode,\n        logLevel,\n        organization,\n        configFile,\n        framework: \"shell-shock\"\n      },\n      {\n        plugins: [plugin(pluginOptions)],\n        framework: \"shell-shock\"\n      }\n    );\n\n    return new ShellShockAPI(powerlines);\n  }\n\n  /**\n   * Gets the current build context, which includes information about the project, environment, and configuration. This context is used internally by the Shell Shock API to manage the build process and provide relevant data to plugins and other components.\n   *\n   * @returns The current build context.\n   */\n  public get context(): PowerlinesExecutionContext {\n    return this.#powerlines.context;\n  }\n\n  private constructor(powerlines: PowerlinesAPI) {\n    this.#powerlines = powerlines;\n  }\n\n  /**\n   * Executes the clean phase of the build process, which typically involves removing generated files and resetting the build environment. The `inlineConfig` parameter allows users to specify additional options or overrides for the clean operation.\n   *\n   * @param inlineConfig - The inline configuration options for the clean operation.\n   * @returns A promise that resolves when the clean operation is complete.\n   */\n  public async clean(inlineConfig: CleanInlineConfig): Promise<void> {\n    return this.#powerlines.clean(inlineConfig);\n  }\n\n  /**\n   * Executes the prepare phase of the build process, which typically involves setting up the build environment and installing dependencies. The `inlineConfig` parameter allows users to specify additional options or overrides for the prepare operation.\n   *\n   * @param inlineConfig - The inline configuration options for the prepare operation.\n   * @returns A promise that resolves when the prepare operation is complete.\n   */\n  public async prepare(inlineConfig: PrepareInlineConfig): Promise<void> {\n    return this.#powerlines.prepare(inlineConfig);\n  }\n\n  /**\n   * Executes the lint phase of the build process, which typically involves analyzing code for quality and style issues. The `inlineConfig` parameter allows users to specify additional options or overrides for the lint operation.\n   *\n   * @param inlineConfig - The inline configuration options for the lint operation.\n   * @returns A promise that resolves when the lint operation is complete.\n   */\n  public async lint(inlineConfig: LintInlineConfig): Promise<void> {\n    return this.#powerlines.lint(inlineConfig);\n  }\n\n  /**\n   * Executes the build phase of the build process, which typically involves compiling source code and generating output artifacts. The `inlineConfig` parameter allows users to specify additional options or overrides for the build operation.\n   *\n   * @param inlineConfig - The inline configuration options for the build operation.\n   * @returns A promise that resolves when the build operation is complete.\n   */\n  public async build(inlineConfig: BuildInlineConfig): Promise<void> {\n    return this.#powerlines.build(inlineConfig);\n  }\n\n  /**\n   * Executes the documentation generation phase of the build process, which typically involves creating API documentation and other project documentation. The `inlineConfig` parameter allows users to specify additional options or overrides for the documentation operation.\n   *\n   * @param inlineConfig - The inline configuration options for the documentation operation.\n   * @returns A promise that resolves when the documentation generation is complete.\n   */\n  public async docs(inlineConfig: DocsInlineConfig): Promise<void> {\n    return this.#powerlines.docs(inlineConfig);\n  }\n\n  /**\n   * Executes the finalize phase of the build process, which typically involves cleanup tasks and final reporting. This method should be called after all other build phases have completed.\n   *\n   * @returns A promise that resolves when the finalize operation is complete.\n   */\n  public async finalize(): Promise<void> {\n    return this.#powerlines.finalize();\n  }\n}\n\n/**\n * Creates a new {@link ShellShockAPI} instance.\n *\n * @param options - The user configuration options.\n * @returns A promise that resolves to a {@link ShellShockAPI} instance.\n */\nexport async function createShellShock(\n  options: EngineOptions\n): Promise<ShellShockAPI> {\n  return ShellShockAPI.from(options);\n}\n"],"mappings":";;;;;;;;;;AAyBA,IAAS,gBAAT,MAAS,cAAgB;CACzB;;;;;;;CAOE,aAAE,KAAA,SAAA;EACD,MAAK,EACN,MACI,MACH,WAEC,UACC,cACF,YACG,GAAA,kBACA;AAcF,SAAM,IAAA,cAAmB,MAbzB,cAAA,KAAA;GACF;GACE;GACE,KAAI,OAAA,QAAA,KAAA;GACJ;GACA;GACA;GACA;GACA,WAAA;GACD,EAAC;GACA,SAAG,CAAA,OAAA,cAAA,CAAA;GACH,WAAS;KAEc;;;;;;;CAO3B,IAAI,UAAE;AACJ,SAAI,MAAA,WAAU;;CAEhB,YAAK,YAAA;AACH,QAAE,aAAA;;;;;;;;;AASF,SAAA,MAAA,WAAA,MAAA,aAAA;;;;;;;;;AASF,SAAQ,MAAA,WAAY,QAAY,aAAe;;;;;;;;CAQ/C,MAAI,KAAO,cAAW;AACpB,SAAA,MAAA,WAAA,KAAA,aAAA;;;;;;;;CAQF,MAAI,MAAM,cAAe;AACvB,SAAE,MAAU,WAAY,MAAC,aAAkB;;;;;;;;CAQ7C,MAAC,KAAA,cAAA;AACC,SAAO,MAAC,WAAe,KAAI,aAAO;;;;;;;CAOpC,MAAE,WAAA;AACA,SAAC,MAAS,WAAU,UAAa;;CAEnC,OAAI,SAAM;EAAA;EAAmB;EAAoB;QAAiB;EAAe;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;EAAA;;;;;;;;AAQnF,eAAkB,iBAAc,SAAgB;AAC9C,QAAC,cAAA,KAAA,QAAA;;AAEH,iBAAgB,SAAQ;CAAA;CAAmB;OAAkB;CAAc;CAAQ;CAAA;CAAA"}