@classytic/payroll 1.0.1 → 2.0.0

package/dist/core/index.js

@@ -0,0 +1,971 @@
+// 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);
+}
+
+// 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,
+    requireEmployeeId: true,
+    uniqueEmployeeIdPerOrg: true,
+    allowMultiTenantEmployees: true
+  }
+};
+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 }
+  };
+}
+
+// src/core/container.ts
+var Container = class _Container {
+  static instance = null;
+  _models = null;
+  _config = HRM_CONFIG;
+  _singleTenant = null;
+  _logger;
+  _initialized = false;
+  constructor() {
+    this._logger = getLogger();
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!_Container.instance) {
+      _Container.instance = new _Container();
+    }
+    return _Container.instance;
+  }
+  /**
+   * Reset instance (for testing)
+   */
+  static resetInstance() {
+    _Container.instance = null;
+  }
+  /**
+   * 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,
+      isSingleTenant: !!this._singleTenant
+    });
+  }
+  /**
+   * Check if container is initialized
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Ensure container is initialized
+   */
+  ensureInitialized() {
+    if (!this._initialized || !this._models) {
+      throw new Error(
+        "Payroll not initialized. Call Payroll.initialize() first."
+      );
+    }
+  }
+  /**
+   * Get models container
+   */
+  getModels() {
+    this.ensureInitialized();
+    return this._models;
+  }
+  /**
+   * Get Employee model
+   */
+  getEmployeeModel() {
+    this.ensureInitialized();
+    return this._models.EmployeeModel;
+  }
+  /**
+   * Get PayrollRecord model
+   */
+  getPayrollRecordModel() {
+    this.ensureInitialized();
+    return this._models.PayrollRecordModel;
+  }
+  /**
+   * Get Transaction model
+   */
+  getTransactionModel() {
+    this.ensureInitialized();
+    return this._models.TransactionModel;
+  }
+  /**
+   * Get Attendance model (optional)
+   */
+  getAttendanceModel() {
+    this.ensureInitialized();
+    return this._models.AttendanceModel ?? 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 };
+  }
+};
+function getContainer() {
+  return Container.getInstance();
+}
+function initializeContainer(config) {
+  Container.getInstance().initialize(config);
+}
+function isContainerInitialized() {
+  return Container.getInstance().isInitialized();
+}
+function getModels() {
+  return Container.getInstance().getModels();
+}
+function getConfig() {
+  return Container.getInstance().getConfig();
+}
+function isSingleTenant() {
+  return Container.getInstance().isSingleTenant();
+}
+
+// src/core/config.ts
+var COUNTRY_DEFAULTS = {
+  US: {
+    currency: "USD",
+    workDays: [1, 2, 3, 4, 5],
+    // Mon-Fri
+    taxBrackets: [
+      { min: 0, max: 11e3, rate: 0.1 },
+      { min: 11e3, max: 44725, rate: 0.12 },
+      { min: 44725, max: 95375, rate: 0.22 },
+      { min: 95375, max: 182100, rate: 0.24 },
+      { min: 182100, max: Infinity, rate: 0.32 }
+    ]
+  },
+  BD: {
+    currency: "BDT",
+    workDays: [0, 1, 2, 3, 4],
+    // Sun-Thu
+    taxBrackets: [
+      { min: 0, max: 35e4, rate: 0 },
+      { min: 35e4, max: 45e4, rate: 0.05 },
+      { min: 45e4, max: 75e4, rate: 0.1 },
+      { min: 75e4, max: 115e4, rate: 0.15 },
+      { min: 115e4, max: Infinity, rate: 0.2 }
+    ]
+  },
+  UK: {
+    currency: "GBP",
+    workDays: [1, 2, 3, 4, 5],
+    taxBrackets: [
+      { min: 0, max: 12570, rate: 0 },
+      { min: 12570, max: 50270, rate: 0.2 },
+      { min: 50270, max: 125140, rate: 0.4 },
+      { min: 125140, max: Infinity, rate: 0.45 }
+    ]
+  },
+  IN: {
+    currency: "INR",
+    workDays: [1, 2, 3, 4, 5, 6],
+    // Mon-Sat
+    taxBrackets: [
+      { min: 0, max: 3e5, rate: 0 },
+      { min: 3e5, max: 6e5, rate: 0.05 },
+      { min: 6e5, max: 9e5, rate: 0.1 },
+      { min: 9e5, max: 12e5, rate: 0.15 },
+      { min: 12e5, max: Infinity, rate: 0.2 }
+    ]
+  }
+};
+var DEFAULT_WORK_SCHEDULE = {
+  workDays: [1, 2, 3, 4, 5],
+  // Monday to Friday
+  hoursPerDay: 8
+};
+var DEFAULT_TAX_BRACKETS = COUNTRY_DEFAULTS.US.taxBrackets;
+function countWorkingDays(startDate, endDate, options = {}) {
+  const workDays = options.workDays || DEFAULT_WORK_SCHEDULE.workDays;
+  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 calculateTax(monthlyIncome, currency, customBrackets) {
+  const brackets = customBrackets || COUNTRY_DEFAULTS[currency]?.taxBrackets || 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,
+    currency,
+    hireDate,
+    terminationDate,
+    periodStart,
+    periodEnd,
+    allowances = [],
+    deductions = [],
+    options = {},
+    attendance
+  } = params;
+  const workSchedule = { ...DEFAULT_WORK_SCHEDULE, ...options.workSchedule };
+  const workingDays = countWorkingDays(periodStart, periodEnd, {
+    workDays: workSchedule.workDays,
+    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 = calculateTax(taxableIncome, currency);
+    taxAmount = taxResult.amount;
+    if (taxAmount > 0) {
+      processedDeductions.push({ type: "tax", amount: taxAmount });
+    }
+  }
+  const totalDeductions = processedDeductions.filter((d) => d.type !== "tax" && d.type !== "attendance").reduce((sum, d) => sum + d.amount, 0);
+  const netSalary = grossSalary - totalDeductions - attendanceDeduction - 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 { COUNTRY_DEFAULTS, Container, DEFAULT_TAX_BRACKETS, DEFAULT_WORK_SCHEDULE, EventBus, PluginManager, Result, ResultClass, all, calculateAttendanceDeduction, calculateProration, calculateSalaryBreakdown, calculateTax, countWorkingDays, createEventBus, createNotificationPlugin, definePlugin, err, flatMap, fromNullable, fromPromise, 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