powerlines 0.23.3 → 0.23.5

package/dist/lib/chunk-NYNHNTHT.js

@@ -0,0 +1 @@
+

package/dist/lib/chunk-SZH2DJOG.js

@@ -0,0 +1,168 @@
+import { PowerlinesEnvironmentContext } from './chunk-EN4XP4D5.js';
+import { PowerlinesContext } from './chunk-764HUXP3.js';
+import { loadWorkspaceConfig } from './chunk-ZPIKFR7Z.js';
+import { __name } from './chunk-SHUYVCID.js';
+import { LogLevelLabel } from '@storm-software/config-tools/types';
+import { toArray } from '@stryke/convert/to-array';
+import { resolvePackage } from '@stryke/fs/resolve';
+import { isSetObject } from '@stryke/type-checks/is-set-object';
+import chalk from 'chalk';
+import { titleCase } from '@stryke/string-format/title-case';
+import defu from 'defu';
+
+var DEFAULT_ENVIRONMENT = "default";
+function createEnvironment(name, userConfig) {
+  return defu(userConfig.environments?.[name] ?? {}, {
+    name,
+    title: userConfig.title || titleCase(userConfig.name),
+    ssr: false,
+    mainFields: userConfig.build?.platform === "browser" ? [
+      "browser",
+      "module",
+      "jsnext:main",
+      "jsnext"
+    ] : [
+      "module",
+      "jsnext:main",
+      "jsnext"
+    ],
+    extensions: [
+      ".mjs",
+      ".js",
+      ".mts",
+      ".ts",
+      ".jsx",
+      ".tsx",
+      ".json"
+    ],
+    consumer: userConfig.build?.platform === "browser" ? "client" : "server",
+    preview: userConfig.build?.platform === "browser" ? {
+      port: 5173,
+      open: true,
+      strictPort: false,
+      // https: false,
+      host: "localhost",
+      allowedHosts: [
+        "."
+      ],
+      cors: true,
+      headers: {}
+    } : void 0
+  }, userConfig);
+}
+__name(createEnvironment, "createEnvironment");
+function createDefaultEnvironment(userConfig) {
+  return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
+}
+__name(createDefaultEnvironment, "createDefaultEnvironment");
+
+// src/lib/contexts/api-context.ts
+var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext {
+  static {
+    __name(this, "PowerlinesAPIContext");
+  }
+  #environments = {};
+  #plugins = [];
+  #log;
+  /**
+  * 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 _PowerlinesAPIContext(await loadWorkspaceConfig(workspaceRoot, config.root));
+    await context.withUserConfig(config);
+    context.powerlinesPath = await resolvePackage("powerlines");
+    if (!context.powerlinesPath) {
+      throw new Error("Could not resolve `powerlines` package location.");
+    }
+    return context;
+  }
+  /**
+  * A record of all environments by name
+  */
+  get environments() {
+    return this.#environments;
+  }
+  get log() {
+    if (!this.#log) {
+      this.#log = this.createLog("engine");
+    }
+    return this.#log;
+  }
+  get plugins() {
+    return this.#plugins;
+  }
+  constructor(workspaceConfig) {
+    super(workspaceConfig);
+  }
+  /**
+  * Initialize the context with the provided configuration options
+  *
+  * @param config - The partial user configuration to use for initialization.
+  */
+  async init(config = {}) {
+    await super.init(config);
+    await Promise.all(toArray(this.config.userConfig.environments && Object.keys(this.config.userConfig.environments).length > 0 ? Object.keys(this.config.userConfig.environments).map((name) => createEnvironment(name, this.config.userConfig)) : createDefaultEnvironment(this.config.userConfig)).map(async (env) => {
+      this.#environments[env.name] = await this.in(env);
+    }));
+  }
+  /**
+  * 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.
+  */
+  async in(environment) {
+    let context;
+    if (this.environments[environment.name]) {
+      context = this.environments[environment.name];
+    } else {
+      context = await PowerlinesEnvironmentContext.fromConfig(this.workspaceConfig, this.config);
+    }
+    if (isSetObject(this.config.inlineConfig)) {
+      await context.withInlineConfig(this.config.inlineConfig);
+    }
+    context.environment = environment;
+    context.plugins = [];
+    for (const plugin of this.plugins) {
+      await context.addPlugin(plugin);
+    }
+    return context;
+  }
+  async addPlugin(plugin) {
+    this.plugins.push(plugin);
+    await Promise.all(Object.keys(this.environments).map(async (name) => {
+      await this.environments[name].addPlugin(plugin);
+    }));
+  }
+  async getEnvironment(name) {
+    let environment;
+    if (name) {
+      environment = this.environments[name];
+    }
+    if (Object.keys(this.environments).length === 1) {
+      environment = this.environments[Object.keys(this.environments)[0]];
+      this.log(LogLevelLabel.DEBUG, `Applying the only configured environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
+    }
+    if (!environment) {
+      if (name) {
+        throw new Error(`Environment "${name}" not found.`);
+      }
+      environment = await this.in(createDefaultEnvironment(this.config.userConfig));
+      this.log(LogLevelLabel.WARN, `No environment specified, and no default environment found. Using a temporary default environment: ${chalk.bold.cyanBright(environment?.environment.name)}`);
+    }
+    return environment;
+  }
+  async getEnvironmentSafe(name) {
+    try {
+      return await this.getEnvironment(name);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+export { PowerlinesAPIContext };

package/dist/lib/{chunk-ULJVBW4L.cjs → chunk-ZBDVQVUK.cjs}

@@ -73,7 +73,7 @@ async function handleResolveId(context, args, options = {}) {
           args.importer
         ] : []
       });
-      if (bundleRequire.match(args.id, options.noExternal) || resolvedPath && context.fs.metadata[resolvedPath]?.variant === "builtin") {
+      if (bundleRequire.match(args.id, options.noExternal) || resolvedPath && context.fs.metadata[resolvedPath]?.type === "builtin") {
         return void 0;
       }
       if (bundleRequire.match(args.id, options.external) || args.id.startsWith("node:")) {