powerlines 0.23.2 → 0.23.4

package/dist/lib/chunk-DX2VAXZB.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var defu = require('defu');
+
+function combineContexts(context, unplugin) {
+  return defu.defu(context, unplugin);
+}
+chunkUSNT2KNT_cjs.__name(combineContexts, "combineContexts");
+
+exports.combineContexts = combineContexts;

package/dist/lib/{chunk-VGSV2BEL.cjs → chunk-EFYMNU53.cjs}

@@ -1,19 +1,14 @@
 'use strict';
 
-var chunkULJVBW4L_cjs = require('./chunk-ULJVBW4L.cjs');
+var chunkDX2VAXZB_cjs = require('./chunk-DX2VAXZB.cjs');
+var chunkZBDVQVUK_cjs = require('./chunk-ZBDVQVUK.cjs');
 var chunkJA4HSQRN_cjs = require('./chunk-JA4HSQRN.cjs');
 var chunk3OCI4TH7_cjs = require('./chunk-3OCI4TH7.cjs');
 var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
 var types = require('@storm-software/config-tools/types');
-var omit = require('@stryke/helpers/omit');
 var filePathFns = require('@stryke/path/file-path-fns');
 var replace = require('@stryke/path/replace');
 var isString = require('@stryke/type-checks/is-string');
