@powerlines/core 0.0.8

package/dist/types/context.d.mts

@@ -0,0 +1,564 @@
+import { ResolveOptions, VirtualFile, VirtualFileSystemInterface, WriteOptions } from "./fs.mjs";
+import { Plugin } from "./plugin.mjs";
+import { HooksList, InferHooksListItem } from "./hooks.mjs";
+import { ParsedTypeScriptConfig } from "./tsconfig.mjs";
+import { EnvironmentResolvedConfig, InlineConfig, LogFn, ResolvedConfig, ResolvedEntryTypeDefinition, UserConfig, WorkspaceConfig } from "./config.mjs";
+import { ExternalIdResult, UnpluginBuildContext, UnpluginContext, UnpluginMessage } from "unplugin";
+import MagicString, { SourceMap } from "magic-string";
+import { Jiti } from "jiti";
+import { EnvPaths } from "@stryke/env/get-env-paths";
+import { FetchRequestOptions } from "@stryke/http/fetch";
+import { PackageJson } from "@stryke/types/package-json";
+import { Worker } from "jest-worker";
+import { ParseResult, ParserOptions } from "oxc-parser";
+import { Range } from "semver";
+import { RequestInfo, Response } from "undici";
+import { Unimport } from "unimport";
+
+//#region src/types/context.d.ts
+type WorkerProcess<TExposedMethods extends ReadonlyArray<string>> = { [K in TExposedMethods[number]]: (data: any) => Promise<any> } & {
+  close: () => void;
+  end: () => ReturnType<Worker["end"]>;
+};
+interface MetaInfo {
+  /**
+   * The checksum generated from the resolved options
+   */
+  checksum: string;
+  /**
+   * The build id
+   */
+  buildId: string;
+  /**
+   * The release id
+   */
+  releaseId: string;
+  /**
+   * The build timestamp
+   */
+  timestamp: number;
+  /**
+   * A hash that represents the path to the project root directory
+   */
+  rootHash: string;
+  /**
+   * A hash that represents the path to the configuration root directory
+   */
+  configHash: string;
+}
+interface Resolver extends Jiti {
+  plugin: Jiti;
+}
+interface TransformResult {
+  code: string;
+  map: SourceMap | null;
+}
+/**
+ * The format for providing source code to the compiler
+ */
+interface SourceFile {
+  /**
+   * The name of the file to be compiled
+   */
+  id: string;
+  /**
+   * The source code to be compiled
+   */
+  code: MagicString;
+  /**
+   * The environment variables used in the source code
+   */
+  env: string[];
+  /**
+   * The result of the transformation
+   */
+  result?: TransformResult;
+}
+type UnimportContext = Omit<Unimport, "injectImports"> & {
+  dumpImports: () => Promise<void>;
+  injectImports: (source: SourceFile) => Promise<SourceFile>;
+  refreshRuntimeImports: () => Promise<void>;
+};
+interface SelectHooksOptions {
+  order?: "pre" | "post" | "normal";
+}
+/**
+ * Options for initializing or updating the context with new configuration values
+ */
+interface InitContextOptions {
+  /**
+   * If false, the plugin will be loaded after all other plugins.
+   *
+   * @defaultValue true
+   */
+  isHighPriority: boolean;
+}
+/**
+ * Options for fetch requests made via the context's {@link Context.fetch} method
+ */
+interface FetchOptions extends FetchRequestOptions {
+  /**
+   * An indicator specifying that the request should bypass any caching
+   */
+  skipCache?: boolean;
+}
+/**
+ * Options for parsing code using [Oxc-Parser](https://github.com/oxc/oxc)
+ */
+interface ParseOptions extends ParserOptions {
+  /**
+   * When true this allows return statements to be outside functions to e.g. support parsing CommonJS code.
+   */
+  allowReturnOutsideFunction?: boolean;
+}
+interface EmitOptions extends WriteOptions {
+  /**
+   * The file extension to use when emitting the file
+   */
+  extension?: string;
+  /**
+   * If true, will emit the file using {@link UnpluginBuildContext.emitFile | the bundler's emit function}.
+   */
+  emitWithBundler?: boolean;
+  needsCodeReference?: Parameters<UnpluginBuildContext["emitFile"]>[0]["needsCodeReference"];
+  originalFileName?: Parameters<UnpluginBuildContext["emitFile"]>[0]["originalFileName"];
+}
+/**
+ * Options for emitting entry virtual files
+ */
+type EmitEntryOptions = EmitOptions & Omit<ResolvedEntryTypeDefinition, "file">;
+/**
+ * The unresolved Powerlines context.
+ *
+ * @remarks
+ * This context is used before the user configuration has been fully resolved after the `config`.
+ */
+interface UnresolvedContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
+  /**
+   * The Storm workspace configuration
+   */
+  workspaceConfig: WorkspaceConfig;
+  /**
+   * An object containing the options provided to Powerlines
+   */
+  config: Omit<TResolvedConfig["userConfig"], "output"> & Required<Pick<TResolvedConfig["userConfig"], "output">> & {
+    output: TResolvedConfig["output"];
+  };
+  /**
+   * A logging function for the Powerlines engine
+   */
+  log: LogFn;
+  /**
+   * A logging function for fatal messages
+   */
+  fatal: (message: string | UnpluginMessage) => void;
+  /**
+   * A logging function for error messages
+   */
+  error: (message: string | UnpluginMessage) => void;
+  /**
+   * A logging function for warning messages
+   */
+  warn: (message: string | UnpluginMessage) => void;
+  /**
+   * A logging function for informational messages
+   */
+  info: (message: string | UnpluginMessage) => void;
+  /**
+   * A logging function for debug messages
+   */
+  debug: (message: string | UnpluginMessage) => void;
+  /**
+   * A logging function for trace messages
+   */
+  trace: (message: string | UnpluginMessage) => void;
+  /**
+   * The metadata information
+   */
+  meta: MetaInfo;
+  /**
+   * The metadata information currently written to disk
+   */
+  persistedMeta?: MetaInfo;
+  /**
+   * The Powerlines artifacts directory
+   */
+  artifactsPath: string;
+  /**
+   * The path to the Powerlines builtin runtime modules directory
+   */
+  builtinsPath: string;
+  /**
+   * The path to the Powerlines entry modules directory
+   */
+  entryPath: string;
+  /**
+   * The path to the Powerlines TypeScript declaration files directory
+   */
+  dtsPath: string;
+  /**
+   * The path to a directory where the reflection data buffers (used by the build processes) are stored
+   */
+  dataPath: string;
+  /**
+   * The path to a directory where the project cache (used by the build processes) is stored
+   */
+  cachePath: string;
+  /**
+   * The Powerlines environment paths
+   */
+  envPaths: EnvPaths;
+  /**
+   * The file system path to the Powerlines package installation
+   */
+  powerlinesPath: string;
+  /**
+   * The relative path to the Powerlines workspace root directory
+   */
+  relativeToWorkspaceRoot: string;
+  /**
+   * The project's `package.json` file content
+   */
+  packageJson: PackageJson & Record<string, any>;
+  /**
+   * The project's `project.json` file content
+   */
+  projectJson?: Record<string, any>;
+  /**
+   * The dependency installations required by the project
+   */
+  dependencies: Record<string, string | Range>;
+  /**
+   * The development dependency installations required by the project
+   */
+  devDependencies: Record<string, string | Range>;
+  /**
+   * The parsed TypeScript configuration from the `tsconfig.json` file
+   */
+  tsconfig: ParsedTypeScriptConfig;
+  /**
+   * The entry points of the source code
+   */
+  entry: ResolvedEntryTypeDefinition[];
+  /**
+   * The virtual file system manager used during the build process to reference generated runtime files
+   */
+  fs: VirtualFileSystemInterface;
+  /**
+   * The Jiti module resolver
+   */
+  resolver: Resolver;
+  /**
+   * The builtin module id that exist in the Powerlines virtual file system
+   */
+  builtins: string[];
+  /**
+   * The alias mappings for the project used during module resolution
+   *
+   * @remarks
+   * This includes both the built-in module aliases as well as any custom aliases defined in the build configuration.
+   */
+  alias: Record<string, string>;
+  /**
+   * 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.
+   */
+  fetch: (input: RequestInfo, options?: FetchOptions) => Promise<Response>;
+  /**
+   * 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.
+   */
+  parse: (code: string, options?: ParseOptions) => Promise<ParseResult>;
+  /**
+   * A helper function to resolve modules using the Jiti resolver
+   *
+   * @remarks
+   * This function can be used to resolve modules relative to the project root directory.
+   *
+   * @example
+   * ```ts
+   * const resolvedPath = 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.
+   */
+  resolve: (id: string, importer?: string, options?: ResolveOptions) => Promise<ExternalIdResult | undefined>;
+  /**
+   * A helper function to load modules using the Jiti resolver
+   *
+   * @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.
+   */
+  load: (id: string) => Promise<TransformResult | undefined>;
+  /**
+   * The Powerlines builtin virtual files
+   */
+  getBuiltins: () => Promise<VirtualFile[]>;
+  /**
+   * 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
+   */
+  emit: (code: string, path: string, options?: EmitOptions) => Promise<void>;
+  /**
+   * 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: string, path: string, options?: EmitOptions) => void;
+  /**
+   * 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 options - Additional options for writing the builtin file
+   */
+  emitBuiltin: (code: string, id: string, options?: EmitOptions) => Promise<void>;
+  /**
+   * 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 options - Additional options for writing the builtin file
+   */
+  emitBuiltinSync: (code: string, id: string, options?: EmitOptions) => void;
+  /**
+   * 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 - An optional path to write the entry file to
+   * @param options - Additional options for writing the entry file
+   */
+  emitEntry: (code: string, path: string, options?: EmitEntryOptions) => Promise<void>;
+  /**
+   * 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 - An optional path to write the entry file to
+   * @param options - Additional options for writing the entry file
+   */
+  emitEntrySync: (code: string, path: string, options?: EmitEntryOptions) => void;
+  /**
+   * A function to update the context fields using a new user configuration options
+   */
+  withUserConfig: (userConfig: UserConfig, options?: InitContextOptions) => Promise<void>;
+  /**
+   * A function to update the context fields using inline configuration options
+   */
+  withInlineConfig: (inlineConfig: InlineConfig, options?: InitContextOptions) => Promise<void>;
+  /**
+   * Create a new logger instance
+   *
+   * @param name - The name to use for the logger instance
+   * @returns A logger function
+   */
+  createLog: (name: string | null) => LogFn;
+  /**
+   * 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: string) => LogFn;
+  /**
+   * Generates a checksum representing the current context state
+   *
+   * @returns A promise that resolves to a string representing the checksum
+   */
+  generateChecksum: () => Promise<string>;
+}
+type Context<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = Omit<UnresolvedContext<TResolvedConfig>, "config"> & {
+  /**
+   * The fully resolved Powerlines configuration
+   */
+  config: TResolvedConfig;
+};
+interface APIContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+  /**
+   * The expected plugins options for the Powerlines project.
+   *
+   * @remarks
+   * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
+   */
+  plugins: Plugin<PluginContext<TResolvedConfig>>[];
+  /**
+   * A function to add a plugin to the context and update the configuration options
+   */
+  addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+  /**
+   * A table for storing the current context for each configured environment
+   */
+  environments: Record<string, EnvironmentContext<TResolvedConfig>>;
+  /**
+   * Retrieves the context for a specific environment by name
+   *
+   * @throws Will throw an error if the environment does not exist
+   *
+   * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
+   * @returns A promise that resolves to the environment context.
+   *
+   * @example
+   * ```ts
+   * const devEnv = await apiContext.getEnvironment("development");
+   * const defaultEnv = await apiContext.getEnvironment();
+   * ```
+   */
+  getEnvironment: (name?: string) => Promise<EnvironmentContext<TResolvedConfig>>;
+  /**
+   * Safely retrieves the context for a specific environment by name
+   *
+   * @param name - The name of the environment to retrieve. If not provided, the default environment is returned.
+   * @returns A promise that resolves to the environment context, or undefined if the environment does not exist.
+   *
+   * @example
+   * ```ts
+   * const devEnv = await apiContext.getEnvironmentSafe("development");
+   * const defaultEnv = await apiContext.getEnvironmentSafe();
+   * ```
+   *
+   * @remarks
+   * This method is similar to `getEnvironment`, but it returns `undefined` instead of throwing an error if the specified environment does not exist.
+   * This can be useful in scenarios where the existence of an environment is optional or uncertain.
+   *
+   * ```ts
+   * const testEnv = await apiContext.getEnvironmentSafe("test");
+   * if (testEnv) {
+   *   // Environment exists, safe to use it
+   * } else {
+   *   // Environment does not exist, handle accordingly
+   * }
+   * ```
+   *
+   * Using this method helps avoid unhandled exceptions in cases where an environment might not be defined.
+   */
+  getEnvironmentSafe: (name?: string) => Promise<EnvironmentContext<TResolvedConfig> | undefined>;
+  /**
+   * A function to copy the context and update the fields for a specific environment
+   *
+   * @param environment - The environment configuration to use.
+   * @returns A new context instance with the updated environment.
+   */
+  in: (environment: EnvironmentResolvedConfig) => Promise<EnvironmentContext<TResolvedConfig>>;
+  /**
+   * A function to merge all configured environments into a single context
+   *
+   * @returns A promise that resolves to the merged environment context.
+   */
+  toEnvironment: () => Promise<EnvironmentContext<TResolvedConfig>>;
+}
+interface EnvironmentContextPlugin<TResolvedConfig extends ResolvedConfig = ResolvedConfig> {
+  plugin: Plugin<PluginContext<TResolvedConfig>>;
+  context: PluginContext<TResolvedConfig>;
+}
+type SelectHookResultItem<TContext extends PluginContext, TKey extends string> = InferHooksListItem<TContext, TKey> & {
+  context: TContext;
+};
+type SelectHookResult<TContext extends PluginContext, TKey extends string> = SelectHookResultItem<TContext, TKey>[];
+interface EnvironmentContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig> {
+  /**
+   * The expected plugins options for the Powerlines project.
+   *
+   * @remarks
+   * This is a record of plugin identifiers to their respective options. This field is populated by the Powerlines engine during both plugin initialization and the `init` command.
+   */
+  plugins: EnvironmentContextPlugin<TResolvedConfig>[];
+  /**
+   * A function to add a plugin to the context and update the configuration options
+   */
+  addPlugin: (plugin: Plugin<PluginContext<TResolvedConfig>>) => Promise<void>;
+  /**
+   * The environment specific resolved configuration
+   */
+  environment: EnvironmentResolvedConfig;
+  /**
+   * A table holding references to hook functions registered by plugins
+   */
+  hooks: HooksList<PluginContext<TResolvedConfig>>;
+  /**
+   * Retrieves the hook handlers for a specific hook name
+   */
+  selectHooks: <TKey extends string>(key: TKey, options?: SelectHooksOptions) => SelectHookResult<PluginContext<TResolvedConfig>, TKey>;
+}
+interface PluginContext<out TResolvedConfig extends ResolvedConfig = ResolvedConfig> extends Context<TResolvedConfig>, UnpluginContext {
+  /**
+   * The environment specific resolved configuration
+   */
+  environment: EnvironmentResolvedConfig;
+  /**
+   * An alternative property name for the {@link log} property
+   *
+   * @remarks
+   * This is provided for compatibility with other logging libraries that expect a `logger` property.
+   */
+  logger: LogFn;
+}
+type BuildPluginContext<TResolvedConfig extends ResolvedConfig = ResolvedConfig> = UnpluginBuildContext & PluginContext<TResolvedConfig>;
+type WithUnpluginBuildContext<TContext extends PluginContext> = UnpluginBuildContext & TContext;
+declare type __ΩWorkerProcess = any[];
+declare type __ΩMetaInfo = any[];
+declare type __ΩResolver = any[];
+declare type __ΩTransformResult = any[];
+declare type __ΩSourceFile = any[];
+declare type __ΩUnimportContext = any[];
+declare type __ΩSelectHooksOptions = any[];
+declare type __ΩInitContextOptions = any[];
+declare type __ΩFetchOptions = any[];
+declare type __ΩParseOptions = any[];
+declare type __ΩEmitOptions = any[];
+declare type __ΩEmitEntryOptions = any[];
+declare type __ΩUnresolvedContext = any[];
+declare type __ΩContext = any[];
+declare type __ΩAPIContext = any[];
+declare type __ΩEnvironmentContextPlugin = any[];
+declare type __ΩSelectHookResultItem = any[];
+declare type __ΩSelectHookResult = any[];
+declare type __ΩEnvironmentContext = any[];
+declare type __ΩPluginContext = any[];
+declare type __ΩBuildPluginContext = any[];
+declare type __ΩWithUnpluginBuildContext = any[];
+//#endregion
+export { APIContext, BuildPluginContext, Context, EmitEntryOptions, EmitOptions, EnvironmentContext, EnvironmentContextPlugin, FetchOptions, InitContextOptions, MetaInfo, ParseOptions, PluginContext, Resolver, SelectHookResult, SelectHookResultItem, SelectHooksOptions, SourceFile, TransformResult, UnimportContext, UnresolvedContext, WithUnpluginBuildContext, WorkerProcess, __ΩAPIContext, __ΩBuildPluginContext, __ΩContext, __ΩEmitEntryOptions, __ΩEmitOptions, __ΩEnvironmentContext, __ΩEnvironmentContextPlugin, __ΩFetchOptions, __ΩInitContextOptions, __ΩMetaInfo, __ΩParseOptions, __ΩPluginContext, __ΩResolver, __ΩSelectHookResult, __ΩSelectHookResultItem, __ΩSelectHooksOptions, __ΩSourceFile, __ΩTransformResult, __ΩUnimportContext, __ΩUnresolvedContext, __ΩWithUnpluginBuildContext, __ΩWorkerProcess };
+//# sourceMappingURL=context.d.mts.map

