@classytic/payroll 1.0.2 → 2.3.0

package/dist/core/index.js

@@ -0,0 +1,1166 @@
+import { LRUCache } from 'lru-cache';
+
+// src/core/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}
+function unwrapOrElse(result, fn) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  return fn(result.error);
+}
+function map(result, fn) {
+  if (isOk(result)) {
+    return ok(fn(result.value));
+  }
+  return result;
+}
+function mapErr(result, fn) {
+  if (isErr(result)) {
+    return err(fn(result.error));
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (isOk(result)) {
+    return fn(result.value);
+  }
+  return result;
+}
+async function tryCatch(fn, errorTransform) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (error) {
+    if (errorTransform) {
+      return err(errorTransform(error));
+    }
+    return err(error);
+  }
+}
+function tryCatchSync(fn, errorTransform) {
+  try {
+    const value = fn();
+    return ok(value);
+  } catch (error) {
+    if (errorTransform) {
+      return err(errorTransform(error));
+    }
+    return err(error);
+  }
+}
+function all(results) {
+  const values = [];
+  for (const result of results) {
+    if (isErr(result)) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function match(result, handlers) {
+  if (isOk(result)) {
+    return handlers.ok(result.value);
+  }
+  return handlers.err(result.error);
+}
+async function fromPromise(promise, errorTransform) {
+  return tryCatch(() => promise, errorTransform);
+}
+function fromNullable(value, error) {
+  if (value === null || value === void 0) {
+    return err(error);
+  }
+  return ok(value);
+}
+var ResultClass = class _ResultClass {
+  constructor(result) {
+    this.result = result;
+  }
+  static ok(value) {
+    return new _ResultClass(ok(value));
+  }
+  static err(error) {
+    return new _ResultClass(err(error));
+  }
+  static async fromAsync(fn, errorTransform) {
+    const result = await tryCatch(fn, errorTransform);
+    return new _ResultClass(result);
+  }
+  isOk() {
+    return isOk(this.result);
+  }
+  isErr() {
+    return isErr(this.result);
+  }
+  unwrap() {
+    return unwrap(this.result);
+  }
+  unwrapOr(defaultValue) {
+    return unwrapOr(this.result, defaultValue);
+  }
+  map(fn) {
+    return new _ResultClass(map(this.result, fn));
+  }
+  mapErr(fn) {
+    return new _ResultClass(mapErr(this.result, fn));
+  }
+  flatMap(fn) {
+    return new _ResultClass(flatMap(this.result, fn));
+  }
+  match(handlers) {
+    return match(this.result, handlers);
+  }
+  toResult() {
+    return this.result;
+  }
+};
+var Result = {
+  ok,
+  err,
+  isOk,
+  isErr,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse,
+  map,
+  mapErr,
+  flatMap,
+  tryCatch,
+  tryCatchSync,
+  all,
+  match,
+  fromPromise,
+  fromNullable
+};
+
+// src/core/events.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Register a one-time event handler
+   */
+  once(event, handler) {
+    const wrappedHandler = async (payload) => {
+      this.off(event, wrappedHandler);
+      await handler(payload);
+    };
+    return this.on(event, wrappedHandler);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  async emit(event, payload) {
+    const eventHandlers = this.handlers.get(event);
+    if (!eventHandlers || eventHandlers.size === 0) {
+      return;
+    }
+    const handlers = Array.from(eventHandlers);
+    await Promise.all(
+      handlers.map(async (handler) => {
+        try {
+          await handler(payload);
+        } catch (error) {
+          console.error(`Event handler error for ${event}:`, error);
+        }
+      })
+    );
+  }
+  /**
+   * Emit event synchronously (fire-and-forget)
+   */
+  emitSync(event, payload) {
+    void this.emit(event, payload);
+  }
+  /**
+   * Remove all handlers for an event
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+  /**
+   * Get listener count for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /**
+   * Get all registered events
+   */
+  eventNames() {
+    return Array.from(this.handlers.keys());
+  }
+};
+var defaultEventBus = null;
+function getEventBus() {
+  if (!defaultEventBus) {
+    defaultEventBus = new EventBus();
+  }
+  return defaultEventBus;
+}
+function createEventBus() {
+  return new EventBus();
+}
+function resetEventBus() {
+  if (defaultEventBus) {
+    defaultEventBus.removeAllListeners();
+  }
+  defaultEventBus = null;
+}
+function onEmployeeHired(handler) {
+  return getEventBus().on("employee:hired", handler);
+}
+function onSalaryProcessed(handler) {
+  return getEventBus().on("salary:processed", handler);
+}
+function onPayrollCompleted(handler) {
+  return getEventBus().on("payroll:completed", handler);
+}
+function onMilestoneAchieved(handler) {
+  return getEventBus().on("milestone:achieved", handler);
+}
+var IdempotencyManager = class {
+  cache;
+  constructor(options = {}) {
+    this.cache = new LRUCache({
+      max: options.max || 1e4,
+      // Store 10k keys
+      ttl: options.ttl || 1e3 * 60 * 60 * 24
+      // 24 hours default
+    });
+  }
+  /**
+   * Check if key exists and return cached result
+   */
+  get(key) {
+    const cached = this.cache.get(key);
+    if (!cached) return null;
+    return {
+      value: cached.value,
+      cached: true,
+      createdAt: cached.createdAt
+    };
+  }
+  /**
+   * Store result for idempotency key
+   */
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Execute function with idempotency protection
+   */
+  async execute(key, fn) {
+    const cached = this.get(key);
+    if (cached) {
+      return cached;
+    }
+    const value = await fn();
+    this.set(key, value);
+    return {
+      value,
+      cached: false,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Clear a specific key
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Clear all keys
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache stats
+   */
+  stats() {
+    return {
+      size: this.cache.size,
+      max: this.cache.max
+    };
+  }
+};
+function generatePayrollIdempotencyKey(organizationId, employeeId, month, year) {
+  return `payroll:${organizationId}:${employeeId}:${year}-${month}`;
+}
+
+// src/core/webhooks.ts
+var WebhookManager = class {
+  webhooks = [];
+  deliveryLog = [];
+  /**
+   * Register a webhook
+   */
+  register(config) {
+    this.webhooks.push({
+      retries: 3,
+      timeout: 3e4,
+      ...config
+    });
+  }
+  /**
+   * Remove a webhook
+   */
+  unregister(url) {
+    this.webhooks = this.webhooks.filter((w) => w.url !== url);
+  }
+  /**
+   * Send webhook for event
+   */
+  async send(event, payload) {
+    const matchingWebhooks = this.webhooks.filter((w) => w.events.includes(event));
+    const deliveries = matchingWebhooks.map(
+      (webhook) => this.deliver(webhook, event, payload)
+    );
+    await Promise.allSettled(deliveries);
+  }
+  /**
+   * Deliver webhook with retries
+   */
+  async deliver(webhook, event, payload) {
+    const deliveryId = `${Date.now()}-${Math.random().toString(36)}`;
+    const delivery = {
+      id: deliveryId,
+      event,
+      url: webhook.url,
+      payload,
+      attempt: 0,
+      status: "pending"
+    };
+    this.deliveryLog.push(delivery);
+    const maxRetries = webhook.retries || 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      delivery.attempt = attempt;
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), webhook.timeout || 3e4);
+        const headers = {
+          "Content-Type": "application/json",
+          "X-Payroll-Event": event,
+          "X-Payroll-Delivery": deliveryId,
+          ...webhook.headers
+        };
+        if (webhook.secret) {
+          headers["X-Payroll-Signature"] = this.generateSignature(payload, webhook.secret);
+        }
+        const response = await fetch(webhook.url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            event,
+            payload,
+            deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }),
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        delivery.response = {
+          status: response.status,
+          body: await response.text()
+        };
+        delivery.sentAt = /* @__PURE__ */ new Date();
+        if (response.ok) {
+          delivery.status = "sent";
+          return delivery;
+        }
+        if (response.status >= 500 && attempt < maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        delivery.status = "failed";
+        delivery.error = `HTTP ${response.status}`;
+        return delivery;
+      } catch (error) {
+        delivery.error = error.message;
+        if (attempt < maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        delivery.status = "failed";
+        return delivery;
+      }
+    }
+    return delivery;
+  }
+  /**
+   * Generate HMAC signature for webhook
+   */
+  generateSignature(payload, secret) {
+    const data = JSON.stringify(payload);
+    return Buffer.from(`${secret}:${data}`).toString("base64");
+  }
+  /**
+   * Sleep for ms
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get delivery log
+   */
+  getDeliveries(options) {
+    let results = this.deliveryLog;
+    if (options?.event) {
+      results = results.filter((d) => d.event === options.event);
+    }
+    if (options?.status) {
+      results = results.filter((d) => d.status === options.status);
+    }
+    if (options?.limit) {
+      results = results.slice(-options.limit);
+    }
+    return results;
+  }
+  /**
+   * Clear delivery log
+   */
+  clearLog() {
+    this.deliveryLog = [];
+  }
+  /**
+   * Get all registered webhooks
+   */
+  getWebhooks() {
+    return [...this.webhooks];
+  }
+};
+
+// src/core/plugin.ts
+var PluginManager = class {
+  constructor(context) {
+    this.context = context;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  hooks = /* @__PURE__ */ new Map();
+  /**
+   * Register a plugin
+   */
+  async register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    if (plugin.hooks) {
+      for (const [hookName, handler] of Object.entries(plugin.hooks)) {
+        if (handler) {
+          this.addHook(hookName, handler);
+        }
+      }
+    }
+    if (plugin.init) {
+      await plugin.init(this.context);
+    }
+    this.plugins.set(plugin.name, plugin);
+    this.context.logger.debug(`Plugin "${plugin.name}" registered`);
+  }
+  /**
+   * Unregister a plugin
+   */
+  async unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      return;
+    }
+    if (plugin.destroy) {
+      await plugin.destroy();
+    }
+    this.plugins.delete(name);
+    this.context.logger.debug(`Plugin "${name}" unregistered`);
+  }
+  /**
+   * Add a hook handler
+   */
+  addHook(hookName, handler) {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, []);
+    }
+    this.hooks.get(hookName).push(handler);
+  }
+  /**
+   * Execute hooks for a given event
+   */
+  async executeHooks(hookName, ...args) {
+    const handlers = this.hooks.get(hookName);
+    if (!handlers || handlers.length === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      try {
+        await handler(...args);
+      } catch (error) {
+        this.context.logger.error(`Hook "${hookName}" error:`, { error });
+        const errorHandlers = this.hooks.get("onError");
+        if (errorHandlers) {
+          for (const errorHandler of errorHandlers) {
+            try {
+              await errorHandler(error, hookName);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get registered plugin names
+   */
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  /**
+   * Check if plugin is registered
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+};
+function definePlugin(definition) {
+  return definition;
+}
+var loggingPlugin = definePlugin({
+  name: "logging",
+  version: "1.0.0",
+  init: (context) => {
+    context.addHook("employee:hired", (payload) => {
+      context.logger.info("Employee hired", {
+        employeeId: payload.employee.employeeId,
+        position: payload.employee.position
+      });
+    });
+    context.addHook("salary:processed", (payload) => {
+      context.logger.info("Salary processed", {
+        employeeId: payload.employee.employeeId,
+        amount: payload.payroll.netAmount,
+        period: payload.payroll.period
+      });
+    });
+    context.addHook("employee:terminated", (payload) => {
+      context.logger.info("Employee terminated", {
+        employeeId: payload.employee.employeeId,
+        reason: payload.reason
+      });
+    });
+  },
+  hooks: {
+    onError: (error, context) => {
+      console.error(`[Payroll Error] ${context}:`, error.message);
+    }
+  }
+});
+var metricsPlugin = definePlugin({
+  name: "metrics",
+  version: "1.0.0",
+  init: (context) => {
+    const metrics = {
+      employeesHired: 0,
+      employeesTerminated: 0,
+      salariesProcessed: 0,
+      totalPaid: 0,
+      errors: 0
+    };
+    context.addHook("employee:hired", () => {
+      metrics.employeesHired++;
+    });
+    context.addHook("employee:terminated", () => {
+      metrics.employeesTerminated++;
+    });
+    context.addHook("salary:processed", (payload) => {
+      metrics.salariesProcessed++;
+      metrics.totalPaid += payload.payroll.netAmount;
+    });
+    context.payroll.metrics = metrics;
+  },
+  hooks: {
+    onError: (error, context) => {
+    }
+  }
+});
+function createNotificationPlugin(options) {
+  return definePlugin({
+    name: "notification",
+    version: "1.0.0",
+    init: (context) => {
+      if (options.onHired) {
+        context.addHook("employee:hired", async (payload) => {
+          await options.onHired({
+            id: payload.employee.id,
+            name: payload.employee.position
+          });
+        });
+      }
+      if (options.onTerminated) {
+        context.addHook("employee:terminated", async (payload) => {
+          await options.onTerminated({
+            id: payload.employee.id,
+            name: payload.employee.name
+          });
+        });
+      }
+      if (options.onSalaryProcessed) {
+        context.addHook("salary:processed", async (payload) => {
+          await options.onSalaryProcessed({
+            employee: {
+              id: payload.employee.id,
+              name: payload.employee.name
+            },
+            amount: payload.payroll.netAmount
+          });
+        });
+      }
+      if (options.onMilestone) {
+        context.addHook("milestone:achieved", async (payload) => {
+          await options.onMilestone({
+            employee: {
+              id: payload.employee.id,
+              name: payload.employee.name
+            },
+            milestone: payload.milestone.message
+          });
+        });
+      }
+    }
+  });
+}
+var notificationPlugin = createNotificationPlugin({});
+
+// src/utils/logger.ts
+var createConsoleLogger = () => ({
+  info: (message, meta) => {
+    if (meta) {
+      console.log(`[Payroll] INFO: ${message}`, meta);
+    } else {
+      console.log(`[Payroll] INFO: ${message}`);
+    }
+  },
+  error: (message, meta) => {
+    if (meta) {
+      console.error(`[Payroll] ERROR: ${message}`, meta);
+    } else {
+      console.error(`[Payroll] ERROR: ${message}`);
+    }
+  },
+  warn: (message, meta) => {
+    if (meta) {
+      console.warn(`[Payroll] WARN: ${message}`, meta);
+    } else {
+      console.warn(`[Payroll] WARN: ${message}`);
+    }
+  },
+  debug: (message, meta) => {
+    if (process.env.NODE_ENV !== "production") {
+      if (meta) {
+        console.log(`[Payroll] DEBUG: ${message}`, meta);
+      } else {
+        console.log(`[Payroll] DEBUG: ${message}`);
+      }
+    }
+  }
+});
+var currentLogger = createConsoleLogger();
+function getLogger() {
+  return currentLogger;
+}
+
+// src/config.ts
+var HRM_CONFIG = {
+  dataRetention: {
+    payrollRecordsTTL: 63072e3,
+    // 2 years in seconds
+    exportWarningDays: 30,
+    archiveBeforeDeletion: true
+  },
+  payroll: {
+    defaultCurrency: "BDT",
+    allowProRating: true,
+    attendanceIntegration: true,
+    autoDeductions: true,
+    overtimeEnabled: false,
+    overtimeMultiplier: 1.5
+  },
+  salary: {
+    minimumWage: 0,
+    maximumAllowances: 10,
+    maximumDeductions: 10,
+    defaultFrequency: "monthly"
+  },
+  employment: {
+    defaultProbationMonths: 3,
+    maxProbationMonths: 6,
+    allowReHiring: true,
+    trackEmploymentHistory: true
+  },
+  validation: {
+    requireBankDetails: false,
+    requireUserId: false,
+    // Modern: Allow guest employees by default
+    identityMode: "employeeId",
+    // Modern: Use human-readable IDs as primary
+    identityFallbacks: ["email", "userId"]
+    // Smart fallback chain
+  }
+};
+var ORG_ROLES = {
+  OWNER: {
+    key: "owner",
+    label: "Owner",
+    description: "Full organization access (set by Organization model)"
+  },
+  MANAGER: {
+    key: "manager",
+    label: "Manager",
+    description: "Management and administrative features"
+  },
+  TRAINER: {
+    key: "trainer",
+    label: "Trainer",
+    description: "Training and coaching features"
+  },
+  STAFF: {
+    key: "staff",
+    label: "Staff",
+    description: "General staff access to basic features"
+  },
+  INTERN: {
+    key: "intern",
+    label: "Intern",
+    description: "Limited access for interns"
+  },
+  CONSULTANT: {
+    key: "consultant",
+    label: "Consultant",
+    description: "Project-based consultant access"
+  }
+};
+Object.values(ORG_ROLES).map((role) => role.key);
+function mergeConfig(customConfig) {
+  if (!customConfig) return HRM_CONFIG;
+  return {
+    dataRetention: { ...HRM_CONFIG.dataRetention, ...customConfig.dataRetention },
+    payroll: { ...HRM_CONFIG.payroll, ...customConfig.payroll },
+    salary: { ...HRM_CONFIG.salary, ...customConfig.salary },
+    employment: { ...HRM_CONFIG.employment, ...customConfig.employment },
+    validation: {
+      ...HRM_CONFIG.validation,
+      ...customConfig.validation,
+      // Ensure fallbacks is always EmployeeIdentityMode[]
+      identityFallbacks: customConfig.validation?.identityFallbacks ?? HRM_CONFIG.validation.identityFallbacks
+    }
+  };
+}
+
+// src/core/container.ts
+var Container = class {
+  _models = null;
+  _config = HRM_CONFIG;
+  _singleTenant = null;
+  _logger;
+  _initialized = false;
+  constructor() {
+    this._logger = getLogger();
+  }
+  /**
+   * Initialize container with configuration
+   */
+  initialize(config) {
+    if (this._initialized) {
+      this._logger.warn("Container already initialized, re-initializing");
+    }
+    this._models = config.models;
+    this._config = mergeConfig(config.config);
+    this._singleTenant = config.singleTenant ?? null;
+    if (config.logger) {
+      this._logger = config.logger;
+    }
+    this._initialized = true;
+    this._logger.info("Container initialized", {
+      hasEmployeeModel: !!this._models.EmployeeModel,
+      hasPayrollRecordModel: !!this._models.PayrollRecordModel,
+      hasTransactionModel: !!this._models.TransactionModel,
+      hasAttendanceModel: !!this._models.AttendanceModel,
+      hasLeaveRequestModel: !!this._models.LeaveRequestModel,
+      hasTaxWithholdingModel: !!this._models.TaxWithholdingModel,
+      isSingleTenant: !!this._singleTenant
+    });
+  }
+  /**
+   * Check if container is initialized
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Reset container (useful for testing)
+   */
+  reset() {
+    this._models = null;
+    this._config = HRM_CONFIG;
+    this._singleTenant = null;
+    this._initialized = false;
+    this._logger.info("Container reset");
+  }
+  /**
+   * Ensure container is initialized
+   */
+  ensureInitialized() {
+    if (!this._initialized || !this._models) {
+      throw new Error(
+        "Payroll not initialized. Call Payroll.initialize() first."
+      );
+    }
+  }
+  /**
+   * Get models container (strongly typed)
+   */
+  getModels() {
+    this.ensureInitialized();
+    return this._models;
+  }
+  /**
+   * Get Employee model (strongly typed)
+   */
+  getEmployeeModel() {
+    this.ensureInitialized();
+    return this._models.EmployeeModel;
+  }
+  /**
+   * Get PayrollRecord model (strongly typed)
+   */
+  getPayrollRecordModel() {
+    this.ensureInitialized();
+    return this._models.PayrollRecordModel;
+  }
+  /**
+   * Get Transaction model (strongly typed)
+   */
+  getTransactionModel() {
+    this.ensureInitialized();
+    return this._models.TransactionModel;
+  }
+  /**
+   * Get Attendance model (optional, strongly typed)
+   */
+  getAttendanceModel() {
+    this.ensureInitialized();
+    return this._models.AttendanceModel ?? null;
+  }
+  /**
+   * Get LeaveRequest model (optional, strongly typed)
+   */
+  getLeaveRequestModel() {
+    this.ensureInitialized();
+    return this._models.LeaveRequestModel ?? null;
+  }
+  /**
+   * Get TaxWithholding model (optional, strongly typed)
+   */
+  getTaxWithholdingModel() {
+    this.ensureInitialized();
+    return this._models.TaxWithholdingModel ?? null;
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this._config;
+  }
+  /**
+   * Get specific config section
+   */
+  getConfigSection(section) {
+    return this._config[section];
+  }
+  /**
+   * Check if single-tenant mode
+   */
+  isSingleTenant() {
+    return !!this._singleTenant;
+  }
+  /**
+   * Get single-tenant config
+   */
+  getSingleTenantConfig() {
+    return this._singleTenant;
+  }
+  /**
+   * Get organization ID (for single-tenant mode)
+   */
+  getOrganizationId() {
+    if (!this._singleTenant || !this._singleTenant.organizationId) return null;
+    return typeof this._singleTenant.organizationId === "string" ? this._singleTenant.organizationId : this._singleTenant.organizationId.toString();
+  }
+  /**
+   * Get logger
+   */
+  getLogger() {
+    return this._logger;
+  }
+  /**
+   * Set logger
+   */
+  setLogger(logger) {
+    this._logger = logger;
+  }
+  /**
+   * Has attendance integration
+   */
+  hasAttendanceIntegration() {
+    return !!this._models?.AttendanceModel && this._config.payroll.attendanceIntegration;
+  }
+  /**
+   * Create operation context with defaults
+   */
+  createOperationContext(overrides) {
+    const context = {};
+    if (this._singleTenant?.autoInject && !overrides?.organizationId) {
+      context.organizationId = this.getOrganizationId();
+    }
+    return { ...context, ...overrides };
+  }
+};
+var defaultContainer = null;
+function getContainer() {
+  if (!defaultContainer) {
+    defaultContainer = new Container();
+  }
+  return defaultContainer;
+}
+function initializeContainer(config) {
+  getContainer().initialize(config);
+}
+function isContainerInitialized() {
+  return defaultContainer?.isInitialized() ?? false;
+}
+function getModels() {
+  return getContainer().getModels();
+}
+function getConfig() {
+  return getContainer().getConfig();
+}
+function isSingleTenant() {
+  return getContainer().isSingleTenant();
+}
+
+// src/core/config.ts
+var DEFAULT_TAX_BRACKETS = [
+  { min: 0, max: 1e4, rate: 0.1 },
+  { min: 1e4, max: 4e4, rate: 0.12 },
+  { min: 4e4, max: 85e3, rate: 0.22 },
+  { min: 85e3, max: 165e3, rate: 0.24 },
+  { min: 165e3, max: 215e3, rate: 0.32 },
+  { min: 215e3, max: 54e4, rate: 0.35 },
+  { min: 54e4, max: Infinity, rate: 0.37 }
+];
+var DEFAULT_WORK_SCHEDULE = {
+  workingDays: [1, 2, 3, 4, 5],
+  // Monday to Friday
+  hoursPerDay: 8
+};
+function countWorkingDays(startDate, endDate, options = {}) {
+  const workDays = options.workingDays || DEFAULT_WORK_SCHEDULE.workingDays;
+  const holidaySet = new Set(
+    (options.holidays || []).map((d) => new Date(d).toDateString())
+  );
+  let totalDays = 0;
+  let workingDays = 0;
+  let holidays = 0;
+  let weekends = 0;
+  const current = new Date(startDate);
+  current.setHours(0, 0, 0, 0);
+  const end = new Date(endDate);
+  end.setHours(0, 0, 0, 0);
+  while (current <= end) {
+    totalDays++;
+    const isHoliday = holidaySet.has(current.toDateString());
+    const isWorkDay = workDays.includes(current.getDay());
+    if (isHoliday) {
+      holidays++;
+    } else if (isWorkDay) {
+      workingDays++;
+    } else {
+      weekends++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  return { totalDays, workingDays, weekends, holidays };
+}
+function calculateProration(hireDate, terminationDate, periodStart, periodEnd) {
+  const hire = new Date(hireDate);
+  hire.setHours(0, 0, 0, 0);
+  const term = terminationDate ? new Date(terminationDate) : null;
+  if (term) term.setHours(0, 0, 0, 0);
+  const start = new Date(periodStart);
+  start.setHours(0, 0, 0, 0);
+  const end = new Date(periodEnd);
+  end.setHours(0, 0, 0, 0);
+  if (hire > end || term && term < start) {
+    return { ratio: 0, reason: "full", isProrated: true };
+  }
+  const effectiveStart = hire > start ? hire : start;
+  const effectiveEnd = term && term < end ? term : end;
+  const totalDays = Math.ceil((end.getTime() - start.getTime()) / 864e5) + 1;
+  const actualDays = Math.ceil((effectiveEnd.getTime() - effectiveStart.getTime()) / 864e5) + 1;
+  const ratio = Math.min(1, Math.max(0, actualDays / totalDays));
+  const isNewHire = hire > start;
+  const isTermination = term !== null && term < end;
+  let reason = "full";
+  if (isNewHire && isTermination) {
+    reason = "both";
+  } else if (isNewHire) {
+    reason = "new_hire";
+  } else if (isTermination) {
+    reason = "termination";
+  }
+  return { ratio, reason, isProrated: ratio < 1 };
+}
+function calculateSimpleTax(monthlyIncome, brackets = DEFAULT_TAX_BRACKETS) {
+  const annualIncome = monthlyIncome * 12;
+  let annualTax = 0;
+  for (const bracket of brackets) {
+    if (annualIncome <= bracket.min) continue;
+    const taxableInBracket = Math.min(annualIncome, bracket.max) - bracket.min;
+    annualTax += taxableInBracket * bracket.rate;
+  }
+  const monthlyTax = Math.round(annualTax / 12);
+  const effectiveRate = monthlyIncome > 0 ? monthlyTax / monthlyIncome : 0;
+  return { amount: monthlyTax, effectiveRate };
+}
+function calculateAttendanceDeduction(expectedDays, actualDays, dailyRate, maxDeductionPercent = 100) {
+  const absentDays = Math.max(0, expectedDays - actualDays);
+  const deduction = Math.round(absentDays * dailyRate);
+  const maxDeduction = Math.round(dailyRate * expectedDays * maxDeductionPercent / 100);
+  return Math.min(deduction, maxDeduction);
+}
+function calculateSalaryBreakdown(params) {
+  const {
+    baseSalary,
+    hireDate,
+    terminationDate,
+    periodStart,
+    periodEnd,
+    allowances = [],
+    deductions = [],
+    options = {},
+    attendance
+  } = params;
+  const workSchedule = { ...DEFAULT_WORK_SCHEDULE, ...options.workSchedule };
+  const workingDays = countWorkingDays(periodStart, periodEnd, {
+    workingDays: workSchedule.workingDays,
+    holidays: options.holidays
+  });
+  const proration = options.skipProration ? { ratio: 1, reason: "full", isProrated: false } : calculateProration(hireDate, terminationDate, periodStart, periodEnd);
+  const proratedBase = Math.round(baseSalary * proration.ratio);
+  const processedAllowances = allowances.map((a) => ({
+    type: a.type,
+    amount: Math.round(a.amount * proration.ratio),
+    taxable: a.taxable ?? true
+  }));
+  const totalAllowances = processedAllowances.reduce((sum, a) => sum + a.amount, 0);
+  const processedDeductions = deductions.map((d) => ({
+    type: d.type,
+    amount: Math.round(d.amount * proration.ratio)
+  }));
+  let attendanceDeduction = 0;
+  if (attendance && !options.skipAttendance && workingDays.workingDays > 0) {
+    const dailyRate = proratedBase / workingDays.workingDays;
+    attendanceDeduction = calculateAttendanceDeduction(
+      attendance.expectedDays,
+      attendance.actualDays,
+      dailyRate
+    );
+    if (attendanceDeduction > 0) {
+      processedDeductions.push({ type: "attendance", amount: attendanceDeduction });
+    }
+  }
+  const grossSalary = proratedBase + totalAllowances;
+  let taxAmount = 0;
+  if (!options.skipTax) {
+    const taxableAllowances = processedAllowances.filter((a) => a.taxable).reduce((sum, a) => sum + a.amount, 0);
+    const taxableIncome = proratedBase + taxableAllowances;
+    const taxResult = calculateSimpleTax(taxableIncome);
+    taxAmount = taxResult.amount;
+    if (taxAmount > 0) {
+      processedDeductions.push({ type: "tax", amount: taxAmount });
+    }
+  }
+  const totalDeductions = processedDeductions.filter((d) => d.type !== "tax").reduce((sum, d) => sum + d.amount, 0);
+  const netSalary = grossSalary - totalDeductions - taxAmount;
+  return {
+    baseSalary,
+    proratedBase,
+    totalAllowances,
+    totalDeductions,
+    attendanceDeduction,
+    grossSalary,
+    taxAmount,
+    netSalary,
+    proration,
+    workingDays,
+    breakdown: {
+      allowances: processedAllowances,
+      deductions: processedDeductions
+    }
+  };
+}
+function getPayPeriod(month, year, payDay = 28) {
+  const startDate = new Date(year, month - 1, 1);
+  const endDate = new Date(year, month, 0);
+  const payDate = new Date(year, month - 1, Math.min(payDay, endDate.getDate()));
+  return { startDate, endDate, payDate };
+}
+
+export { Container, DEFAULT_TAX_BRACKETS, DEFAULT_WORK_SCHEDULE, EventBus, IdempotencyManager, PluginManager, Result, ResultClass, WebhookManager, all, calculateAttendanceDeduction, calculateProration, calculateSalaryBreakdown, countWorkingDays, createEventBus, createNotificationPlugin, definePlugin, err, flatMap, fromNullable, fromPromise, generatePayrollIdempotencyKey, getConfig, getContainer, getEventBus, getModels, getPayPeriod, initializeContainer, isContainerInitialized, isErr, isOk, isSingleTenant, loggingPlugin, map, mapErr, match, metricsPlugin, notificationPlugin, ok, onEmployeeHired, onMilestoneAchieved, onPayrollCompleted, onSalaryProcessed, resetEventBus, tryCatch, tryCatchSync, unwrap, unwrapOr, unwrapOrElse };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map