محرّك تسوية إنهاء الخدمة بـ TypeScript (المادة 77)

settleTermination(input: TerminationInput): Settlement

/** Article 74 lists the lawful causes of termination that carry no fault. */
type Article74Cause =
  | 'mutual-written-agreement'
  | 'fixed-term-expiry'
  | 'retirement-age'
  | 'force-majeure'
  | 'establishment-closure'
  | 'activity-cessation';
 
type Exit =
  /** Employer ends an indefinite contract for a valid reason, with notice (Art. 75). */
  | { by: 'employer'; ground: 'article-75-valid-reason'; reasonInWriting: boolean }
  /** Employer ends without a lawful cause — the Article 77 exposure. */
  | { by: 'employer'; ground: 'no-lawful-cause' }
  /** Employer dismisses for one of the nine Article 80 cases. */
  | { by: 'employer'; ground: 'article-80'; case: Article80Case; evidence: Article80Evidence }
  /** A neutral Article 74 ending: expiry, retirement, closure, force majeure. */
  | { by: 'neither'; ground: 'article-74'; cause: Article74Cause }
  /** The worker resigns in the ordinary way. */
  | { by: 'worker'; ground: 'resignation' }
  /** The worker leaves under Article 81 — priced as an employer termination. */
  | { by: 'worker'; ground: 'article-81'; case: Article81Case; noticeGiven: boolean };

/** All money is integer halalas. 1 SAR = 100 halalas. Floats do not belong here. */
type Halalas = number;
 
type Wage = {
  /** الأجر الأساسي — the contractual basic. */
  basic: Halalas;
  /** Housing, transport and any other allowance due for the work itself. */
  allowances: Halalas;
};
 
/** الأجر — Article 2. This is the base for Articles 76, 77 and 84. */
const actualMonthlyWage = (w: Wage): Halalas => w.basic + w.allowances;
 
/**
 * Labour entitlements are priced per calendar day on a 30-day month, not on the
 * actual length of the month. A 31-day month does not make the day rate cheaper.
 */
const dailyWage = (w: Wage): Halalas => divideRoundHalfUp(actualMonthlyWage(w), 30);
 
function divideRoundHalfUp(numerator: number, denominator: number): number {
  return Math.floor((numerator * 2 + denominator) / (denominator * 2));
}

type Contract =
  | { kind: 'indefinite' }
  | {
      kind: 'fixed';
      /** ISO date the term was due to end. */
      endsOn: string;
      /** How many times this fixed term has already been renewed. */
      renewals: number;
    };

const FIXED_TERM_RENEWAL_LIMIT = 3;
const FIXED_TERM_YEARS_LIMIT = 4;
 
/**
 * Article 55 — normalise before pricing. Applies to Saudi workers; a non-Saudi's
 * contract term is tied to the work permit under Article 37, so the conversion
 * does not run for them.
 */
function normaliseContract(
  contract: Contract,
  serviceYears: number,
  isSaudi: boolean,
): Contract {
  if (contract.kind !== 'fixed' || !isSaudi) return contract;
  const converted =
    contract.renewals >= FIXED_TERM_RENEWAL_LIMIT || serviceYears >= FIXED_TERM_YEARS_LIMIT;
  return converted ? { kind: 'indefinite' } : contract;
}

type PayFrequency = 'monthly' | 'other';
 
const noticeDaysRequired = (f: PayFrequency): number => (f === 'monthly' ? 60 : 30);
 
/**
 * Article 76 — the shortfall between the notice the law requires and the notice
 * actually served. Never negative: serving longer than required earns nothing back.
 */
function noticeInLieu(
  wage: Wage,
  frequency: PayFrequency,
  daysServed: number,
  contract: Contract,
): Halalas {
  // Notice is an indefinite-contract obligation. A fixed term ending on its own
  // date needs no notice — the end date was the notice.
  if (contract.kind === 'fixed') return 0;
  const shortfall = Math.max(0, noticeDaysRequired(frequency) - daysServed);
  return shortfall * dailyWage(wage);
}

const MIN_COMPENSATION_MONTHS = 2;
const INDEFINITE_DAYS_PER_YEAR = 15;
 
