conduithub 0.0.1 → 0.0.2

package/dist/core/hook/index.d.ts

@@ -0,0 +1,40 @@
+import { c as createLogger } from '../../shared/conduithub.B7aryjPG.js';
+
+interface HookResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface HookHandler<I = unknown, O = unknown> {
+    id: string;
+    hook: string;
+    handler: (data: I) => Promise<HookResult<O> | O> | HookResult<O> | O;
+    priority: number;
+}
+
+declare class Hook<HM extends Record<string, {
+    input: any;
+    output: any;
+}>> {
+    private hooks;
+    private initialized;
+    private logger;
+    private failFast;
+    private onError?;
+    constructor(options?: {
+        failFast?: boolean;
+        onError?: (err: unknown, hook: keyof HM) => void;
+    }, logger?: ReturnType<typeof createLogger>);
+    private ensure;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    registerHook<K extends keyof HM>(hook: K, handler: (data: HM[K]["input"]) => HookResult<HM[K]["output"]> | Promise<HookResult<HM[K]["output"]>> | HM[K]["output"] | Promise<HM[K]["output"]>, priority?: number, customId?: string): string;
+    unregisterHook<K extends keyof HM>(hook: K, id: string): boolean;
+    private handleHookResult;
+    executeHook<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HM[K]["output"]>;
+    executeHookSeries<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HookResult<HM[K]["output"]>[]>;
+    executeHookSeriesWithContext<K extends keyof HM>(hook: K, data: HM[K]["input"], context: Record<string, unknown>): Promise<HookResult<HM[K]["output"]>[]>;
+}
+
+export { Hook };
+export type { HookHandler, HookResult };

package/dist/core/hook/index.mjs