package/dist/types/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../../src/types/context.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/types/context.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/types/fs.cjs

@@ -0,0 +1,11 @@
+
+//#region src/types/fs.ts
+const __VFS_PATCH__ = "__VFS_PATCH__";
+const __VFS_REVERT__ = "__VFS_REVERT__";
+const STORAGE_PRESETS = ["fs", "virtual"];
+
+//#endregion
+exports.STORAGE_PRESETS = STORAGE_PRESETS;
+exports.__VFS_PATCH__ = __VFS_PATCH__;
+exports.__VFS_REVERT__ = __VFS_REVERT__;
+//# sourceMappingURL=fs.cjs.map

package/dist/types/fs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.cjs","names":["STORAGE_PRESETS: StoragePreset[]"],"sources":["../../src/types/fs.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 type { ResolveOptions as BaseResolveOptions } from \"@stryke/fs/resolve\";\nimport { MaybePromise } from \"@stryke/types/base\";\nimport { AssetGlob } from \"@stryke/types/file\";\n\nexport type VirtualFileExtension = \"js\" | \"ts\" | \"jsx\" | \"tsx\";\n\n// eslint-disable-next-line ts/naming-convention\nexport const __VFS_PATCH__ = \"__VFS_PATCH__\";\n\n// eslint-disable-next-line ts/naming-convention\nexport const __VFS_REVERT__ = \"__VFS_REVERT__\";\n\nexport type StoragePreset = \"fs\" | \"virtual\";\n\nexport const STORAGE_PRESETS: StoragePreset[] = [\"fs\", \"virtual\"];\n\n/**\n * Interface defining the methods and properties for a storage adapter.\n */\nexport interface StorageAdapter {\n  /**\n   * A name identifying the storage adapter type.\n   */\n  name: string;\n\n  /**\n   * The storage preset for the adapter.\n   *\n   * @remarks\n   * This can be used as an alternate way to identify the type of storage being used.\n   */\n  preset?: StoragePreset | null;\n\n  /**\n   * Checks if a key exists in the storage.\n   *\n   * @param key - The key to check for existence.\n   * @returns A promise that resolves to `true` if the key exists, otherwise `false`.\n   */\n  exists: (key: string) => Promise<boolean>;\n\n  /**\n   * Synchronously checks if a key exists in the storage.\n   *\n   * @param key - The key to check for existence.\n   * @returns Returns `true` if the key exists, otherwise `false`.\n   */\n  existsSync: (key: string) => boolean;\n\n  /**\n   * Read a value associated with a key from the storage.\n   *\n   * @param key - The key to read the value for.\n   * @returns A promise that resolves to the value if found, otherwise `null`.\n   */\n  get: (key: string) => Promise<string | null>;\n\n  /**\n   * Synchronously reads the value associated with a key from the storage.\n   *\n   * @param key - The key to read the value for.\n   * @returns The value if found, otherwise `null`.\n   */\n  getSync: (key: string) => string | null;\n\n  /**\n   * Writes a value to the storage for the given key.\n   *\n   * @param key - The key to associate the value with.\n   * @param value - The value to store.\n   */\n  set: (key: string, value: string) => Promise<void>;\n\n  /**\n   * Synchronously writes a value to the storage for the given key.\n   *\n   * @param key - The key to associate the value with.\n   * @param value - The value to store.\n   */\n  setSync: (key: string, value: string) => void;\n\n  /**\n   * Removes a value from the storage.\n   *\n   * @param key - The key whose value should be removed.\n   */\n  remove: (key: string) => Promise<void>;\n\n  /**\n   * Synchronously removes a value from the storage.\n   *\n   * @param key - The key whose value should be removed.\n   */\n  removeSync: (key: string) => void;\n\n  /**\n   * Creates a directory at the specified path.\n   *\n   * @param dirPath - The path of the directory to create.\n   */\n  mkdir: (dirPath: string) => Promise<void>;\n\n  /**\n   * Synchronously creates a directory at the specified path.\n   *\n   * @param dirPath - The path of the directory to create.\n   */\n  mkdirSync: (dirPath: string) => void;\n\n  /**\n   * Remove all entries from the storage that match the provided base path.\n   *\n   * @param base - The base path or prefix to clear entries from.\n   */\n  clear: (base?: string) => Promise<void>;\n\n  /**\n   * Synchronously remove all entries from the storage that match the provided base path.\n   *\n   * @param base - The base path or prefix to clear entries from.\n   */\n  clearSync: (base?: string) => void;\n\n  /**\n   * Lists all keys under the provided base path.\n   *\n   * @param base - The base path or prefix to list keys from.\n   * @returns A promise resolving to the list of keys.\n   */\n  list: (base?: string) => Promise<string[]>;\n\n  /**\n   * Synchronously lists all keys under the provided base path.\n   *\n   * @param base - The base path or prefix to list keys from.\n   * @returns The list of keys.\n   */\n  listSync: (base?: string) => string[];\n\n  /**\n   * Checks if the given key is a directory.\n   *\n   * @param key - The key to check.\n   * @returns A promise that resolves to `true` if the key is a directory, otherwise `false`.\n   */\n  isDirectory: (key: string) => Promise<boolean>;\n\n  /**\n   * Synchronously checks if the given key is a directory.\n   *\n   * @param key - The key to check.\n   * @returns `true` if the key is a directory, otherwise `false`.\n   */\n  isDirectorySync: (key: string) => boolean;\n\n  /**\n   * Checks if the given key is a file.\n   *\n   * @param key - The key to check.\n   * @returns A promise that resolves to `true` if the key is a file, otherwise `false`.\n   */\n  isFile: (key: string) => Promise<boolean>;\n\n  /**\n   * Synchronously checks if the given key is a file.\n   *\n   * @param key - The key to check.\n   * @returns `true` if the key is a file, otherwise `false`.\n   */\n  isFileSync: (key: string) => boolean;\n\n  /**\n   * Releases any resources held by the storage adapter.\n   */\n  dispose: () => MaybePromise<void>;\n}\n\n/**\n * A mapping of file paths to storage adapter names and their corresponding {@link StorageAdapter} instances.\n */\nexport type StoragePort = Record<string, StorageAdapter>;\n\nexport interface VirtualFileMetadata {\n  /**\n   * The identifier for the file data.\n   */\n  id: string;\n\n  /**\n   * The timestamp of the virtual file.\n   */\n  timestamp: number;\n\n  /**\n   * The type of the file.\n   *\n   * @remarks\n   * This string represents the purpose/function of the file in the virtual file system. A potential list of variants includes:\n   * - `builtin`: Indicates that the file is a built-in module provided by the system.\n   * - `entry`: Indicates that the file is an entry point for execution.\n   * - `normal`: Indicates that the file is a standard file without any special role.\n   */\n  type: string;\n\n  /**\n   * Additional metadata associated with the file.\n   */\n  properties: Record<string, string | undefined>;\n}\n\nexport interface VirtualFileData {\n  /**\n   * The identifier for the file data.\n   */\n  id?: string;\n\n  /**\n   * The contents of the virtual file.\n   */\n  code: string;\n\n  /**\n   * The type of the file.\n   *\n   * @remarks\n   * This string represents the purpose/function of the file in the virtual file system. A potential list of variants includes:\n   * - `builtin`: Indicates that the file is a built-in module provided by the system.\n   * - `entry`: Indicates that the file is an entry point for execution.\n   * - `normal`: Indicates that the file is a standard file without any special role.\n   */\n  type?: string;\n\n  /**\n   * Additional metadata associated with the file.\n   */\n  properties?: Record<string, string | undefined>;\n}\n\nexport interface VirtualFile\n  extends Required<VirtualFileData>, VirtualFileMetadata {\n  /**\n   * An additional name for the file.\n   */\n  path: string;\n\n  /**\n   * The timestamp of the virtual file.\n   */\n  timestamp: number;\n}\n\nexport interface WriteOptions {\n  /**\n   * Should the file skip formatting before being written?\n   *\n   * @defaultValue false\n   */\n  skipFormat?: boolean;\n\n  /**\n   * The storage preset or adapter name for the output file.\n   *\n   * @remarks\n   * If not specified, the output mode will be determined by the provided `output.mode` value.\n   */\n  storage?: StoragePreset | string;\n\n  /**\n   * Additional metadata for the file.\n   */\n  meta?: Partial<VirtualFileMetadata>;\n}\n\nexport type WriteData = string | NodeJS.ArrayBufferView | VirtualFileData;\n\nexport interface ResolveOptions extends BaseResolveOptions {\n  /**\n   * If true, the module is being resolved as an entry point.\n   */\n  isEntry?: boolean;\n\n  /**\n   * If true, the resolver will skip alias resolution when resolving modules.\n   */\n  skipAlias?: boolean;\n\n  /**\n   * If true, the resolver will skip using the cache when resolving modules.\n   */\n  skipCache?: boolean;\n\n  /**\n   * An array of external modules or patterns to exclude from resolution.\n   */\n  external?: (string | RegExp)[];\n\n  /**\n   * An array of modules or patterns to include in the resolution, even if they are marked as external.\n   */\n  noExternal?: (string | RegExp)[];\n\n  /**\n   * An array of patterns to match when resolving modules.\n   */\n  skipNodeModulesBundle?: boolean;\n}\n\nexport interface VirtualFileSystemInterface {\n  /**\n   * The underlying file metadata.\n   */\n  metadata: Readonly<Record<string, VirtualFileMetadata>>;\n\n  /**\n   * A map of file paths to their module ids.\n   */\n  ids: Readonly<Record<string, string>>;\n\n  /**\n   * A map of module ids to their file paths.\n   */\n  paths: Readonly<Record<string, string>>;\n\n  /**\n   * Checks if a file exists in the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   * @returns `true` if the file exists, otherwise `false`.\n   */\n  exists: (path: string) => Promise<boolean>;\n\n  /**\n   * Synchronously Checks if a file exists in the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   * @returns `true` if the file exists, otherwise `false`.\n   */\n  existsSync: (path: string) => boolean;\n\n  /**\n   * Checks if a file is virtual in the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   * @returns `true` if the file is virtual, otherwise `false`.\n   */\n  isVirtual: (path: string) => boolean;\n\n  /**\n   * Checks if the given key is a directory.\n   *\n   * @param key - The key to check.\n   * @returns A promise that resolves to `true` if the key is a directory, otherwise `false`.\n   */\n  isDirectory: (key: string) => Promise<boolean>;\n\n  /**\n   * Synchronously checks if the given key is a directory.\n   *\n   * @param key - The key to check.\n   * @returns `true` if the key is a directory, otherwise `false`.\n   */\n  isDirectorySync: (key: string) => boolean;\n\n  /**\n   * Checks if the given key is a file.\n   *\n   * @param key - The key to check.\n   * @returns A promise that resolves to `true` if the key is a file, otherwise `false`.\n   */\n  isFile: (key: string) => Promise<boolean>;\n\n  /**\n   * Synchronously checks if the given key is a file.\n   *\n   * @param key - The key to check.\n   * @returns `true` if the key is a file, otherwise `false`.\n   */\n  isFileSync: (key: string) => boolean;\n\n  /**\n   * Gets the metadata of a file in the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   * @returns The metadata of the file if it exists, otherwise undefined.\n   */\n  getMetadata: (path: string) => VirtualFileMetadata | undefined;\n\n  /**\n   * Lists files in a given path.\n   *\n   * @param path - The path to list files from.\n   * @returns An array of file names in the specified path.\n   */\n  listSync: (path: string) => string[];\n\n  /**\n   * Lists files in a given path.\n   *\n   * @param path - The path to list files from.\n   * @returns An array of file names in the specified path.\n   */\n  list: (path: string) => Promise<string[]>;\n\n  /**\n   * Removes a file or symbolic link in the virtual file system (VFS).\n   *\n   * @param path - The path to the file to remove.\n   * @returns A promise that resolves when the file is removed.\n   */\n  removeSync: (path: string) => void;\n\n  /**\n   * Asynchronously removes a file or symbolic link in the virtual file system (VFS).\n   *\n   * @param path - The path to the file to remove.\n   * @returns A promise that resolves when the file is removed.\n   */\n  remove: (path: string) => Promise<void>;\n\n  /**\n   * Reads a file from the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   * @returns The contents of the file if it exists, otherwise undefined.\n   */\n  read: (path: string) => Promise<string | undefined>;\n\n  /**\n   * Reads a file from the virtual file system (VFS).\n   *\n   * @param path - The path or id of the file.\n   */\n  readSync: (path: string) => string | undefined;\n\n  /**\n   * Writes a file to the virtual file system (VFS).\n   *\n   * @param path - The path to the file.\n   * @param data - The contents of the file.\n   * @param options - Options for writing the file.\n   * @returns A promise that resolves when the file is written.\n   */\n  write: (path: string, data: string, options?: WriteOptions) => Promise<void>;\n\n  /**\n   * Writes a file to the virtual file system (VFS).\n   *\n   * @param path - The path to the file.\n   * @param data - The contents of the file.\n   * @param options - Options for writing the file.\n   */\n  writeSync: (path: string, data: string, options?: WriteOptions) => void;\n\n  /**\n   * Creates a directory at the specified path.\n   *\n   * @param dirPath - The path of the directory to create.\n   */\n  mkdir: (dirPath: string) => Promise<void>;\n\n  /**\n   * Synchronously creates a directory at the specified path.\n   *\n   * @param dirPath - The path of the directory to create.\n   */\n  mkdirSync: (dirPath: string) => void;\n\n  /**\n   * Moves a file from one path to another in the virtual file system (VFS).\n   *\n   * @param srcPath - The source path to move\n   * @param destPath - The destination path to move to\n   */\n  move: (srcPath: string, destPath: string) => Promise<void>;\n\n  /**\n   * Synchronously moves a file from one path to another in the virtual file system (VFS).\n   *\n   * @param srcPath - The source path to move\n   * @param destPath - The destination path to move to\n   */\n  moveSync: (srcPath: string, destPath: string) => void;\n\n  /**\n   * Copies a file from one path to another in the virtual file system (VFS).\n   *\n   * @param srcPath - The source path to copy\n   * @param destPath - The destination path to copy to\n   */\n  copy: (\n    srcPath: string | URL | Omit<AssetGlob, \"output\">,\n    destPath: string | URL\n  ) => Promise<void>;\n\n  /**\n   * Synchronously copies a file from one path to another in the virtual file system (VFS).\n   *\n   * @param srcPath - The source path to copy\n   * @param destPath - The destination path to copy to\n   */\n  copySync: (\n    srcPath: string | URL | Omit<AssetGlob, \"output\">,\n    destPath: string | URL\n  ) => void;\n\n  /**\n   * Glob files in the virtual file system (VFS) based on the provided pattern(s).\n   *\n   * @param pattern - A pattern (or multiple patterns) to use to determine the file paths to return\n   * @returns An array of file paths matching the provided pattern(s)\n   */\n  glob: (\n    patterns:\n      | string\n      | Omit<AssetGlob, \"output\">\n      | (string | Omit<AssetGlob, \"output\">)[]\n  ) => Promise<string[]>;\n\n  /**\n   * Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).\n   *\n   * @param pattern - A pattern (or multiple patterns) to use to determine the file paths to return\n   * @returns An array of file paths matching the provided pattern(s)\n   */\n  globSync: (\n    patterns:\n      | string\n      | Omit<AssetGlob, \"output\">\n      | (string | Omit<AssetGlob, \"output\">)[]\n  ) => string[];\n\n  /**\n   * A helper function to resolve modules using the Jiti resolver\n   *\n   * @remarks\n   * This function can be used to resolve modules relative to the project root directory.\n   *\n   * @example\n   * ```ts\n   * const resolvedPath = await context.resolve(\"some-module\", \"/path/to/importer\");\n   * ```\n   *\n   * @param id - The module to resolve.\n   * @param importer - An optional path to the importer module.\n   * @param options - Additional resolution options.\n   * @returns A promise that resolves to the resolved module path.\n   */\n  resolve: (\n    id: string,\n    importer?: string,\n    options?: ResolveOptions\n  ) => Promise<string | undefined>;\n\n  /**\n   * A synchronous helper function to resolve modules using the Jiti resolver\n   *\n   * @remarks\n   * This function can be used to resolve modules relative to the project root directory.\n   *\n   * @example\n   * ```ts\n   * const resolvedPath = context.resolveSync(\"some-module\", \"/path/to/importer\");\n   * ```\n   *\n   * @param id - The module to resolve.\n   * @param importer - An optional path to the importer module.\n   * @param options - Additional resolution options.\n   * @returns The resolved module path.\n   */\n  resolveSync: (\n    id: string,\n    importer?: string,\n    options?: ResolveOptions\n  ) => string | undefined;\n\n  /**\n   * Resolves a given module ID using the configured aliases.\n   *\n   * @remarks\n   * This function can be used to map module IDs to different paths based on the alias configuration.\n   *\n   * @param id - The module ID to resolve.\n   * @returns The resolved module ID - after applying any configured aliases (this will be the same as the input ID if no aliases match).\n   */\n  resolveAlias: (id: string) => string;\n\n  /**\n   * Disposes of the virtual file system (VFS), writes any virtual file changes to disk, and releases any associated resources.\n   */\n  dispose: () => Promise<void>;\n}\n"],"mappings":";;AAyBA,MAAa,gBAAgB;AAG7B,MAAa,iBAAiB;AAI9B,MAAaA,kBAAmC,CAAC,MAAM,UAAU"}