-var defu = require('defu');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var defu__default = /*#__PURE__*/_interopDefault(defu);
 
 function createUnplugin(context, options = {}) {
   const ctx = context;
@@ -48,7 +43,7 @@ function createUnplugin(context, options = {}) {
           if (result) {
             return result;
           }
-          result = await chunkULJVBW4L_cjs.handleResolveId(ctx, {
+          result = await chunkZBDVQVUK_cjs.handleResolveId(ctx, {
             id,
             importer,
             options: opts
@@ -74,7 +69,7 @@ function createUnplugin(context, options = {}) {
             entry.output ||= entry.output?.replace(filePathFns.findFileName(entry.output, {
               withExtension: true
             }), entry.file);
-            await ctx.writeEntry(`
+            await ctx.emitEntry(`
 ${ctx.config.build.polyfill.map((p) => `import "${p}";`).join("\n")}
 
 export * from "${isString.isString(resolved) ? resolved : resolved.id}";
@@ -120,9 +115,7 @@ export * from "${isString.isString(resolved) ? resolved : resolved.id}";
       async function transform(code, id) {
         let transformed = code;
         for (const handler of ctx.$$internal.environment.selectHooks("transform")) {
-          const result = await handler.apply(defu__default.default(ctx, omit.omit(this, [
-            "parse"
-          ])), [
+          const result = await handler.apply(chunkDX2VAXZB_cjs.combineContexts(ctx, this), [
             chunk3OCI4TH7_cjs.getString(transformed),
             id
           ]);
@@ -149,6 +142,7 @@ export * from "${isString.isString(resolved) ? resolved : resolved.id}";
       chunkUSNT2KNT_cjs.__name(writeBundle, "writeBundle");
       return {
         name: "powerlines",
+        api: ctx.$$internal.api,
         resolveId: {
           filter: {
             id: {

package/dist/lib/chunk-FBQIPNRV.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+var chunkB3EE3VHZ_cjs = require('./chunk-B3EE3VHZ.cjs');
+var chunkPYQADZVV_cjs = require('./chunk-PYQADZVV.cjs');
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var resolve = require('@stryke/fs/resolve');
+var isFunction = require('@stryke/type-checks/is-function');
+var isObject = require('@stryke/type-checks/is-object');
+
+// src/types/plugin.ts
+var PLUGIN_NON_HOOK_FIELDS = [
+  "name",
+  "enforce",
+  "dedupe",
+  "dependsOn",
+  "applyToEnvironment"
+];
+
+// src/lib/contexts/environment-context.ts
+var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends chunkPYQADZVV_cjs.PowerlinesContext {
+  static {
+    chunkUSNT2KNT_cjs.__name(this, "PowerlinesEnvironmentContext");
+  }
+  /**
+  * The hooks registered by plugins in this environment
+  */
+  #hooks = {};
+  /**
+  * Create a new Storm context from the workspace root and user config.
+  *
+  * @param workspaceConfig - The root directory of the workspace.
+  * @param config - The user configuration options.
+  * @returns A promise that resolves to the new context.
+  */
+  static async fromConfig(workspaceConfig, config) {
+    const context = new _PowerlinesEnvironmentContext(config, workspaceConfig);
+    await context.init();
+    context.powerlinesPath = await resolve.resolvePackage("powerlines");
+    if (!context.powerlinesPath) {
+      throw new Error("Could not resolve `powerlines` package location.");
+    }
+    return context;
+  }
+  /**
+  * The resolved environment configuration
+  */
+  environment;
+  /**
+  * The list of plugins applied to this environment
+  */
+  plugins = [];
+  /**
+  * The resolved configuration options
+  */
+  get config() {
+    return super.config;
+  }
+  get hooks() {
+    return this.#hooks;
+  }
+  async addPlugin(plugin) {
+    let resolvedPlugin = plugin;
+    if (plugin.applyToEnvironment) {
+      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+      if (!result || isObject.isObject(result) && Object.keys(result).length === 0) {
+        return;
+      }
+      resolvedPlugin = chunkPYQADZVV_cjs.isPlugin(result) ? result : plugin;
+    }
+    const context = chunkB3EE3VHZ_cjs.createPluginContext(resolvedPlugin, this);
+    this.plugins.push({
+      plugin: resolvedPlugin,
+      context
+    });
+    this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
+      const hook = key;
+      const pluginHook = resolvedPlugin[hook];
+      if (!chunkPYQADZVV_cjs.isPluginHook(pluginHook)) {
+        return ret;
+      }
+      if (!chunkPYQADZVV_cjs.isHookExternal(hook)) {
+        ret[hook] ??= {};
+        if (resolvedPlugin.enforce) {
+          ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
+          chunkPYQADZVV_cjs.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
+          return ret;
+        }
+        if (isFunction.isFunction(pluginHook) || !pluginHook.order) {
+          ret[hook].normal ??= [];
+          chunkPYQADZVV_cjs.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
+          return ret;
+        }
+        ret[hook][`${pluginHook.order}Ordered`] ??= [];
+        chunkPYQADZVV_cjs.addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
+      } else {
+        ret[hook] ??= [];
+        ret[hook].push({
+          plugin: resolvedPlugin,
+          hook: chunkPYQADZVV_cjs.getHookHandler(pluginHook).bind(context)
+        });
+      }
+      return ret;
+    }, this.hooks);
+  }
+  /**
+  * Retrieves the hook handlers for a specific hook name
+  */
+  selectHooks(hook, options) {
+    const handlers = [];
+    if (this.hooks[hook]) {
+      if (!chunkPYQADZVV_cjs.isHookExternal(hook)) {
+        const hooks = this.hooks[hook];
+        if (options?.order) {
+          if (options?.order === "pre") {
+            handlers.push(...(hooks.preOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.preEnforced ?? []).map((h) => h.handler));
+          } else if (options?.order === "post") {
+            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
+          } else {
+            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
+          }
+        } else {
+          handlers.push(...this.selectHooks(hook, {
+            order: "pre"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "normal"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "post"
+          }));
+        }
+      } else {
+        handlers.push(...this.hooks[hook].map((h) => h.handler));
+      }
+    }
+    return handlers;
+  }
+  constructor(config, workspaceConfig) {
+    super(workspaceConfig);
+    this.resolvedConfig = config;
+  }
+};
+
+exports.PowerlinesEnvironmentContext = PowerlinesEnvironmentContext;

package/dist/lib/chunk-FFT4PWRM.js

@@ -0,0 +1 @@
+

package/dist/lib/{chunk-L4NEN725.js → chunk-G7S5PIAC.js}

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

package/dist/lib/chunk-KFJCWNVG.js

@@ -0,0 +1,120 @@
+import { __name } from './chunk-SHUYVCID.js';
+import { LogLevelLabel } from '@storm-software/config-tools/types';
+import { isString } from '@stryke/type-checks/is-string';
+import { isFunction } from '@stryke/type-checks/is-function';
+import { isSet } from '@stryke/type-checks/is-set';
+import chalk from 'chalk';
+import { defu } from 'defu';
+
+async function callHook(context, hook, options, ...args) {
+  const handlers = context.selectHooks(hook, options);
+  if (handlers.length > 0) {
+    context.log(LogLevelLabel.DEBUG, ` \u{1F9E9}  Calling plugin hook: ${chalk.bold.cyanBright(`${hook}${options?.order ? ` (${options.order})` : ""}`)}`);
+    let results = [];
+    if (options?.sequential === false) {
+      results = await Promise.all(handlers.map(async (handler) => {
+        if (!isFunction(handler)) {
+          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
+        }
+        return Promise.resolve(handler.apply(null, ...args));
+      }));
+    } else {
+      for (const handler of handlers) {
+        if (!isFunction(handler)) {
+          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
+        }
+        results.push(await Promise.resolve(handler.apply(null, ...args)));
+        if (options?.result === "first" && isSet(results[results.length - 1])) {
+          break;
+        }
+      }
+    }
+    const definedResults = results.filter((result) => isSet(result));
+    if (definedResults.length > 0) {
+      let mergedResult = void 0;
+      for (const result of definedResults) {
+        mergedResult = defu(result, mergedResult ?? {});
+      }
+      return mergedResult;
+    }
+  }
+  return void 0;
+}
+__name(callHook, "callHook");
+
+// src/lib/contexts/plugin-context.ts
+function createPluginContext(plugin, environment) {
+  const normalizeMessage = /* @__PURE__ */ __name((message) => {
+    return isString(message) ? message : message.message;
+  }, "normalizeMessage");
+  const log = environment.extendLog(plugin.name);
+  const callHookFn = /* @__PURE__ */ __name(async (hook, options, ...args) => {
+    return callHook(environment, hook, {
+      sequential: true,
+      ...options
+    }, ...args);
+  }, "callHookFn");
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "$$internal") {
+        return {
+          ...environment.$$internal,
+          environment,
+          callHook: callHookFn
+        };
+      }
+      if (prop === "log" || prop === "logger") {
+        return log;
+      }
+      if (prop === "error") {
+        return (message) => {
+          log(LogLevelLabel.ERROR, normalizeMessage(message));
+        };
+      }
+      if (prop === "warn") {
+        return (message) => {
+          log(LogLevelLabel.WARN, normalizeMessage(message));
+        };
+      }
+      if (prop === "info") {
+        return (message) => {
+          log(LogLevelLabel.INFO, normalizeMessage(message));
+        };
+      }
+      if (prop === "debug") {
+        return (message) => {
+          log(LogLevelLabel.DEBUG, normalizeMessage(message));
+        };
+      }
+      if (prop === "trace") {
+        return (message) => {
+          log(LogLevelLabel.TRACE, normalizeMessage(message));
+        };
+      }
+      return environment[prop];
+    },
+    set(_, prop, value) {
+      if ([
+        "$$internal",
+        "environment",
+        "config",
+        "log",
+        "logger",
+        "error",
+        "warn",
+        "plugins",
+        "hooks",
+        "addPlugin",
+        "selectHooks"
+      ].includes(prop)) {
+        log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
+        return false;
+      }
+      environment[prop] = value;
+      return true;
+    }
+  });
+}
+__name(createPluginContext, "createPluginContext");
+
+export { callHook, createPluginContext };

package/dist/lib/chunk-M2U6XIQ2.js

@@ -0,0 +1,144 @@
+import { createPluginContext } from './chunk-KFJCWNVG.js';
+import { PowerlinesContext, isPlugin, isPluginHook, isHookExternal, addPluginHook, getHookHandler } from './chunk-BLNW3ZQA.js';
+import { __name } from './chunk-SHUYVCID.js';
+import { resolvePackage } from '@stryke/fs/resolve';
+import { isFunction } from '@stryke/type-checks/is-function';
+import { isObject } from '@stryke/type-checks/is-object';
+
+// src/types/plugin.ts
+var PLUGIN_NON_HOOK_FIELDS = [
+  "name",
+  "enforce",
+  "dedupe",
+  "dependsOn",
+  "applyToEnvironment"
+];
+
+// src/lib/contexts/environment-context.ts
+var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends PowerlinesContext {
+  static {
+    __name(this, "PowerlinesEnvironmentContext");
+  }
+  /**
+  * The hooks registered by plugins in this environment
+  */
+  #hooks = {};
+  /**
+  * Create a new Storm context from the workspace root and user config.
+  *
+  * @param workspaceConfig - The root directory of the workspace.
+  * @param config - The user configuration options.
+  * @returns A promise that resolves to the new context.
+  */
+  static async fromConfig(workspaceConfig, config) {
+    const context = new _PowerlinesEnvironmentContext(config, workspaceConfig);
+    await context.init();
+    context.powerlinesPath = await resolvePackage("powerlines");
+    if (!context.powerlinesPath) {
+      throw new Error("Could not resolve `powerlines` package location.");
+    }
+    return context;
+  }
+  /**
+  * The resolved environment configuration
+  */
+  environment;
+  /**
+  * The list of plugins applied to this environment
+  */
+  plugins = [];
+  /**
+  * The resolved configuration options
+  */
+  get config() {
+    return super.config;
+  }
+  get hooks() {
+    return this.#hooks;
+  }
+  async addPlugin(plugin) {
+    let resolvedPlugin = plugin;
+    if (plugin.applyToEnvironment) {
+      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+      if (!result || isObject(result) && Object.keys(result).length === 0) {
+        return;
+      }
+      resolvedPlugin = isPlugin(result) ? result : plugin;
+    }
+    const context = createPluginContext(resolvedPlugin, this);
+    this.plugins.push({
+      plugin: resolvedPlugin,
+      context
+    });
+    this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
+      const hook = key;
+      const pluginHook = resolvedPlugin[hook];
+      if (!isPluginHook(pluginHook)) {
+        return ret;
+      }
+      if (!isHookExternal(hook)) {
+        ret[hook] ??= {};
+        if (resolvedPlugin.enforce) {
+          ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
+          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
+          return ret;
+        }
+        if (isFunction(pluginHook) || !pluginHook.order) {
+          ret[hook].normal ??= [];
+          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
+          return ret;
+        }
+        ret[hook][`${pluginHook.order}Ordered`] ??= [];
+        addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
+      } else {
+        ret[hook] ??= [];
+        ret[hook].push({
+          plugin: resolvedPlugin,
+          hook: getHookHandler(pluginHook).bind(context)
+        });
+      }
+      return ret;
+    }, this.hooks);
+  }
+  /**
+  * Retrieves the hook handlers for a specific hook name
+  */
+  selectHooks(hook, options) {
+    const handlers = [];
+    if (this.hooks[hook]) {
+      if (!isHookExternal(hook)) {
+        const hooks = this.hooks[hook];
+        if (options?.order) {
+          if (options?.order === "pre") {
+            handlers.push(...(hooks.preOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.preEnforced ?? []).map((h) => h.handler));
+          } else if (options?.order === "post") {
+            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
+          } else {
+            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
+          }
+        } else {
+          handlers.push(...this.selectHooks(hook, {
+            order: "pre"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "normal"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "post"
+          }));
+        }
+      } else {
+        handlers.push(...this.hooks[hook].map((h) => h.handler));
+      }
+    }
+    return handlers;
+  }
+  constructor(config, workspaceConfig) {
+    super(workspaceConfig);
+    this.resolvedConfig = config;
+  }
+};
+
+export { PowerlinesEnvironmentContext };

package/dist/lib/chunk-MVIKYHBX.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/lib/chunk-NYNHNTHT.js

@@ -0,0 +1 @@
+