@powerlines/plugin-webpack 0.5.132 → 0.5.134

package/dist/powerlines/src/lib/contexts/context.cjs

@@ -0,0 +1,933 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_ts_morph = require('../typescript/ts-morph.cjs');
+const require_tsconfig = require('../typescript/tsconfig.cjs');
+const require_config_file = require('../config-file.cjs');
+const require_resolver = require('../../internal/helpers/resolver.cjs');
+const require_helpers = require('../../plugin-utils/helpers.cjs');
+const require_paths = require('../../plugin-utils/paths.cjs');
+const require_entry = require('../entry.cjs');
+const require_logger = require('../logger.cjs');
+const require_vfs = require('../fs/vfs.cjs');
+const require_meta = require('../utilities/meta.cjs');
+let __storm_software_config_tools_types = require("@storm-software/config-tools/types");
+let defu = require("defu");
+defu = require_rolldown_runtime.__toESM(defu);
+let __stryke_helpers_omit = require("@stryke/helpers/omit");
+let __stryke_fs_get_workspace_root = require("@stryke/fs/get-workspace-root");
+let __stryke_convert_to_array = require("@stryke/convert/to-array");
+let __stryke_fs_resolve = require("@stryke/fs/resolve");
+let __stryke_path_append = require("@stryke/path/append");
+let __stryke_path_replace = require("@stryke/path/replace");
+let __stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let __stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let __stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let __stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
+let __stryke_fs_json = require("@stryke/fs/json");
+let __stryke_json_storm_json = require("@stryke/json/storm-json");
+let __stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let __stryke_fs_exists = require("@stryke/fs/exists");
+let __stryke_env_get_env_paths = require("@stryke/env/get-env-paths");
+let __stryke_hash_hash_files = require("@stryke/hash/hash-files");
+let __stryke_hash_murmurhash = require("@stryke/hash/murmurhash");
+let __stryke_helpers_get_unique = require("@stryke/helpers/get-unique");
+let __stryke_http_fetch = require("@stryke/http/fetch");
+let __stryke_path_is_parent_path = require("@stryke/path/is-parent-path");
+let __stryke_path_is_type = require("@stryke/path/is-type");
+let __stryke_path_join = require("@stryke/path/join");
+let __stryke_type_checks_is_null = require("@stryke/type-checks/is-null");
+let __stryke_unique_id_uuid = require("@stryke/unique-id/uuid");
+let bundle_require = require("bundle-require");
+let flat_cache = require("flat-cache");
+let oxc_parser = require("oxc-parser");
+let undici = require("undici");
+
+//#region ../powerlines/src/lib/contexts/context.ts
+const configCache = /* @__PURE__ */ new WeakMap();
+const envPathCache = /* @__PURE__ */ new WeakMap();
+(0, undici.setGlobalDispatcher)(new undici.Agent({ keepAliveTimeout: 1e4 }).compose(undici.interceptors.retry({
+	maxRetries: 3,
+	minTimeout: 1e3,
+	maxTimeout: 1e4,
+	timeoutFactor: 2,
+	retryAfter: true
+})));
+var PowerlinesContext = class PowerlinesContext {
+	/**
+	* Internal references storage
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	#internal = {};
+	#workspaceConfig;
+	#checksum = null;
+	#buildId = (0, __stryke_unique_id_uuid.uuid)();
+	#releaseId = (0, __stryke_unique_id_uuid.uuid)();
+	#timestamp = Date.now();
+	#entry = null;
+	#fs;
+	#tsconfig;
+	#program;
+	#parserCache;
+	#requestCache;
+	#getConfigProps(config = {}) {
+		return (0, defu.default)({
+			variant: config.build?.variant,
+			projectType: config.type,
+			projectRoot: config.root,
+			name: config.name,
+			title: config.title,
+			organization: config.organization,
+			compatibilityDate: config.compatibilityDate,
+			description: config.description,
+			sourceRoot: config.sourceRoot,
+			configFile: config.configFile,
+			customLogger: config.customLogger,
+			logLevel: config.logLevel,
+			tsconfig: config.tsconfig,
+			tsconfigRaw: config.tsconfigRaw,
+			skipCache: config.skipCache,
+			skipInstalls: config.skipInstalls,
+			entry: config.entry,
+			output: config.output,
+			plugins: config.plugins,
+			mode: config.mode,
+			lint: config.lint,
+			transform: config.transform,
+			build: config.build,
+			framework: config.framework,
+			...config
+		}, { output: config.framework ? {
+			artifactsPath: (0, __stryke_path_join.joinPaths)(config.root ?? this.config.projectRoot, `.${config.framework ?? "powerlines"}`),
+			dts: (0, __stryke_path_join.joinPaths)(config.root ?? this.config.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
+			builtinPrefix: config.framework ?? "powerlines"
+		} : {} });
+	}
+	/**
+	* Create a new Storm context from the workspace root and user config.
+	*
+	* @param workspaceRoot - The root directory of the workspace.
+	* @param config - The user configuration options.
+	* @returns A promise that resolves to the new context.
+	*/
+	static async from(workspaceRoot, config) {
+		const context = new PowerlinesContext(await require_config_file.loadWorkspaceConfig(workspaceRoot, config.root));
+		await context.withUserConfig(config);
+		const powerlinesPath = await (0, __stryke_fs_resolve.resolvePackage)("powerlines");
+		if (!powerlinesPath) throw new Error("Could not resolve `powerlines` package location.");
+		context.powerlinesPath = powerlinesPath;
+		return context;
+	}
+	/**
+	* An object containing the dependencies that should be installed for the project
+	*/
+	dependencies = {};
+	/**
+	* An object containing the development dependencies that should be installed for the project
+	*/
+	devDependencies = {};
+	/**
+	* The persisted meta information about the current build
+	*/
+	persistedMeta = void 0;
+	/**
+	* The path to the Powerlines package
+	*/
+	powerlinesPath;
+	/**
+	* The parsed `package.json` file for the project
+	*/
+	packageJson;
+	/**
+	* The parsed `project.json` file for the project
+	*/
+	projectJson = void 0;
+	/**
+	* The module resolver for the project
+	*/
+	resolver;
+	/**
+	* The resolved configuration options
+	*/
+	resolvePatterns = [];
+	/**
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	get $$internal() {
+		return this.#internal;
+	}
+	/**
+	* Internal context fields and methods
+	*
+	* @danger
+	* This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+	*
+	* @internal
+	*/
+	set $$internal(value) {
+		this.#internal = value;
+	}
+	/**
+	* The resolved entry type definitions for the project
+	*/
+	get entry() {
+		return require_entry.resolveEntriesSync(this, !this.#entry ? (0, __stryke_convert_to_array.toArray)(this.config.entry) : this.#entry);
+	}
+	/**
+	* Sets the resolved entry type definitions for the project
+	*/
+	set entry(value) {
+		this.#entry = value;
+	}
+	/**
+	* The TypeScript configuration parsed from the tsconfig file
+	*/
+	get tsconfig() {
+		if (!this.#tsconfig) this.tsconfig = { tsconfigFilePath: this.config.tsconfig };
+		return this.#tsconfig;
+	}
+	/**
+	* Sets the TypeScript configuration parsed from the tsconfig file
+	*/
+	set tsconfig(value) {
+		this.#tsconfig = value;
+		this.resolvePatterns = (0, bundle_require.tsconfigPathsToRegExp)(value?.options?.paths ?? {});
+	}
+	/**
+	* The virtual file system interface for the project
+	*/
+	get fs() {
+		if (!this.#fs) this.#fs = require_vfs.VirtualFileSystem.createSync(this);
+		return this.#fs;
+	}
+	/**
+	* Get the checksum of the project's current state
+	*/
+	get checksum() {
+		return this.#checksum;
+	}
+	/**
+	* The meta information about the current build
+	*/
+	get meta() {
+		return {
+			buildId: this.#buildId,
+			releaseId: this.#releaseId,
+			checksum: this.#checksum,
+			timestamp: this.#timestamp,
+			projectRootHash: (0, __stryke_hash_murmurhash.murmurhash)({
+				workspaceRoot: this.workspaceConfig?.workspaceRoot,
+				projectRoot: this.config?.projectRoot
+			}, { maxLength: require_meta.PROJECT_ROOT_HASH_LENGTH }),
+			configHash: (0, __stryke_hash_murmurhash.murmurhash)(this.config, { maxLength: require_meta.CACHE_HASH_LENGTH })
+		};
+	}
+	/**
+	* The resolved configuration options
+	*/
+	get config() {
+		return this.resolvedConfig ?? {};
+	}
+	/**
+	* The logger function
+	*/
+	get log() {
+		if (!this.logFn) this.logFn = this.createLog();
+		return this.logFn;
+	}
+	/**
+	* The workspace configuration
+	*/
+	get workspaceConfig() {
+		return this.#workspaceConfig;
+	}
+	/**
+	* The environment paths for the project
+	*/
+	get envPaths() {
+		if (envPathCache.has({
+			workspaceRoot: this.workspaceConfig.workspaceRoot,
+			framework: this.config?.framework || "powerlines"
+		})) return envPathCache.get({
+			workspaceRoot: this.workspaceConfig.workspaceRoot,
+			framework: this.config?.framework || "powerlines"
+		});
+		const envPaths = (0, __stryke_env_get_env_paths.getEnvPaths)({
+			orgId: "storm-software",
+			appId: this.config?.framework || "powerlines",
+			workspaceRoot: this.workspaceConfig.workspaceRoot
+		});
+		envPathCache.set({
+			workspaceRoot: this.workspaceConfig.workspaceRoot,
+			framework: this.config?.framework || "powerlines"
+		}, envPaths);
+		return envPaths;
+	}
+	/**
+	* Get the path to the artifacts directory for the project
+	*/
+	get artifactsPath() {
+		return (0, __stryke_path_join.joinPaths)(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsPath);
+	}
+	/**
+	* Get the path to the builtin modules used by the project
+	*/
+	get builtinsPath() {
+		return (0, __stryke_path_join.joinPaths)(this.artifactsPath, "builtins");
+	}
+	/**
+	* Get the path to the entry directory for the project
+	*/
+	get entryPath() {
+		return (0, __stryke_path_join.joinPaths)(this.artifactsPath, "entry");
+	}
+	/**
+	* Get the path to the data directory for the project
+	*/
+	get dataPath() {
+		return (0, __stryke_path_join.joinPaths)(this.envPaths.data, "projects", require_meta.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+	}
+	/**
+	* Get the path to the cache directory for the project
+	*/
+	get cachePath() {
+		return (0, __stryke_path_join.joinPaths)(this.envPaths.cache, "projects", (0, __stryke_hash_murmurhash.murmurhash)({
+			checksum: this.#checksum,
+			config: this.meta.configHash
+		}, { maxLength: require_meta.CACHE_HASH_LENGTH }));
+	}
+	/**
+	* Get the path to the generated declaration file for the project
+	*/
+	get dtsPath() {
+		return this.config.output.dts ? (0, __stryke_path_append.appendPath)(this.config.output.dts, this.workspaceConfig.workspaceRoot) : (0, __stryke_path_join.joinPaths)(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "powerlines.d.ts");
+	}
+	/**
+	* Get the project root relative to the workspace root
+	*/
+	get relativeToWorkspaceRoot() {
+		return (0, __stryke_fs_get_workspace_root.relativeToWorkspaceRoot)(this.config.projectRoot);
+	}
+	/**
+	* The builtin module id that exist in the Powerlines virtual file system
+	*/
+	get builtins() {
+		return Object.values(this.fs.metadata).filter((meta) => meta && meta.type === "builtin").map((meta) => meta?.id).filter(Boolean);
+	}
+	/**
+	* The {@link Project} instance used for type reflection and module manipulation
+	*
+	* @see https://ts-morph.com/
+	*
+	* @remarks
+	* This instance is created lazily on first access.
+	*/
+	get program() {
+		if (!this.#program) this.#program = require_ts_morph.createProgram(this, { skipAddingFilesFromTsConfig: true });
+		return this.#program;
+	}
+	/**
+	* Gets the parser cache.
+	*/
+	get parserCache() {
+		if (!this.#parserCache) this.#parserCache = (0, flat_cache.create)({
+			cacheId: "parser",
+			cacheDir: this.cachePath,
+			ttl: 7200 * 1e3,
+			lruSize: 5e3,
+			persistInterval: 250
+		});
+		return this.#parserCache;
+	}
+	/**
+	* Gets the request cache.
+	*/
+	get requestCache() {
+		if (!this.#requestCache) this.#requestCache = (0, flat_cache.create)({
+			cacheId: "http",
+			cacheDir: this.cachePath,
+			ttl: 360 * 60 * 1e3,
+			lruSize: 5e3,
+			persistInterval: 250
+		});
+		return this.#requestCache;
+	}
+	/**
+	* A function to perform HTTP fetch requests
+	*
+	* @remarks
+	* This function uses a caching layer to avoid duplicate requests during the Powerlines process.
+	*
+	* @example
+	* ```ts
+	* const response = await context.fetch("https://api.example.com/data");
+	* const data = await response.json();
+	* ```
+	*
+	* @see https://github.com/nodejs/undici
+	*
+	* @param input - The URL to fetch.
+	* @param options - The fetch request options.
+	* @returns A promise that resolves to a response returned by the fetch.
+	*/
+	async fetch(input, options = {}) {
+		const cacheKey = (0, __stryke_hash_murmurhash.murmurhash)({
+			input: input.toString(),
+			options: JSON.stringify(options)
+		});
+		if (!this.config.skipCache && !options.skipCache) {
+			const cached = this.requestCache.get(cacheKey);
+			if (cached) return new undici.Response(cached.body, {
+				status: cached.status,
+				statusText: cached.statusText,
+				headers: cached.headers
+			});
+		}
+		const response = await (0, __stryke_http_fetch.fetchRequest)(input, {
+			timeout: 12e3,
+			...options
+		});
+		const result = {
+			body: await response.text(),
+			status: response.status,
+			statusText: response.statusText,
+			headers: Object.fromEntries(response.headers.entries())
+		};
+		if (!this.config.skipCache && !options.skipCache) try {
+			this.requestCache.set(cacheKey, result);
+		} catch {}
+		return new undici.Response(result.body, {
+			status: result.status,
+			statusText: result.statusText,
+			headers: result.headers
+		});
+	}
+	/**
+	* Parse code using [Oxc-Parser](https://github.com/oxc/oxc) into an (ESTree-compatible)[https://github.com/estree/estree] AST object.
+	*
+	* @remarks
+	* This function can be used to parse TypeScript code into an AST for further analysis or transformation.
+	*
+	* @example
+	* ```ts
+	* const ast = context.parse("const x: number = 42;");
+	* ```
+	*
+	* @see https://rollupjs.org/plugin-development/#this-parse
+	* @see https://github.com/oxc/oxc
+	*
+	* @param code - The source code to parse.
+	* @param options - The options to pass to the parser.
+	* @returns An (ESTree-compatible)[https://github.com/estree/estree] AST object.
+	*/
+	async parse(code, options = {}) {
+		const cacheKey = (0, __stryke_hash_murmurhash.murmurhash)({
+			code,
+			options
+		});
+		let result;
+		if (!this.config.skipCache) {
+			result = this.parserCache.get(cacheKey);
+			if (result) return result;
+		}
+		result = await (0, oxc_parser.parse)(`source.${options.lang || "ts"}`, code, {
+			...options,
+			sourceType: "module",
+			showSemanticErrors: this.config.mode === "development"
+		});
+		if (!this.config.skipCache) this.parserCache.set(cacheKey, result);
+		return result;
+	}
+	/**
+	* A helper function to resolve modules in the Virtual File System
+	*
+	* @remarks
+	* This function can be used to resolve modules relative to the project root directory.
+	*
+	* @example
+	* ```ts
+	* const resolved = await context.resolve("some-module", "/path/to/importer");
+	* ```
+	*
+	* @param id - The module to resolve.
+	* @param importer - An optional path to the importer module.
+	* @param options - Additional resolution options.
+	* @returns A promise that resolves to the resolved module path.
+	*/
+	async resolve(id, importer, options = {}) {
+		let moduleId = id;
+		if (this.config.build.alias) {
+			if (Array.isArray(this.config.build.alias)) {
+				const alias = this.config.build.alias.find((a) => (0, bundle_require.match)(moduleId, [a.find]));
+				if (alias) moduleId = alias.replacement;
+			} else if ((0, __stryke_type_checks_is_set_object.isSetObject)(this.config.build.alias) && this.config.build.alias[id]) moduleId = this.config.build.alias[id];
+		}
+		if (this.fs.isVirtual(moduleId)) {
+			const result = await this.fs.resolve(moduleId, importer, {
+				conditions: this.config.build.conditions,
+				extensions: this.config.build.extensions,
+				...options
+			});
+			if (!result) return;
+			return {
+				id: `\0${result}`,
+				external: this.config.projectType !== "application"
+			};
+		}
+		if (this.config.build.skipNodeModulesBundle) {
+			if ((0, bundle_require.match)(moduleId, this.resolvePatterns) || (0, bundle_require.match)(moduleId, this.config.build.noExternal)) return;
+			if ((0, bundle_require.match)(moduleId, this.config.build.external) || moduleId.startsWith("node:")) return {
+				id: moduleId,
+				external: true
+			};
+			if (!/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(moduleId)) return {
+				id: moduleId,
+				external: true
+			};
+		} else {
+			if ((0, bundle_require.match)(moduleId, this.config.build.noExternal)) return;
+			if ((0, bundle_require.match)(moduleId, this.config.build.external) || moduleId.startsWith("node:")) return {
+				id: moduleId,
+				external: true
+			};
+		}
+	}
+	/**
+	* A helper function to load modules from the Virtual File System
+	*
+	* @remarks
+	* This function can be used to load modules relative to the project root directory.
+	*
+	* @example
+	* ```ts
+	* const module = await context.load("some-module", "/path/to/importer");
+	* ```
+	*
+	* @param id - The module to load.
+	* @returns A promise that resolves to the loaded module.
+	*/
+	async load(id) {
+		const resolvedId = await this.fs.resolve(id);
+		if (!resolvedId) return;
+		const code = await this.fs.read(resolvedId);
+		if (!code) return;
+		return {
+			code,
+			map: null
+		};
+	}
+	/**
+	* Get the builtin virtual files that exist in the Powerlines virtual file system
+	*/
+	async getBuiltins() {
+		return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "builtin").map(async ([path, meta]) => {
+			const code = await this.fs.read(path);
+			return {
+				...meta,
+				path,
+				code
+			};
+		}));
+	}
+	/**
+	* Resolves a file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the file
+	* @param path - The path to write the file to
+	* @param options - Additional options for writing the file
+	*/
+	async emit(code, path, options = {}) {
+		if ((0, __stryke_type_checks_is_function.isFunction)(this.emitFile) && options.emitWithBundler) return this.emitFile({
+			needsCodeReference: options.needsCodeReference,
+			originalFileName: options.originalFileName,
+			fileName: path,
+			source: code,
+			type: "asset"
+		});
+		return this.fs.write(path, code, options);
+	}
+	/**
+	* Synchronously resolves a file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the file
+	* @param path - The path to write the file to
+	* @param options - Additional options for writing the file
+	*/
+	emitSync(code, path, options = {}) {
+		if ((0, __stryke_type_checks_is_function.isFunction)(this.emitFile) && options.emitWithBundler) return this.emitFile({
+			needsCodeReference: options.needsCodeReference,
+			originalFileName: options.originalFileName,
+			fileName: path,
+			source: code,
+			type: "asset"
+		});
+		return this.fs.writeSync(path, code, options);
+	}
+	/**
+	* Resolves a entry virtual file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the entry file
+	* @param path - A path to write the entry file to
+	* @param options - Optional write file options
+	*/
+	async emitEntry(code, path, options = {}) {
+		const entryPath = (0, __stryke_path_is_type.isAbsolute)(path) ? path : (0, __stryke_path_append.appendPath)(path, this.entryPath);
+		this.entry ??= [];
+		this.entry.push({
+			name: options.name,
+			file: entryPath,
+			input: options.input,
+			output: options.output
+		});
+		return this.emit(code, entryPath, (0, defu.default)((0, __stryke_helpers_omit.omit)(options, ["name"]), { meta: {
+			type: "entry",
+			properties: {
+				name: options.name,
+				output: options.output,
+				"input.file": options.input?.file,
+				"input.name": options.input?.name
+			}
+		} }));
+	}
+	/**
+	* Synchronously resolves a entry virtual file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the entry file
+	* @param path - A path to write the entry file to
+	* @param options - Optional write file options
+	*/
+	emitEntrySync(code, path, options = {}) {
+		const entryPath = (0, __stryke_path_is_type.isAbsolute)(path) ? path : (0, __stryke_path_append.appendPath)(path, this.entryPath);
+		this.entry ??= [];
+		this.entry.push({
+			name: options?.name,
+			file: entryPath,
+			input: options?.input,
+			output: options?.output
+		});
+		return this.emitSync(code, entryPath, (0, defu.default)((0, __stryke_helpers_omit.omit)(options, ["name"]), { meta: {
+			type: "entry",
+			properties: {
+				name: options?.name,
+				output: options?.output,
+				"input.file": options?.input?.file,
+				"input.name": options?.input?.name
+			}
+		} }));
+	}
+	/**
+	* Resolves a builtin virtual file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the builtin file
+	* @param id - The unique identifier of the builtin file
+	* @param path - An optional path to write the builtin file to
+	* @param options - Optional write file options
+	*/
+	async emitBuiltin(code, id, path, options = {}) {
+		return this.emit(code, path ? (0, __stryke_path_is_type.isAbsolute)(path) ? path : (0, __stryke_path_join.joinPaths)(this.builtinsPath, path) : (0, __stryke_path_append.appendPath)(id, this.builtinsPath), (0, defu.default)(options, { meta: { type: "builtin" } }));
+	}
+	/**
+	* Synchronously resolves a builtin virtual file and writes it to the VFS if it does not already exist
+	*
+	* @param code - The source code of the builtin file
+	* @param id - The unique identifier of the builtin file
+	* @param path - An optional path to write the builtin file to
+	* @param options - Optional write file options
+	*/
+	emitBuiltinSync(code, id, path, options = {}) {
+		return this.emitSync(code, path ? (0, __stryke_path_is_type.isAbsolute)(path) ? path : (0, __stryke_path_join.joinPaths)(this.builtinsPath, path) : (0, __stryke_path_append.appendPath)(id, this.builtinsPath), (0, defu.default)(options, { meta: { type: "builtin" } }));
+	}
+	/**
+	* Update the context using a new user configuration options
+	*
+	* @param userConfig - The new user configuration options.
+	*/
+	async withUserConfig(userConfig, options = { isHighPriority: true }) {
+		this.mergeUserConfig(userConfig);
+		await this.init(this.config.userConfig, options);
+	}
+	/**
+	* Update the context using a new inline configuration options
+	*
+	* @param inlineConfig - The new inline configuration options.
+	*/
+	async withInlineConfig(inlineConfig, options = { isHighPriority: true }) {
+		this.config.inlineConfig = inlineConfig;
+		if (inlineConfig.command === "new") {
+			const workspacePackageJsonPath = (0, __stryke_path_join.joinPaths)(this.workspaceConfig.workspaceRoot, "package.json");
+			if (!(0, __stryke_fs_exists.existsSync)(workspacePackageJsonPath)) throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
+			this.packageJson = await (0, __stryke_fs_json.readJsonFile)(workspacePackageJsonPath);
+			this.workspaceConfig.repository ??= (0, __stryke_type_checks_is_set_string.isSetString)(this.packageJson?.repository) ? this.packageJson.repository : this.packageJson?.repository?.url;
+		}
+		await this.init(this.config.inlineConfig, options);
+	}
+	/**
+	* A logging function for fatal messages
+	*
+	* @param message - The message to log.
+	*/
+	fatal(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.FATAL, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* A logging function for error messages
+	*
+	* @param message - The message to log.
+	*/
+	error(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.ERROR, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* A logging function for warning messages
+	*
+	* @param message - The message to log.
+	*/
+	warn(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.WARN, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* A logging function for informational messages
+	*
+	* @param message - The message to log.
+	*/
+	info(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.INFO, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* A logging function for debug messages
+	*
+	* @param message - The message to log.
+	*/
+	debug(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.DEBUG, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* A logging function for trace messages
+	*
+	* @param message - The message to log.
+	*/
+	trace(message) {
+		this.log(__storm_software_config_tools_types.LogLevelLabel.TRACE, (0, __stryke_type_checks_is_string.isString)(message) ? message : __stryke_json_storm_json.StormJSON.stringify(message));
+	}
+	/**
+	* Create a new logger instance
+	*
+	* @param name - The name to use for the logger instance
+	* @returns A logger function
+	*/
+	createLog(name = null) {
+		return require_logger.createLog(name, {
+			...this.config,
+			logLevel: (0, __stryke_type_checks_is_null.isNull)(this.config.logLevel) ? "silent" : this.config.logLevel
+		});
+	}
+	/**
+	* Extend the current logger instance with a new name
+	*
+	* @param name - The name to use for the extended logger instance
+	* @returns A logger function
+	*/
+	extendLog(name) {
+		return require_logger.extendLog(this.log, name);
+	}
+	/**
+	* Generates a checksum representing the current context state
+	*
+	* @param root - The root directory of the project to generate the checksum for
+	* @returns A promise that resolves to a string representing the checksum
+	*/
+	async generateChecksum(root = this.config.projectRoot) {
+		this.#checksum = await (0, __stryke_hash_hash_files.hashDirectory)(root, { ignore: [
+			"node_modules",
+			".git",
+			".nx",
+			".cache",
+			".storm",
+			"tmp",
+			"dist"
+		] });
+		return this.#checksum;
+	}
+	/**
+	* Creates a new StormContext instance.
+	*
+	* @param workspaceConfig - The workspace configuration.
+	*/
+	constructor(workspaceConfig) {
+		this.#workspaceConfig = workspaceConfig;
+		envPathCache.set({
+			workspaceRoot: workspaceConfig.workspaceRoot,
+			framework: "powerlines"
+		}, (0, __stryke_env_get_env_paths.getEnvPaths)({
+			orgId: ((0, __stryke_type_checks_is_set_object.isSetObject)(workspaceConfig.organization) ? workspaceConfig.organization.name : workspaceConfig.organization) || "storm-software",
+			appId: "powerlines",
+			workspaceRoot: workspaceConfig.workspaceRoot
+		}));
+	}
+	/**
+	* The resolved configuration for this context
+	*/
+	resolvedConfig = {};
+	/**
+	* A logger function specific to this context
+	*/
+	logFn;
+	/**
+	* Initialize the context with the provided configuration options
+	*
+	* @param config - The partial user configuration to use for initialization.
+	*/
+	async init(config = {}, options = { isHighPriority: true }) {
+		const cacheKey = {
+			projectRoot: config.root ?? this.config.projectRoot ?? this.config.userConfig?.root ?? this.config.inlineConfig?.root,
+			mode: (config.mode ?? this.config.mode) || this.workspaceConfig.mode,
+			skipCache: config.skipCache ?? this.config.skipCache ?? false,
+			configFile: config.configFile ?? this.config.configFile,
+			framework: config.framework ?? this.config.framework ?? "powerlines",
+			command: this.config.inlineConfig?.command
+		};
+		if (configCache.has(cacheKey)) {
+			const result = configCache.get(cacheKey);
+			this.projectJson = result.projectJson;
+			this.packageJson = result.packageJson;
+			this.#checksum = result.checksum;
+			this.resolver = result.resolver;
+			this.mergeUserConfig(result.userConfig.config, this.config.userConfig);
+		} else {
+			const projectJsonPath = (0, __stryke_path_join.joinPaths)(cacheKey.projectRoot, "project.json");
+			if ((0, __stryke_fs_exists.existsSync)(projectJsonPath)) this.projectJson = await (0, __stryke_fs_json.readJsonFile)(projectJsonPath);
+			const packageJsonPath = (0, __stryke_path_join.joinPaths)(cacheKey.projectRoot, "package.json");
+			if ((0, __stryke_fs_exists.existsSync)(packageJsonPath)) this.packageJson = await (0, __stryke_fs_json.readJsonFile)(packageJsonPath);
+			this.#checksum = await this.generateChecksum(cacheKey.projectRoot);
+			this.resolver = require_resolver.createResolver({
+				workspaceRoot: this.workspaceConfig.workspaceRoot,
+				projectRoot: cacheKey.projectRoot,
+				cacheDir: this.cachePath,
+				mode: cacheKey.mode,
+				logLevel: config.logLevel || this.config?.logLevel || this.workspaceConfig.logLevel || "info",
+				skipCache: cacheKey.skipCache
+			});
+			const userConfig = await require_config_file.loadUserConfigFile(cacheKey.projectRoot, this.workspaceConfig.workspaceRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile, cacheKey.framework);
+			this.mergeUserConfig(userConfig.config);
+			configCache.set(cacheKey, {
+				projectJson: this.projectJson,
+				packageJson: this.packageJson,
+				checksum: this.#checksum,
+				resolver: this.resolver,
+				userConfig
+			});
+		}
+		config.tsconfig ??= require_tsconfig.getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.projectRoot, config.tsconfig);
+		if ((0, __stryke_type_checks_is_set_object.isSetObject)(config)) this.resolvedConfig = (0, defu.default)({
+			inlineConfig: this.config.inlineConfig,
+			userConfig: this.config.userConfig
+		}, options.isHighPriority ? this.#getConfigProps(config) : {}, {
+			command: this.config.inlineConfig?.command,
+			...this.#getConfigProps(this.config.inlineConfig)
+		}, this.#getConfigProps(this.config.userConfig), {
+			mode: this.workspaceConfig?.mode,
+			logLevel: this.workspaceConfig?.logLevel,
+			skipCache: this.workspaceConfig?.skipCache
+		}, {
+			name: this.projectJson?.name || this.packageJson?.name,
+			version: this.packageJson?.version,
+			description: this.packageJson?.description,
+			sourceRoot: this.projectJson?.sourceRoot || (0, __stryke_path_append.appendPath)("src", cacheKey.projectRoot),
+			output: (0, defu.default)(config.output ?? {}, {
+				outputPath: cacheKey.projectRoot ? (0, __stryke_path_join.joinPaths)(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
+				artifactsPath: (0, __stryke_path_join.joinPaths)(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
+				dts: (0, __stryke_path_join.joinPaths)(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
+				builtinPrefix: config.framework ?? "powerlines",
+				assets: [
+					{ glob: "LICENSE" },
+					{
+						input: cacheKey.projectRoot,
+						glob: "*.md"
+					},
+					{
+						input: cacheKey.projectRoot,
+						glob: "package.json"
+					}
+				]
+			})
+		}, options.isHighPriority ? {} : this.#getConfigProps(config), {
+			inlineConfig: {},
+			userConfig: {},
+			framework: "powerlines",
+			platform: "neutral",
+			mode: "production",
+			projectType: "application",
+			logLevel: "info",
+			preview: false,
+			environments: {},
+			transform: { babel: {
+				plugins: [],
+				presets: []
+			} },
+			lint: { eslint: {} },
+			build: {
+				target: "esnext",
+				override: {}
+			}
+		});
+		this.config.entry = require_entry.getUniqueEntries(this.config.entry);
+		if (this.config.name?.startsWith("@") && this.config.name.split("/").filter(Boolean).length > 1) this.config.name = this.config.name.split("/").filter(Boolean)[1];
+		this.config.title ??= (0, __stryke_string_format_title_case.titleCase)(this.config.name);
+		this.config.organization ??= ((0, __stryke_type_checks_is_set_object.isSetObject)(this.workspaceConfig.organization) ? this.workspaceConfig.organization.name : this.workspaceConfig.organization) || ((0, __stryke_type_checks_is_set_object.isSetObject)(this.packageJson?.author) ? this.packageJson?.author?.name : this.packageJson?.author) || this.config.name;
+		if (this.config.userConfig.build?.external) this.config.userConfig.build.external = (0, __stryke_helpers_get_unique.getUnique)(this.config.userConfig.build.external);
+		if (this.config.userConfig.build?.noExternal) this.config.userConfig.build.noExternal = (0, __stryke_helpers_get_unique.getUnique)(this.config.userConfig.build.noExternal);
+		if (this.config.build.external) this.config.build.external = (0, __stryke_helpers_get_unique.getUnique)(this.config.build.external);
+		if (this.config.build.noExternal) this.config.build.noExternal = (0, __stryke_helpers_get_unique.getUnique)(this.config.build.noExternal);
+		this.config.output.format = (0, __stryke_helpers_get_unique.getUnique)((0, __stryke_convert_to_array.toArray)(this.config.output?.format ?? (this.config.projectType === "library" ? ["cjs", "esm"] : ["esm"])));
+		if (this.config.projectRoot && this.config.projectRoot !== "." && this.config.projectRoot !== "./" && this.config.projectRoot !== this.workspaceConfig.workspaceRoot) {
+			this.config.output.outputPath ??= (0, __stryke_path_join.joinPaths)("dist", this.config.projectRoot);
+			this.config.output.buildPath ??= (0, __stryke_path_join.joinPaths)(this.config.projectRoot, "dist");
+		} else {
+			this.config.output.outputPath ??= "dist";
+			this.config.output.buildPath ??= "dist";
+		}
+		this.config.output.assets = (0, __stryke_helpers_get_unique.getUniqueBy)(this.config.output.assets.map((asset) => {
+			return {
+				glob: (0, __stryke_type_checks_is_set_object.isSetObject)(asset) ? asset.glob : asset,
+				input: (0, __stryke_type_checks_is_string.isString)(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : (0, __stryke_path_is_parent_path.isParentPath)(asset.input, this.workspaceConfig.workspaceRoot) || asset.input === this.workspaceConfig.workspaceRoot ? asset.input : (0, __stryke_path_append.appendPath)(asset.input, this.workspaceConfig.workspaceRoot),
+				output: (0, __stryke_type_checks_is_set_object.isSetObject)(asset) && asset.output ? (0, __stryke_path_is_parent_path.isParentPath)(asset.output, this.workspaceConfig.workspaceRoot) ? asset.output : (0, __stryke_path_append.appendPath)((0, __stryke_path_join.joinPaths)(this.config.output.outputPath, (0, __stryke_path_replace.replacePath)((0, __stryke_path_replace.replacePath)(asset.output, (0, __stryke_path_replace.replacePath)(this.config.output.outputPath, this.workspaceConfig.workspaceRoot)), this.config.output.outputPath)), this.workspaceConfig.workspaceRoot) : (0, __stryke_path_append.appendPath)(this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
+				ignore: (0, __stryke_type_checks_is_set_object.isSetObject)(asset) && asset.ignore ? (0, __stryke_convert_to_array.toArray)(asset.ignore) : void 0
+			};
+		}), (a) => `${a.input}-${a.glob}-${a.output}`);
+		this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+			if (require_helpers.isPlugin(plugin) && require_helpers.checkDedupe(plugin, ret.filter((p) => require_helpers.isPlugin(p)))) return ret;
+			ret.push(plugin);
+			return ret;
+		}, []);
+		if (this.config.tsconfig) this.config.tsconfig = require_paths.replacePathTokens(this, this.config.tsconfig);
+		if (this.config.output.dts) this.config.output.dts = require_paths.replacePathTokens(this, this.config.output.dts);
+		if (this.config.build.polyfill) this.config.build.polyfill = this.config.build.polyfill.map((polyfill) => require_paths.replacePathTokens(this, polyfill));
+		if (this.config.output.assets) this.config.output.assets = this.config.output.assets.map((asset) => ({
+			...asset,
+			glob: require_paths.replacePathTokens(this, asset.glob),
+			ignore: asset.ignore ? asset.ignore.map((ignore) => require_paths.replacePathTokens(this, ignore)) : void 0,
+			input: require_paths.replacePathTokens(this, asset.input),
+			output: require_paths.replacePathTokens(this, asset.output)
+		}));
+		this.#fs ??= await require_vfs.VirtualFileSystem.create(this);
+	}
+	mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
+		this.config.userConfig = (0, defu.default)({ entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : [] }, (0, __stryke_helpers_omit.omit)(from ?? {}, ["entry"]), (0, __stryke_helpers_omit.omit)(into ?? {}, ["entry"]));
+		if (this.config.userConfig.output?.format) this.config.userConfig.output.format = (0, __stryke_helpers_get_unique.getUnique)((0, __stryke_convert_to_array.toArray)(this.config.userConfig.output?.format));
+		this.config.userConfig.plugins = (this.config.userConfig.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+			if (require_helpers.isPlugin(plugin) && require_helpers.checkDedupe(plugin, ret.filter((p) => require_helpers.isPlugin(p)))) return ret;
+			ret.push(plugin);
+			return ret;
+		}, []);
+	}
+};
+
+//#endregion
+exports.PowerlinesContext = PowerlinesContext;