type Article77Input = {
  wage: Wage;
  contract: Contract;
  serviceYears: number;
  /** ISO date the relationship actually ended. */
  terminatedOn: string;
  /** A figure written into the contract under the Article 77 opening clause. */
  contractualCompensation?: Halalas;
};
 
function article77Compensation(input: Article77Input): {
  amount: Halalas;
  basis: 'contractual' | 'per-year' | 'remaining-term';
  flooredUp: boolean;
} {
  const { wage, contract, serviceYears, terminatedOn, contractualCompensation } = input;
  const monthly = actualMonthlyWage(wage);
  const floor = MIN_COMPENSATION_MONTHS * monthly;
 
  let amount: Halalas;
  let basis: 'contractual' | 'per-year' | 'remaining-term';
 
  if (contractualCompensation !== undefined) {
    amount = contractualCompensation;
    basis = 'contractual';
  } else if (contract.kind === 'indefinite') {
    amount = Math.round(serviceYears * INDEFINITE_DAYS_PER_YEAR * dailyWage(wage));
    basis = 'per-year';
  } else {
    amount = remainingTermWage(wage, terminatedOn, contract.endsOn);
    basis = 'remaining-term';
  }
 
  // Article 8 — a contract may improve on the statute, never reduce it.
  return amount < floor
    ? { amount: floor, basis, flooredUp: true }
    : { amount, basis, flooredUp: false };
}
 
/** Wage for the unexpired part of a fixed term: whole months, then residual days. */
function remainingTermWage(wage: Wage, from: string, to: string): Halalas {
  const start = new Date(`${from}T00:00:00Z`);
  const end = new Date(`${to}T00:00:00Z`);
  if (end <= start) return 0;
 
  let months =
    (end.getUTCFullYear() - start.getUTCFullYear()) * 12 +
    (end.getUTCMonth() - start.getUTCMonth());
  const anniversary = new Date(start);
  anniversary.setUTCMonth(anniversary.getUTCMonth() + months);
  if (anniversary > end) {
    months -= 1;
    anniversary.setUTCMonth(anniversary.getUTCMonth() - 1);
  }
  const residualDays = Math.round((end.getTime() - anniversary.getTime()) / 86_400_000);
 
  return months * actualMonthlyWage(wage) + residualDays * dailyWage(wage);
}

type Article80Case = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 
type Article80Evidence = {
  /** Required for all nine cases: the worker was allowed to state their case. */
  investigationHeld: boolean;
  /** Case 2: the prior written warning. */
  writtenWarningIssued?: boolean;
  /** Case 4: hours between the employer becoming aware and notifying the authorities. */
  hoursToAuthorityNotice?: number;
  /** Case 7. */
  absence?: { daysInYear: number; consecutiveDays: number; warningIssued: boolean };
};
 
const AUTHORITY_NOTICE_HOURS = 24;
const ABSENCE_DAYS_IN_YEAR = 30;
const ABSENCE_CONSECUTIVE_DAYS = 15;
 
/** Returns null when the dismissal stands, or the reason it collapses. */
function article80Failure(c: Article80Case, e: Article80Evidence): string | null {
  if (!e.investigationHeld) return 'no opportunity to state the case (Art. 80, final paragraph)';
 
  switch (c) {
    case 2:
      return e.writtenWarningIssued ? null : 'no prior written warning (Art. 80/2)';
    case 4:
      return (e.hoursToAuthorityNotice ?? Infinity) <= AUTHORITY_NOTICE_HOURS
        ? null
        : 'authorities not notified within 24 hours (Art. 80/4)';
    case 7: {
      const a = e.absence;
      if (!a) return 'absence record missing (Art. 80/7)';
      const threshold =
        a.daysInYear > ABSENCE_DAYS_IN_YEAR || a.consecutiveDays > ABSENCE_CONSECUTIVE_DAYS;
      if (!threshold) return 'absence below the 30-day or 15-consecutive-day threshold (Art. 80/7)';
      return a.warningIssued ? null : 'no written warning before dismissal (Art. 80/7)';
    }
    default:
      return null;
  }
}

type Article81Case = 1 | 2 | 3 | 4 | 5 | 6 | 7;
 
