powerlines 0.24.8 → 0.25.0

package/dist/lib/chunk-WBSA6OG6.cjs

@@ -0,0 +1,860 @@
+'use strict';
+
+var chunkHRRI4KOM_cjs = require('./chunk-HRRI4KOM.cjs');
+var chunkR33US3PV_cjs = require('./chunk-R33US3PV.cjs');
+var chunkD6MI2V6R_cjs = require('./chunk-D6MI2V6R.cjs');
+var chunkGA3RXX4R_cjs = require('./chunk-GA3RXX4R.cjs');
+var chunkK3NBD5LL_cjs = require('./chunk-K3NBD5LL.cjs');
+var chunkJA4HSQRN_cjs = require('./chunk-JA4HSQRN.cjs');
+var chunkN5XEKCVW_cjs = require('./chunk-N5XEKCVW.cjs');
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var types = require('@storm-software/config-tools/types');
+var toArray = require('@stryke/convert/to-array');
+var getEnvPaths = require('@stryke/env/get-env-paths');
+var exists = require('@stryke/fs/exists');
+var getWorkspaceRoot = require('@stryke/fs/get-workspace-root');
+var json = require('@stryke/fs/json');
+var resolve = require('@stryke/fs/resolve');
+var hashFiles = require('@stryke/hash/hash-files');
+var murmurhash = require('@stryke/hash/murmurhash');
+var getUnique = require('@stryke/helpers/get-unique');
+var omit = require('@stryke/helpers/omit');
+var stormJson = require('@stryke/json/storm-json');
+var append = require('@stryke/path/append');
+var isType = require('@stryke/path/is-type');
+var join = require('@stryke/path/join');
+var replace = require('@stryke/path/replace');
+var titleCase = require('@stryke/string-format/title-case');
+var isNull = require('@stryke/type-checks/is-null');
+var isSetObject = require('@stryke/type-checks/is-set-object');
+var isSetString = require('@stryke/type-checks/is-set-string');
+var isString = require('@stryke/type-checks/is-string');
+var uuid = require('@stryke/unique-id/uuid');
+var bundleRequire = require('bundle-require');
+var defu2 = require('defu');
+var joinPaths = require('@stryke/path/join-paths');
+var jiti = require('jiti');
+var isFunction = require('@stryke/type-checks/is-function');
+var isUndefined = require('@stryke/type-checks/is-undefined');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var defu2__default = /*#__PURE__*/_interopDefault(defu2);
+
+function resolveOptions(options) {
+  return defu2__default.default(options, {
+    interopDefault: true,
+    fsCache: options.mode !== "development" ? joinPaths.joinPaths(options.cacheDir, "jiti") : false,
+    moduleCache: options.mode !== "development"
+  });
+}
+chunkUSNT2KNT_cjs.__name(resolveOptions, "resolveOptions");
+function createPluginResolver(options) {
+  return jiti.createJiti(joinPaths.joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions({
+    ...options
+  }));
+}
+chunkUSNT2KNT_cjs.__name(createPluginResolver, "createPluginResolver");
+function createResolver(options) {
+  const baseResolver = jiti.createJiti(joinPaths.joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions(options));
+  baseResolver.plugin = createPluginResolver(options);
+  return baseResolver;
+}
+chunkUSNT2KNT_cjs.__name(createResolver, "createResolver");
+
+// src/types/commands.ts
+var SUPPORTED_COMMANDS = [
+  "new",
+  "clean",
+  "prepare",
+  "lint",
+  "test",
+  "build",
+  "docs",
+  "deploy",
+  "finalize"
+];
+
+// src/plugin-utils/helpers.ts
+function isPlugin(value) {
+  return isSetObject.isSetObject(value) && "name" in value && isSetString.isSetString(value.name) && (isUndefined.isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction.isFunction(value.applyToEnvironment)) && (isUndefined.isUndefined(value.dedupe) || "dedupe" in value && isFunction.isFunction(value.dedupe)) && (isUndefined.isUndefined(value.dependsOn) || "dependsOn" in value && Array.isArray(value.dependsOn) && value.dependsOn.every(isPluginConfig)) && SUPPORTED_COMMANDS.every((command) => isUndefined.isUndefined(value[command]) || command in value && (isFunction.isFunction(value[command]) || isSetObject.isSetObject(value[command]) && "handler" in value[command] && isFunction.isFunction(value[command].handler)));
+}
+chunkUSNT2KNT_cjs.__name(isPlugin, "isPlugin");
+function isPluginConfigObject(value) {
+  return isSetObject.isSetObject(value) && "plugin" in value && ((isSetString.isSetString(value.plugin) || isFunction.isFunction(value.plugin)) && "options" in value && isSetObject.isSetObject(value.options) || isPlugin(value.plugin));
+}
+chunkUSNT2KNT_cjs.__name(isPluginConfigObject, "isPluginConfigObject");
+function isPluginConfigTuple(value) {
+  return Array.isArray(value) && (value.length === 1 || value.length === 2) && ((isSetString.isSetString(value[0]) || isFunction.isFunction(value[0])) && value.length > 1 && isSetObject.isSetObject(value[1]) || isPlugin(value[0]));
+}
+chunkUSNT2KNT_cjs.__name(isPluginConfigTuple, "isPluginConfigTuple");
+function isPluginConfig(value) {
+  return isSetString.isSetString(value) || isFunction.isFunction(value) || isPlugin(value) || isPluginConfigObject(value) || isPluginConfigTuple(value);
+}
+chunkUSNT2KNT_cjs.__name(isPluginConfig, "isPluginConfig");
+function isPluginHookFunction(value) {
+  return isFunction.isFunction(value) || isSetObject.isSetObject(value) && "handler" in value && isFunction.isFunction(value.handler);
+}
+chunkUSNT2KNT_cjs.__name(isPluginHookFunction, "isPluginHookFunction");
+function isPluginHookObject(value) {
+  return isSetObject.isSetObject(value) && "handler" in value && isFunction.isFunction(value.handler);
+}
+chunkUSNT2KNT_cjs.__name(isPluginHookObject, "isPluginHookObject");
+function isPluginHook(value) {
+  return isPluginHookFunction(value) || isPluginHookObject(value);
+}
+chunkUSNT2KNT_cjs.__name(isPluginHook, "isPluginHook");
+function getHookHandler(pluginHook) {
+  return isFunction.isFunction(pluginHook) ? pluginHook : pluginHook.handler;
+}
+chunkUSNT2KNT_cjs.__name(getHookHandler, "getHookHandler");
+function isHookExternal(hook) {
+  return hook.startsWith("vite:") || hook.startsWith("esbuild:") || hook.startsWith("rolldown:") || hook.startsWith("rollup:") || hook.startsWith("webpack:") || hook.startsWith("rspack:") || hook.startsWith("farm:");
+}
+chunkUSNT2KNT_cjs.__name(isHookExternal, "isHookExternal");
+function checkDedupe(plugin, plugins) {
+  return plugin.dedupe === false || plugins.some((p) => p.dedupe !== false && (isFunction.isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
+}
+chunkUSNT2KNT_cjs.__name(checkDedupe, "checkDedupe");
+function addPluginHook(context, plugin, pluginHook, hooksList) {
+  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) {
+    hooksList.push(isFunction.isFunction(pluginHook) ? {
+      plugin,
+      handler: getHookHandler(pluginHook).bind(context)
+    } : {
+      plugin,
+      ...pluginHook,
+      handler: getHookHandler(pluginHook).bind(context)
+    });
+  }
+}
+chunkUSNT2KNT_cjs.__name(addPluginHook, "addPluginHook");
+
+// src/lib/contexts/context.ts
+var configCache = /* @__PURE__ */ new WeakMap();
+var PowerlinesContext = class _PowerlinesContext {
+  static {
+    chunkUSNT2KNT_cjs.__name(this, "PowerlinesContext");
+  }
+  /**
+  * Internal reference to the API instance
+  *
+  * @internal
+  */
+  #api;
+  #workspaceConfig;
+  #checksum = null;
+  #buildId = uuid.uuid();
+  #releaseId = uuid.uuid();
+  #timestamp = Date.now();
+  #envPaths;
+  #fs;
+  #tsconfig;
+  #program;
+  #resolvePatterns = [];
+  #getConfigProps(config = {}) {
+    return {
+      variant: config.build?.variant,
+      projectType: config.type,
+      projectRoot: config.root,
+      name: config.name,
+      title: config.title,
+      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
+    };
+  }
+  /**
+  * 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 chunkK3NBD5LL_cjs.loadWorkspaceConfig(workspaceRoot, config.root));
+    await context.withUserConfig(config);
+    context.powerlinesPath = await resolve.resolvePackage("powerlines");
+    if (!context.powerlinesPath) {
+      throw new Error("Could not resolve `powerlines` package location.");
+    }
+    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;
+  /**
+  * Internal context fields and methods
+  *
+  * @internal
+  */
+  get $$internal() {
+    return {
+      api: this.#api
+    };
+  }
+  /**
+  * The resolved entry type definitions for the project
+  */
+  get entry() {
+    return chunkN5XEKCVW_cjs.resolveEntriesSync(this, toArray.toArray(this.config.entry));
+  }
+  /**
+  * 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 = bundleRequire.tsconfigPathsToRegExp(value?.options?.paths ?? {});
+  }
+  /**
+  * The virtual file system interface for the project
+  */
+  get fs() {
+    if (!this.#fs) {
+      this.#fs = chunkR33US3PV_cjs.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: murmurhash.murmurhash({
+        workspaceRoot: this.workspaceConfig?.workspaceRoot,
+        projectRoot: this.config?.projectRoot
+      }, {
+        maxLength: chunkHRRI4KOM_cjs.PROJECT_ROOT_HASH_LENGTH
+      }),
+      configHash: murmurhash.murmurhash(this.config, {
+        maxLength: chunkHRRI4KOM_cjs.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 (!this.#envPaths) {
+      this.#envPaths = getEnvPaths.getEnvPaths({
+        orgId: "storm-software",
+        appId: "powerlines",
+        workspaceRoot: this.workspaceConfig.workspaceRoot
+      });
+    }
+    return this.#envPaths;
+  }
+  /**
+  * Get the path to the artifacts directory for the project
+  */
+  get artifactsPath() {
+    return 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 join.joinPaths(this.artifactsPath, "builtins");
+  }
+  /**
+  * Get the path to the entry directory for the project
+  */
+  get entryPath() {
+    return join.joinPaths(this.artifactsPath, "entry");
+  }
+  /**
+  * Get the path to the data directory for the project
+  */
+  get dataPath() {
+    return join.joinPaths(this.envPaths.data, "projects", chunkHRRI4KOM_cjs.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+  }
+  /**
+  * Get the path to the cache directory for the project
+  */
+  get cachePath() {
+    return join.joinPaths(this.envPaths.cache, "projects", murmurhash.murmurhash({
+      checksum: this.#checksum,
+      config: this.meta.configHash
+    }, {
+      maxLength: chunkHRRI4KOM_cjs.CACHE_HASH_LENGTH
+    }));
+  }
+  /**
+  * Get the path to the generated declaration file for the project
+  */
+  get dtsPath() {
+    return this.config.output.dts ? append.appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : join.joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "powerlines.d.ts");
+  }
+  /**
+  * Get the project root relative to the workspace root
+  */
+  get relativeToWorkspaceRoot() {
+    return getWorkspaceRoot.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 = chunkD6MI2V6R_cjs.createProgram(this, {
+        skipAddingFilesFromTsConfig: true
+      });
+    }
+    return this.#program;
+  }
+  /**
+  * 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 resolveId(id, importer, options = {}) {
+    if (this.fs.isVirtual(id)) {
+      const result = await this.fs.resolve(id, importer, options);
+      if (!result) {
+        return void 0;
+      }
+      return {
+        id: `\0${result}`,
+        external: this.config.projectType !== "application"
+      };
+    }
+    if (this.config.build.skipNodeModulesBundle) {
+      if (bundleRequire.match(id, this.#resolvePatterns) || bundleRequire.match(id, this.config.build.noExternal)) {
+        return void 0;
+      }
+      if (bundleRequire.match(id, this.config.build.external) || id.startsWith("node:")) {
+        return {
+          id,
+          external: true
+        };
+      }
+      if (!/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(id)) {
+        return {
+          id,
+          external: true
+        };
+      }
+    } else {
+      if (bundleRequire.match(id, this.config.build.noExternal)) {
+        return void 0;
+      }
+      if (bundleRequire.match(id, this.config.build.external) || id.startsWith("node:")) {
+        return {
+          id,
+          external: true
+        };
+      }
+    }
+    return void 0;
+  }
+  /**
+  * 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 void 0;
+    }
+    const code = await this.fs.read(resolvedId);
+    if (!code) {
+      return void 0;
+    }
+    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 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 = {}) {
+    return this.fs.write(isType.isAbsolute(path) ? path : append.appendPath(path, this.entryPath), code, defu2__default.default(options, {
+      type: "entry"
+    }));
+  }
+  /**
+  * 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.fs.write(path ? isType.isAbsolute(path) ? path : join.joinPaths(this.builtinsPath, path) : append.appendPath(id, this.builtinsPath), code, defu2__default.default(options, {
+      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 = join.joinPaths(this.workspaceConfig.workspaceRoot, "package.json");
+      if (!exists.existsSync(workspacePackageJsonPath)) {
+        throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
+      }
+      this.packageJson = await json.readJsonFile(workspacePackageJsonPath);
+      this.workspaceConfig.repository ??= isSetString.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(types.LogLevelLabel.FATAL, isString.isString(message) ? message : stormJson.StormJSON.stringify(message));
+  }
+  /**
+  * A logging function for error messages
+  *
+  * @param message - The message to log.
+  */
+  error(message) {
+    this.log(types.LogLevelLabel.ERROR, isString.isString(message) ? message : stormJson.StormJSON.stringify(message));
+  }
+  /**
+  * A logging function for warning messages
+  *
+  * @param message - The message to log.
+  */
+  warn(message) {
+    this.log(types.LogLevelLabel.WARN, isString.isString(message) ? message : stormJson.StormJSON.stringify(message));
+  }
+  /**
+  * A logging function for informational messages
+  *
+  * @param message - The message to log.
+  */
+  info(message) {
+    this.log(types.LogLevelLabel.INFO, isString.isString(message) ? message : stormJson.StormJSON.stringify(message));
+  }
+  /**
+  * A logging function for debug messages
+  *
+  * @param message - The message to log.
+  */
+  debug(message) {
+    this.log(types.LogLevelLabel.DEBUG, isString.isString(message) ? message : stormJson.StormJSON.stringify(message));
+  }
+  /**
+  * A logging function for trace messages
+  *
+  * @param message - The message to log.
+  */
+  trace(message) {
+    this.log(types.LogLevelLabel.TRACE, isString.isString(message) ? message : stormJson.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 chunkJA4HSQRN_cjs.createLog(name, {
+      ...this.config,
+      logLevel: isNull.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 chunkJA4HSQRN_cjs.extendLog(this.log, name);
+  }
+  /**
+  * Creates a new StormContext instance.
+  *
+  * @param workspaceConfig - The workspace configuration.
+  */
+  constructor(workspaceConfig) {
+    this.#workspaceConfig = workspaceConfig;
+    this.#envPaths = getEnvPaths.getEnvPaths({
+      orgId: "storm-software",
+      appId: "powerlines",
+      workspaceRoot: workspaceConfig.workspaceRoot
+    });
+  }
+  /**
+  * The resolved configuration for this context
+  */
+  resolvedConfig = {};
+  /**
+  * A logger function specific to this context
+  */
+  logFn;
+  /**
+  * 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 hashFiles.hashDirectory(root, {
+      ignore: [
+        "node_modules",
+        ".git",
+        ".nx",
+        ".cache",
+        ".storm",
+        "tmp",
+        "dist"
+      ]
+    });
+    return this.#checksum;
+  }
+  /**
+  * 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 = join.joinPaths(cacheKey.projectRoot, "project.json");
+      if (exists.existsSync(projectJsonPath)) {
+        this.projectJson = await json.readJsonFile(projectJsonPath);
+      }
+      const packageJsonPath = join.joinPaths(cacheKey.projectRoot, "package.json");
+      if (exists.existsSync(packageJsonPath)) {
+        this.packageJson = await json.readJsonFile(packageJsonPath);
+      }
+      this.#checksum = await this.generateChecksum(cacheKey.projectRoot);
+      this.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 chunkK3NBD5LL_cjs.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 ??= chunkGA3RXX4R_cjs.getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.projectRoot, config.tsconfig);
+    if (isSetObject.isSetObject(config)) {
+      this.resolvedConfig = defu2__default.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 || append.appendPath("src", cacheKey.projectRoot),
+        output: defu2__default.default(config.output ?? {}, {
+          outputPath: cacheKey.projectRoot ? join.joinPaths(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
+          artifactsPath: join.joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
+          dts: 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 = chunkN5XEKCVW_cjs.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 ??= titleCase.titleCase(this.config.name);
+    if (this.config.build.external) {
+      this.config.build.external = getUnique.getUnique(this.config.build.external);
+    }
+    if (this.config.build.noExternal) {
+      this.config.build.noExternal = getUnique.getUnique(this.config.build.noExternal);
+    }
+    this.config.output.format = getUnique.getUnique(toArray.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 ??= join.joinPaths("dist", this.config.projectRoot);
+      this.config.output.buildPath ??= join.joinPaths(this.config.projectRoot, "dist");
+    } else {
+      this.config.output.outputPath ??= "dist";
+      this.config.output.buildPath ??= "dist";
+    }
+    this.config.output.assets = getUnique.getUnique(this.config.output.assets.map((asset) => {
+      return {
+        glob: isSetObject.isSetObject(asset) ? asset.glob : asset,
+        input: isString.isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : append.appendPath(asset.input, this.workspaceConfig.workspaceRoot),
+        output: append.appendPath(isSetObject.isSetObject(asset) && asset.output ? join.joinPaths(this.config.output.outputPath, replace.replacePath(asset.output, this.config.output.outputPath)) : this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
+        ignore: isSetObject.isSetObject(asset) && asset.ignore ? toArray.toArray(asset.ignore) : void 0
+      };
+    }));
+    this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
+        return ret;
+      }
+      ret.push(plugin);
+      return ret;
+    }, []);
+    if (this.config.tsconfig) {
+      this.config.tsconfig = chunkN5XEKCVW_cjs.replacePathTokens(this, this.config.tsconfig);
+    }
+    if (this.config.output.dts) {
+      this.config.output.dts = chunkN5XEKCVW_cjs.replacePathTokens(this, this.config.output.dts);
+    }
+    if (this.config.build.polyfill) {
+      this.config.build.polyfill = this.config.build.polyfill.map((polyfill) => chunkN5XEKCVW_cjs.replacePathTokens(this, polyfill));
+    }
+    if (this.config.output.assets) {
+      this.config.output.assets = this.config.output.assets.map((asset) => ({
+        ...asset,
+        glob: chunkN5XEKCVW_cjs.replacePathTokens(this, asset.glob),
+        ignore: asset.ignore ? asset.ignore.map((ignore) => chunkN5XEKCVW_cjs.replacePathTokens(this, ignore)) : void 0,
+        input: chunkN5XEKCVW_cjs.replacePathTokens(this, asset.input),
+        output: chunkN5XEKCVW_cjs.replacePathTokens(this, asset.output)
+      }));
+    }
+    this.#fs ??= await chunkR33US3PV_cjs.VirtualFileSystem.create(this);
+  }
+  mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
+    this.config.userConfig = defu2__default.default({
+      entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
+    }, omit.omit(from ?? {}, [
+      "entry"
+    ]), omit.omit(into ?? {}, [
+      "entry"
+    ]));
+    if (this.config.userConfig.output?.format) {
+      this.config.userConfig.output.format = getUnique.getUnique(toArray.toArray(this.config.userConfig.output?.format));
+    }
+    this.config.userConfig.plugins = (this.config.userConfig.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
+        return ret;
+      }
+      ret.push(plugin);
+      return ret;
+    }, []);
+  }
+};
+
+exports.PowerlinesContext = PowerlinesContext;
+exports.addPluginHook = addPluginHook;
+exports.checkDedupe = checkDedupe;
+exports.getHookHandler = getHookHandler;
+exports.isHookExternal = isHookExternal;
+exports.isPlugin = isPlugin;
+exports.isPluginConfig = isPluginConfig;
+exports.isPluginConfigObject = isPluginConfigObject;
+exports.isPluginConfigTuple = isPluginConfigTuple;
+exports.isPluginHook = isPluginHook;