@@ -0,0 +1,208 @@
+import { c as createLogger, g as generateUuid } from '../../shared/conduithub.74V0wiLi.mjs';
+import 'uuid';
+
+class Hook {
+  hooks = /* @__PURE__ */ new Map();
+  initialized = false;
+  logger;
+  failFast;
+  onError;
+  constructor(options, logger) {
+    this.failFast = options?.failFast ?? false;
+    this.onError = options?.onError;
+    this.logger = logger ?? createLogger({ name: "Hook" });
+  }
+  ensure() {
+    if (!this.initialized) throw new Error("Hook system is not initialized");
+  }
+  async initialize() {
+    if (!this.initialized) {
+      this.initialized = true;
+      this.logger.success("Hook system initialized successfully");
+    }
+  }
+  async shutdown() {
+    this.ensure();
+    const hookCount = Array.from(this.hooks.values()).reduce(
+      (total, handlers) => total + handlers.length,
+      0
+    );
+    this.hooks.clear();
+    this.initialized = false;
+    this.logger.success(
+      `Hook system shutdown completed - cleared ${hookCount} handlers`
+    );
+  }
+  registerHook(hook, handler, priority = 0, customId) {
+    this.ensure();
+    if (!this.hooks.has(hook)) this.hooks.set(hook, []);
+    const id = customId ?? generateUuid();
+    const entry = {
+      id,
+      hook: String(hook),
+      handler,
+      priority
+    };
+    this.hooks.get(hook).push(entry);
+    this.hooks.get(hook).sort((a, b) => b.priority - a.priority);
+    const handlerCount = this.hooks.get(hook).length;
+    this.logger.debug(
+      `Hook registered: '${String(hook)}' \u2192 ${id} (priority: ${priority}, total handlers: ${handlerCount})`
+    );
+    return id;
+  }
+  unregisterHook(hook, id) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list) {
+      this.logger.warn(
+        `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
+      );
+      return false;
+    }
+    const index = list.findIndex((h) => h.id === id);
+    if (index >= 0) {
+      list.splice(index, 1);
+      const remainingCount = list.length;
+      if (remainingCount === 0) this.hooks.delete(hook);
+      this.logger.debug(
+        `Hook unregistered: '${String(hook)}' \u2192 ${id} (remaining handlers: ${remainingCount})`
+      );
+      return true;
+    }
+    this.logger.warn(
+      `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
+    );
+    return false;
+  }
+  async handleHookResult(raw, failFast, hook, handlerId) {
+    try {
+      const result = await raw;
+      if (typeof result === "object" && result && "success" in result) {
+        const res = result;
+        if (!res.success && failFast) throw new Error(res.error);
+        this.logger.debug(
+          `Hook handler completed: '${String(hook)}' \u2192 ${handlerId} (success: ${res.success})`
+        );
+        return res;
+      }
+      this.logger.debug(
+        `Hook handler completed: '${String(hook)}' \u2192 ${handlerId} (success: true)`
+      );
+      return { success: true, data: result };
+    } catch (err) {
+      if (failFast) throw err;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.logger.error(
+        `Hook handler failed: '${String(hook)}' \u2192 ${handlerId} - ${errorMessage}`
+      );
+      this.onError?.(err, hook);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  async executeHook(hook, data) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list?.length) {
+      this.logger.debug(
+        `Hook execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return data;
+    }
+    this.logger.debug(
+      `Hook execution started: '${String(hook)}' (${list.length} handlers)`
+    );
+    let result = data;
+    let successCount = 0;
+    let errorCount = 0;
+    for (const { handler, id } of list) {
+      const {
+        success,
+        data: output,
+        error
+      } = await this.handleHookResult(
+        Promise.resolve().then(() => handler(result)),
+        this.failFast,
+        hook,
+        id
+      );
+      if (success) {
+        successCount++;
+        if (output !== void 0) result = output;
+      } else {
+        errorCount++;
+        if (this.failFast) throw new Error(error);
+      }
+    }
+    this.logger.debug(
+      `Hook execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return result;
+  }
+  async executeHookSeries(hook, data) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list?.length) {
+      this.logger.debug(
+        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return [];
+    }
+    this.logger.debug(
+      `Hook series execution started: '${String(hook)}' (${list.length} handlers)`
+    );
+    const results = [];
+    for (const { handler, id } of list) {
+      const result = await this.handleHookResult(
+        Promise.resolve().then(() => handler(data)),
+        false,
+        // Never fail fast in series execution, just collect results
+        hook,
+        id
+      );
+      results.push(result);
+      if (!result.success && this.failFast) break;
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const errorCount = results.filter((r) => !r.success).length;
+    this.logger.debug(
+      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return results;
+  }
+  async executeHookSeriesWithContext(hook, data, context) {
+    this.ensure();
+    const handlers = this.hooks.get(hook);
+    if (!handlers || handlers.length === 0) {
+      this.logger.debug(
+        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return [];
+    }
+    this.logger.debug(
+      `Hook series execution started: '${String(hook)}' (${handlers.length} handlers)`
+    );
+    const results = [];
+    for (const { handler, id } of handlers) {
+      const result = await this.handleHookResult(
+        Promise.resolve().then(() => handler(data)),
+        this.failFast,
+        hook,
+        id
+      );
+      results.push(result);
+      if (!result.success && this.failFast) break;
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const errorCount = results.filter((r) => !r.success).length;
+    this.logger.debug(
+      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return results;
+  }
+}
+
+export { Hook };

package/dist/core/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const core_eventBus_index = require('./event-bus/index.cjs');
+const core_hook_index = require('./hook/index.cjs');
+require('../shared/conduithub.CvMLTa-R.cjs');
+require('uuid');
+
+
+
+exports.EventBus = core_eventBus_index.EventBus;
+exports.Hook = core_hook_index.Hook;

package/dist/core/index.d.cts

@@ -0,0 +1,3 @@
+export { EventBus, EventData, EventHandlerRecord } from './event-bus/index.cjs';
+export { Hook, HookHandler, HookResult } from './hook/index.cjs';
+import '../shared/conduithub.B7aryjPG.cjs';

package/dist/core/index.d.mts

@@ -0,0 +1,3 @@
+export { EventBus, EventData, EventHandlerRecord } from './event-bus/index.mjs';
+export { Hook, HookHandler, HookResult } from './hook/index.mjs';
+import '../shared/conduithub.B7aryjPG.mjs';

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { EventBus, EventData, EventHandlerRecord } from './event-bus/index.js';
+export { Hook, HookHandler, HookResult } from './hook/index.js';
+import '../shared/conduithub.B7aryjPG.js';

package/dist/core/index.mjs

@@ -0,0 +1,4 @@
+export { EventBus } from './event-bus/index.mjs';
+export { Hook } from './hook/index.mjs';
+import '../shared/conduithub.74V0wiLi.mjs';
+import 'uuid';

package/dist/index.cjs

@@ -1,10 +1,16 @@
 'use strict';
 
-const utils_index = require('./utils/index.cjs');
+const core_eventBus_index = require('./core/event-bus/index.cjs');
+const core_hook_index = require('./core/hook/index.cjs');
+const uuid = require('./shared/conduithub.CvMLTa-R.cjs');
+require('uuid');
 
 
 
-exports.createLogger = utils_index.createLogger;
-exports.levels = utils_index.levels;
-exports.logger = utils_index.logger;
-exports.shouldPublishLog = utils_index.shouldPublishLog;
+exports.EventBus = core_eventBus_index.EventBus;
+exports.Hook = core_hook_index.Hook;
+exports.createLogger = uuid.createLogger;
+exports.generateUuid = uuid.generateUuid;
+exports.levels = uuid.levels;
+exports.logger = uuid.logger;
+exports.shouldPublishLog = uuid.shouldPublishLog;

package/dist/index.d.cts

@@ -1 +1,4 @@
-export { LogHandlerParams, LogLevel, Logger, createLogger, levels, logger, shouldPublishLog } from './utils/index.cjs';
+export { EventBus, EventData, EventHandlerRecord } from './core/event-bus/index.cjs';
+export { Hook, HookHandler, HookResult } from './core/hook/index.cjs';
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from './shared/conduithub.B7aryjPG.cjs';
+export { generateUuid } from './utils/index.cjs';

package/dist/index.d.mts

@@ -1 +1,4 @@
-export { LogHandlerParams, LogLevel, Logger, createLogger, levels, logger, shouldPublishLog } from './utils/index.mjs';
+export { EventBus, EventData, EventHandlerRecord } from './core/event-bus/index.mjs';
+export { Hook, HookHandler, HookResult } from './core/hook/index.mjs';
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from './shared/conduithub.B7aryjPG.mjs';
+export { generateUuid } from './utils/index.mjs';

package/dist/index.d.ts

@@ -1 +1,4 @@
-export { LogHandlerParams, LogLevel, Logger, createLogger, levels, logger, shouldPublishLog } from './utils/index.js';
+export { EventBus, EventData, EventHandlerRecord } from './core/event-bus/index.js';
+export { Hook, HookHandler, HookResult } from './core/hook/index.js';
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from './shared/conduithub.B7aryjPG.js';
+export { generateUuid } from './utils/index.js';

package/dist/index.mjs

@@ -1 +1,4 @@
-export { createLogger, levels, logger, shouldPublishLog } from './utils/index.mjs';
+export { EventBus } from './core/event-bus/index.mjs';
+export { Hook } from './core/hook/index.mjs';
+export { c as createLogger, g as generateUuid, l as levels, a as logger, s as shouldPublishLog } from './shared/conduithub.74V0wiLi.mjs';
+import 'uuid';

package/dist/shared/conduithub.74V0wiLi.mjs

@@ -0,0 +1,62 @@
+import { v4 } from 'uuid';
+
+const levels = ["info", "success", "warn", "error", "debug"];
+function shouldPublishLog(currentLogLevel, logLevel) {
+  return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  fg: {
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m"}};
+const levelColors = {
+  info: colors.fg.blue,
+  success: colors.fg.green,
+  warn: colors.fg.yellow,
+  error: colors.fg.red,
+  debug: colors.fg.magenta
+};
+const formatMessage = (level, message, name) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${name ?? "ConduiHub"}]:${colors.reset} ${message}`;
+};
+const createLogger = (options) => {
+  const enabled = options?.disabled !== true;
+  const logLevel = options?.level ?? "error";
+  const name = options?.name ?? "ConduiHub";
+  const LogFunc = (level, message, args = []) => {
+    if (!enabled || !shouldPublishLog(logLevel, level)) {
+      return;
+    }
+    const formattedMessage = formatMessage(level, message, name);
+    if (!options || typeof options.log !== "function") {
+      if (level === "error") {
+        console.error(formattedMessage, ...args);
+      } else if (level === "warn") {
+        console.warn(formattedMessage, ...args);
+      } else {
+        console.log(formattedMessage, ...args);
+      }
+      return;
+    }
+    options.log(level === "success" ? "info" : level, message, ...args);
+  };
+  return Object.fromEntries(
+    levels.map((level) => [
+      level,
+      (...[message, ...args]) => LogFunc(level, message, args)
+    ])
+  );
+};
+const logger = createLogger();
+
+const generateUuid = () => {
+  return v4();
+};
+
+export { logger as a, createLogger as c, generateUuid as g, levels as l, shouldPublishLog as s };

package/dist/shared/conduithub.B7aryjPG.d.cts

@@ -0,0 +1,18 @@
+type LogLevel = "info" | "success" | "warn" | "error" | "debug";
+declare const levels: readonly ["info", "success", "warn", "error", "debug"];
+declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
+interface Logger {
+    disabled?: boolean;
+    level?: Exclude<LogLevel, "success">;
+    name?: string;
+    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
+}
+type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [
+    LogLevel,
+    ...infer Rest
+] ? Rest : never;
+declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
+declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+
+export { createLogger as c, logger as d, levels as l, shouldPublishLog as s };
+export type { LogLevel as L, Logger as a, LogHandlerParams as b };

package/dist/shared/conduithub.B7aryjPG.d.mts

@@ -0,0 +1,18 @@
+type LogLevel = "info" | "success" | "warn" | "error" | "debug";
+declare const levels: readonly ["info", "success", "warn", "error", "debug"];
+declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
+interface Logger {
+    disabled?: boolean;
+    level?: Exclude<LogLevel, "success">;
+    name?: string;
+    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
+}
+type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [
+    LogLevel,
+    ...infer Rest
+] ? Rest : never;
+declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
+declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+
+export { createLogger as c, logger as d, levels as l, shouldPublishLog as s };
+export type { LogLevel as L, Logger as a, LogHandlerParams as b };

package/dist/shared/conduithub.B7aryjPG.d.ts

@@ -0,0 +1,18 @@
+type LogLevel = "info" | "success" | "warn" | "error" | "debug";
+declare const levels: readonly ["info", "success", "warn", "error", "debug"];
+declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
+interface Logger {
+    disabled?: boolean;
+    level?: Exclude<LogLevel, "success">;
+    name?: string;
+    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
+}
+type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [
+    LogLevel,
+    ...infer Rest
+] ? Rest : never;
+declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
+declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+
+export { createLogger as c, logger as d, levels as l, shouldPublishLog as s };
+export type { LogLevel as L, Logger as a, LogHandlerParams as b };

package/dist/shared/conduithub.CvMLTa-R.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+const uuid = require('uuid');
+
+const levels = ["info", "success", "warn", "error", "debug"];
+function shouldPublishLog(currentLogLevel, logLevel) {
+  return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  fg: {
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m"}};
+const levelColors = {
+  info: colors.fg.blue,
+  success: colors.fg.green,
+  warn: colors.fg.yellow,
+  error: colors.fg.red,
+  debug: colors.fg.magenta
+};
+const formatMessage = (level, message, name) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${name ?? "ConduiHub"}]:${colors.reset} ${message}`;
+};
+const createLogger = (options) => {
+  const enabled = options?.disabled !== true;
+  const logLevel = options?.level ?? "error";
+  const name = options?.name ?? "ConduiHub";
+  const LogFunc = (level, message, args = []) => {
+    if (!enabled || !shouldPublishLog(logLevel, level)) {
+      return;
+    }
+    const formattedMessage = formatMessage(level, message, name);
+    if (!options || typeof options.log !== "function") {
+      if (level === "error") {
+        console.error(formattedMessage, ...args);
+      } else if (level === "warn") {
+        console.warn(formattedMessage, ...args);
+      } else {
+        console.log(formattedMessage, ...args);
+      }
+      return;
+    }
+    options.log(level === "success" ? "info" : level, message, ...args);
+  };
+  return Object.fromEntries(
+    levels.map((level) => [
+      level,
+      (...[message, ...args]) => LogFunc(level, message, args)
+    ])
+  );
+};
+const logger = createLogger();
+
+const generateUuid = () => {
+  return uuid.v4();
+};
+
+exports.createLogger = createLogger;
+exports.generateUuid = generateUuid;
+exports.levels = levels;
+exports.logger = logger;
+exports.shouldPublishLog = shouldPublishLog;

package/dist/utils/index.cjs

@@ -1,58 +1,12 @@
 'use strict';
 
-const levels = ["info", "success", "warn", "error", "debug"];
-function shouldPublishLog(currentLogLevel, logLevel) {
-  return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
-}
-const colors = {
-  reset: "\x1B[0m",
-  bright: "\x1B[1m",
-  dim: "\x1B[2m",
-  fg: {
-    red: "\x1B[31m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    blue: "\x1B[34m",
-    magenta: "\x1B[35m"}};
-const levelColors = {
-  info: colors.fg.blue,
-  success: colors.fg.green,
-  warn: colors.fg.yellow,
-  error: colors.fg.red,
-  debug: colors.fg.magenta
-};
-const formatMessage = (level, message, name) => {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${name ?? "ConduiHub"}]:${colors.reset} ${message}`;
-};
-const createLogger = (options) => {
-  const enabled = options?.disabled !== true;
-  const logLevel = options?.level ?? "error";
-  const name = options?.name ?? "ConduiHub";
-  const LogFunc = (level, message, args = []) => {
-    if (!enabled || !shouldPublishLog(logLevel, level)) {
-      return;
-    }
-    const formattedMessage = formatMessage(level, message, name);
-    if (!options || typeof options.log !== "function") {
-      if (level === "error") {
-        console.error(formattedMessage, ...args);
-      } else if (level === "warn") {
-        console.warn(formattedMessage, ...args);
-      } else {
-        console.log(formattedMessage, ...args);
-      }
-      return;
-    }
-    options.log(level === "success" ? "info" : level, message, ...args);
-  };
-  return Object.fromEntries(
-    levels.map((level) => [level, (...[message, ...args]) => LogFunc(level, message, args)])
-  );
-};
-const logger = createLogger();
+const uuid = require('../shared/conduithub.CvMLTa-R.cjs');
+require('uuid');
 
-exports.createLogger = createLogger;
-exports.levels = levels;
-exports.logger = logger;
-exports.shouldPublishLog = shouldPublishLog;
+
+
+exports.createLogger = uuid.createLogger;
+exports.generateUuid = uuid.generateUuid;
+exports.levels = uuid.levels;
+exports.logger = uuid.logger;
+exports.shouldPublishLog = uuid.shouldPublishLog;

package/dist/utils/index.d.cts

@@ -1,15 +1,5 @@
-type LogLevel = "info" | "success" | "warn" | "error" | "debug";
-declare const levels: readonly ["info", "success", "warn", "error", "debug"];
-declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
-interface Logger {
-    disabled?: boolean;
-    level?: Exclude<LogLevel, "success">;
-    name?: string;
-    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
-}
-type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [LogLevel, ...infer Rest] ? Rest : never;
-declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
-declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from '../shared/conduithub.B7aryjPG.cjs';
 
-export { createLogger, levels, logger, shouldPublishLog };
-export type { LogHandlerParams, LogLevel, Logger };
+declare const generateUuid: () => string;
+
+export { generateUuid };

package/dist/utils/index.d.mts

@@ -1,15 +1,5 @@
-type LogLevel = "info" | "success" | "warn" | "error" | "debug";
-declare const levels: readonly ["info", "success", "warn", "error", "debug"];
-declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
-interface Logger {
-    disabled?: boolean;
-    level?: Exclude<LogLevel, "success">;
-    name?: string;
-    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
-}
-type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [LogLevel, ...infer Rest] ? Rest : never;
-declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
-declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from '../shared/conduithub.B7aryjPG.mjs';
 
-export { createLogger, levels, logger, shouldPublishLog };
-export type { LogHandlerParams, LogLevel, Logger };
+declare const generateUuid: () => string;
+
+export { generateUuid };

package/dist/utils/index.d.ts

@@ -1,15 +1,5 @@
-type LogLevel = "info" | "success" | "warn" | "error" | "debug";
-declare const levels: readonly ["info", "success", "warn", "error", "debug"];
-declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
-interface Logger {
-    disabled?: boolean;
-    level?: Exclude<LogLevel, "success">;
-    name?: string;
-    log?: (level: Exclude<LogLevel, "success">, message: string, ...args: unknown[]) => void;
-}
-type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [LogLevel, ...infer Rest] ? Rest : never;
-declare const createLogger: (options?: Logger) => Record<LogLevel, (...params: LogHandlerParams) => void>;
-declare const logger: Record<LogLevel, (message: string, ...args: unknown[]) => void>;
+export { b as LogHandlerParams, L as LogLevel, a as Logger, c as createLogger, l as levels, d as logger, s as shouldPublishLog } from '../shared/conduithub.B7aryjPG.js';
 
-export { createLogger, levels, logger, shouldPublishLog };
-export type { LogHandlerParams, LogLevel, Logger };
+declare const generateUuid: () => string;
+
+export { generateUuid };