type Classification = {
  /** Which end-of-service scale the award engine should be called with. */
  awardScale: 'full' | 'resignation-scale' | 'none';
  /** Whether Article 77 compensation is owed. */
  article77Owed: boolean;
  /** Whether notice was owed by the employer at all. */
  noticeOwedByEmployer: boolean;
  /** Human-readable trail: what the engine decided and under which article. */
  rationale: string[];
};
 
function classify(exit: Exit): Classification {
  switch (exit.ground) {
    case 'article-80': {
      const failure = article80Failure(exit.case, exit.evidence);
      if (failure) {
        return {
          awardScale: 'full',
          article77Owed: true,
          noticeOwedByEmployer: true,
          rationale: [`Article 80 dismissal collapses: ${failure}`, 'priced as unlawful termination'],
        };
      }
      return {
        awardScale: 'none',
        article77Owed: false,
        noticeOwedByEmployer: false,
        rationale: [`Article 80 case ${exit.case} established`],
      };
    }
    case 'no-lawful-cause':
      return {
        awardScale: 'full',
        article77Owed: true,
        noticeOwedByEmployer: true,
        rationale: ['termination without a lawful cause (Art. 77)'],
      };
    case 'article-81':
      return {
        awardScale: 'full',
        article77Owed: true,
        noticeOwedByEmployer: true,
        rationale: [`Article 81 case ${exit.case} — worker exit priced as employer termination`],
      };
    case 'article-75-valid-reason':
      return {
        awardScale: 'full',
        article77Owed: false,
        noticeOwedByEmployer: true,
        rationale: [
          exit.reasonInWriting
            ? 'lawful termination with written reason (Art. 75)'
            : 'reason not stated in writing — Article 75 defect, review before paying',
        ],
      };
    case 'article-74':
      return {
        awardScale: 'full',
        article77Owed: false,
        noticeOwedByEmployer: false,
        rationale: [`Article 74 — ${exit.cause}`],
      };
    case 'resignation':
      return {
        awardScale: 'resignation-scale',
        article77Owed: false,
        noticeOwedByEmployer: false,
        rationale: ['ordinary resignation — Article 85 scale applies'],
      };
  }
}

type SettlementLine = { head: string; article: string; amount: Halalas };
 
type TerminationInput = {
  exit: Exit;
  wage: Wage;
  contract: Contract;
  frequency: PayFrequency;
  isSaudi: boolean;
  hiredOn: string;
  terminatedOn: string;
  noticeDaysServed: number;
  contractualCompensation?: Halalas;
  /** Already-computed balances from the other engines. */
  unpaidWages: Halalas;
  unusedLeavePay: Halalas;
  unpaidOvertime: Halalas;
  /** Article 84/85 award, computed by the end-of-service engine for the scale we pass it. */
  award: (scale: 'full' | 'resignation-scale' | 'none') => Halalas;
};
 
type Settlement = {
  classification: Classification;
  lines: SettlementLine[];
  total: Halalas;
  /** Article 88 — the date the money is legally due. */
  dueBy: string;
};
 
const MS_PER_DAY = 86_400_000;
 
function settleTermination(input: TerminationInput): Settlement {
  const serviceYears =
    (new Date(`${input.terminatedOn}T00:00:00Z`).getTime() -
      new Date(`${input.hiredOn}T00:00:00Z`).getTime()) /
    (MS_PER_DAY * 365.25);
 
  const contract = normaliseContract(input.contract, serviceYears, input.isSaudi);
  const classification = classify(input.exit);
  const lines: SettlementLine[] = [];
 
  if (input.unpaidWages > 0) {
    lines.push({ head: 'Unpaid wages', article: 'Art. 90', amount: input.unpaidWages });
  }
  if (input.unpaidOvertime > 0) {
    lines.push({ head: 'Unpaid overtime', article: 'Art. 107', amount: input.unpaidOvertime });
  }
  if (input.unusedLeavePay > 0) {
    lines.push({ head: 'Unused annual leave', article: 'Art. 111', amount: input.unusedLeavePay });
  }
 
  const award = input.award(classification.awardScale);
  if (award > 0) {
    lines.push({ head: 'End-of-service award', article: 'Art. 84/85', amount: award });
  }
 
  if (classification.noticeOwedByEmployer) {
    const lieu = noticeInLieu(input.wage, input.frequency, input.noticeDaysServed, contract);
    if (lieu > 0) {
      lines.push({ head: 'Pay in lieu of notice', article: 'Art. 76', amount: lieu });
    }
  }
 
  if (classification.article77Owed) {
    const c = article77Compensation({
      wage: input.wage,
      contract,
      serviceYears,
      terminatedOn: input.terminatedOn,
      contractualCompensation: input.contractualCompensation,
    });
    lines.push({ head: 'Unlawful-termination compensation', article: 'Art. 77', amount: c.amount });
    classification.rationale.push(
      c.flooredUp
        ? `Article 77 basis "${c.basis}" raised to the two-month statutory floor`
        : `Article 77 basis "${c.basis}"`,
    );
  }
 
  return {
    classification,
    lines,
    total: lines.reduce((sum, l) => sum + l.amount, 0),
    dueBy: settlementDeadline(input.terminatedOn, input.exit.by),
  };
}
 
/**
 * Article 88 — one week where the employer ended the relationship, two weeks
 * where the worker did. The clock does not wait for the next payroll run.
 */
function settlementDeadline(terminatedOn: string, by: Exit['by']): string {
  const days = by === 'worker' ? 14 : 7;
  const due = new Date(`${terminatedOn}T00:00:00Z`);
  due.setUTCDate(due.getUTCDate() + days);
  return due.toISOString().slice(0, 10);
}

import test from 'node:test';
import assert from 'node:assert/strict';
 
const wage: Wage = { basic: 800_000, allowances: 200_000 }; // 8,000 + 2,000 SAR
 
test('Article 77 floor lifts a short-service indefinite case to two months', () => {
  const c = article77Compensation({
    wage,
    contract: { kind: 'indefinite' },
    serviceYears: 0.5, // 7.5 days computed
    terminatedOn: '2026-08-24',
  });
  assert.equal(c.amount, 2 * actualMonthlyWage(wage)); // 20,000 SAR
  assert.equal(c.flooredUp, true);
});
 
test('a contractual one-month clause is raised to the statutory floor', () => {
  const c = article77Compensation({
    wage,
    contract: { kind: 'indefinite' },
    serviceYears: 6,
    terminatedOn: '2026-08-24',
    contractualCompensation: actualMonthlyWage(wage), // one month, as written
  });
  assert.equal(c.amount, 2 * actualMonthlyWage(wage));
});
 
test('fixed term pays the remaining term, not fifteen days a year', () => {
  const c = article77Compensation({
    wage,
    contract: { kind: 'fixed', endsOn: '2027-02-24', renewals: 0 },
    serviceYears: 3,
    terminatedOn: '2026-08-24',
  });
  assert.equal(c.basis, 'remaining-term');
  assert.equal(c.amount, 6 * actualMonthlyWage(wage)); // six months left
});
 
test('absence of exactly 30 days does not establish Article 80 case 7', () => {
  const failure = article80Failure(7, {
    investigationHeld: true,
    absence: { daysInYear: 30, consecutiveDays: 4, warningIssued: true },
  });
  assert.match(failure ?? '', /threshold/);
});
 
test('a case 7 dismissal without the written warning collapses into Article 77', () => {
  const c = classify({
    by: 'employer',
    ground: 'article-80',
    case: 7,
    evidence: {
      investigationHeld: true,
      absence: { daysInYear: 41, consecutiveDays: 41, warningIssued: false },
    },
  });
  assert.equal(c.awardScale, 'full');
  assert.equal(c.article77Owed, true);
});
 
test('Article 81 keeps the full award even though the worker left', () => {
  const c = classify({ by: 'worker', ground: 'article-81', case: 4, noticeGiven: false });
  assert.equal(c.awardScale, 'full');
  assert.equal(c.article77Owed, true);
});
 
test('notice in lieu and Article 77 are cumulative, not alternatives', () => {
  const lieu = noticeInLieu(wage, 'monthly', 0, { kind: 'indefinite' });
  assert.equal(lieu, 60 * dailyWage(wage)); // two months on top of Article 77
});
 
test('Article 88 gives one week when the employer terminated', () => {
  assert.equal(settlementDeadline('2026-08-24', 'employer'), '2026-08-31');
  assert.equal(settlementDeadline('2026-08-24', 'worker'), '2026-09-07');
});