محرك فترة التجربة بـ TypeScript — المادة 53 من نظام العمل

/** ISO calendar date, 'YYYY-MM-DD'. Dates here are days, never instants. */
type IsoDate = string;
 
/**
 * One agreed stretch of probation. Article 53 permits the period to be extended,
 * so a clause is a list of tranches, not a single number.
 */
type ProbationTranche = {
  days: number;
  /** Article 53 requires extensions to rest on a written agreement. */
  agreedInWriting: boolean;
};
 
type ProbationClause = {
  /** Article 53: stated expressly in the contract, or the contract is final. */
  statedInContract: boolean;
  /** Duration must be clearly defined — an open-ended clause is not a clause. */
  durationClearlyDefined: boolean;
  tranches: ProbationTranche[];
};

/** Article 53 — a single agreed stretch, before any written extension. */
const SINGLE_TRANCHE_CAP_DAYS = 90;
 
/** Article 53 — the absolute total, in all circumstances. This one never bends. */
const ABSOLUTE_CAP_DAYS = 180;

type ClauseAssessment = {
  valid: boolean;
  effectiveDays: number;
  reasons: string[];
};
 
function assessClause(clause: ProbationClause): ClauseAssessment {
  const reasons: string[] = [];
 
  if (!clause.statedInContract) {
    return {
      valid: false,
      effectiveDays: 0,
      reasons: ['probation not stated expressly in the contract (Art. 53) — contract is final'],
    };
  }
 
  if (!clause.durationClearlyDefined) {
    return {
      valid: false,
      effectiveDays: 0,
      reasons: ['probation duration not clearly defined (Art. 53) — contract is final'],
    };
  }
 
  if (clause.tranches.length === 0) {
    return {
      valid: false,
      effectiveDays: 0,
      reasons: ['probation clause carries no duration'],
    };
  }
 
  // The first tranche stands on the contract. Every later one needs writing.
  let counted = 0;
  clause.tranches.forEach((tranche, index) => {
    if (index > 0 && !tranche.agreedInWriting) {
      reasons.push(`extension ${index} not agreed in writing (Art. 53) — not counted`);
      return;
    }
    if (index === 0 && tranche.days > SINGLE_TRANCHE_CAP_DAYS) {
      reasons.push(
        `initial probation of ${tranche.days} days exceeds the ${SINGLE_TRANCHE_CAP_DAYS}-day base ` +
          'and is only sustainable as a written extension',
      );
    }
    counted += tranche.days;
  });
 
  const effectiveDays = Math.min(counted, ABSOLUTE_CAP_DAYS);
  if (counted > ABSOLUTE_CAP_DAYS) {
    reasons.push(
      `total probation of ${counted} days truncated to the Art. 53 ceiling of ${ABSOLUTE_CAP_DAYS}`,
    );
  }
 
  return { valid: effectiveDays > 0, effectiveDays, reasons };
}

type PriorEngagement = {
  profession: string;
  endedOn: IsoDate;
  hadProbation: boolean;
};
 
const SIX_MONTHS_IN_DAYS = 180;
 
function daysBetween(from: IsoDate, to: IsoDate): number {
  const MS_PER_DAY = 86_400_000;
  return Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / MS_PER_DAY);
}
 
/**
 * Article 54 — may this worker lawfully be placed under probation again?
 * Only the prior engagements that actually carried probation are relevant.
 */
function repeatProbationAllowed(
  newProfession: string,
  startDate: IsoDate,
  history: PriorEngagement[],
): { allowed: boolean; reason: string } {
  const priorProbations = history.filter((h) => h.hadProbation);
  if (priorProbations.length === 0) {
    return { allowed: true, reason: 'no prior probation with this employer' };
  }
 
  if (priorProbations.every((h) => h.profession !== newProfession)) {
    return { allowed: true, reason: 'different profession from every prior engagement (Art. 54)' };
  }
 
  const mostRecentEnd = priorProbations
    .map((h) => h.endedOn)
    .sort()
    .at(-1) as IsoDate;
 
  const gap = daysBetween(mostRecentEnd, startDate);
  if (gap >= SIX_MONTHS_IN_DAYS) {
    return { allowed: true, reason: `${gap} days since the previous engagement ended (Art. 54)` };
  }
 
  return {
    allowed: false,
    reason:
      `same profession and only ${gap} days since the previous engagement — ` +
      'a second probation is not permitted (Art. 54)',
  };
}

type PauseKind = 'eid-al-fitr' | 'eid-al-adha' | 'sick-leave';
 
/** A stretch of days that does not count toward probation. Both ends inclusive. */
type PausePeriod = {
  kind: PauseKind;
  from: IsoDate;
  to: IsoDate;
};
 
function eachDay(from: IsoDate, to: IsoDate): IsoDate[] {
  const out: IsoDate[] = [];
  const cursor = new Date(`${from}T00:00:00Z`);
  const end = new Date(`${to}T00:00:00Z`);
  while (cursor <= end) {
    out.push(cursor.toISOString().slice(0, 10));
    cursor.setUTCDate(cursor.getUTCDate() + 1);
  }
  return out;
}
 
/**
 * Walk forward from the start date, counting only days the statute counts,
 * until `effectiveDays` of probation have actually elapsed.
 *
 * Deliberately a day walk rather than date arithmetic: pauses overlap
 * (sick leave across Eid is one excluded day, not two) and the only honest
 * way to handle overlap is a set of excluded days.
 */
function probationEndDate(
  startDate: IsoDate,
  effectiveDays: number,
  pauses: PausePeriod[],
): IsoDate {
  const excluded = new Set<IsoDate>();
  for (const pause of pauses) {
    for (const day of eachDay(pause.from, pause.to)) excluded.add(day);
  }
 
  let counted = 0;
  const cursor = new Date(`${startDate}T00:00:00Z`);
  // Hard stop well past any lawful probation, so a pathological pause set
  // cannot spin forever.
  const MAX_ELAPSED_DAYS = ABSOLUTE_CAP_DAYS * 4;
 
  for (let elapsed = 0; elapsed < MAX_ELAPSED_DAYS; elapsed++) {
    const day = cursor.toISOString().slice(0, 10);
    if (!excluded.has(day)) counted += 1;
    if (counted === effectiveDays) return day;
    cursor.setUTCDate(cursor.getUTCDate() + 1);
  }
 
  throw new Error('probation end date not reached — check the pause periods for an open range');
}

type Contract = {
  workerId: string;
  profession: string;
  startDate: IsoDate;
  clause: ProbationClause;
};
 
type ExitBranch =
  | {
      branch: 'probation';
      /** Article 53 — the termination carries none of these. */
      noticeDays: 0;
      compensationOwed: false;
      endOfServiceAward: false;
      probationEndsOn: IsoDate;
      reasons: string[];
    }
  | {
      branch: 'article-77';
      /** Priced by the termination settlement engine, with its two-month floor. */
      probationEndsOn: IsoDate | null;
      reasons: string[];
    };
 
function classifyExit(
  contract: Contract,
  terminationDate: IsoDate,
  pauses: PausePeriod[],
  history: PriorEngagement[],
): ExitBranch {
  const reasons: string[] = [];
 
  const repeat = repeatProbationAllowed(contract.profession, contract.startDate, history);
  reasons.push(repeat.reason);
  if (!repeat.allowed) {
    return { branch: 'article-77', probationEndsOn: null, reasons };
  }
 
  const assessment = assessClause(contract.clause);
  reasons.push(...assessment.reasons);
  if (!assessment.valid) {
    return { branch: 'article-77', probationEndsOn: null, reasons };
  }
 
  const relevant = pauses.filter((p) => p.from >= contract.startDate);
  const endsOn = probationEndDate(contract.startDate, assessment.effectiveDays, relevant);
  reasons.push(
    `probation of ${assessment.effectiveDays} counted days runs to ${endsOn} ` +
      `(${pauses.length} excluded period(s) applied)`,
  );
 
  if (terminationDate <= endsOn) {
    return {
      branch: 'probation',
      noticeDays: 0,
      compensationOwed: false,
      endOfServiceAward: false,
      probationEndsOn: endsOn,
      reasons,
    };
  }
 
  reasons.push(`termination on ${terminationDate} falls after probation ended on ${endsOn}`);
  return { branch: 'article-77', probationEndsOn: endsOn, reasons };
}

import test from 'node:test';
import assert from 'node:assert/strict';
 
const baseClause: ProbationClause = {
  statedInContract: true,
  durationClearlyDefined: true,
  tranches: [{ days: 90, agreedInWriting: false }],
};
 
const contract: Contract = {
  workerId: 'W-1',
  profession: 'accountant',
  startDate: '2026-01-01',
  clause: baseClause,
};
 
test('an unwritten probation clause routes the exit to Article 77', () => {
  const c = { ...contract, clause: { ...baseClause, statedInContract: false } };
  const exit = classifyExit(c, '2026-02-01', [], []);
  assert.equal(exit.branch, 'article-77');
});
 
test('the last probation day is still inside probation', () => {
  // 90 counted days from 2026-01-01 inclusive lands on 2026-03-31.
  const inside = classifyExit(contract, '2026-03-31', [], []);
  assert.equal(inside.branch, 'probation');
  const outside = classifyExit(contract, '2026-04-01', [], []);
  assert.equal(outside.branch, 'article-77');
});
 
test('sick leave pauses the clock and pushes the end date out', () => {
  const pauses: PausePeriod[] = [
    { kind: 'sick-leave', from: '2026-02-10', to: '2026-02-19' }, // 10 days
  ];
  const exit = classifyExit(contract, '2026-04-01', pauses, []);
  assert.equal(exit.branch, 'probation');
  assert.equal(exit.probationEndsOn, '2026-04-10');
});
 
test('overlapping pauses are counted once', () => {
  const pauses: PausePeriod[] = [
    { kind: 'eid-al-fitr', from: '2026-03-19', to: '2026-03-22' },
    { kind: 'sick-leave', from: '2026-03-20', to: '2026-03-23' },
  ];
  // Union is 2026-03-19..2026-03-23 — five days, not eight.
  const exit = classifyExit(contract, '2026-04-05', pauses, []);
  assert.equal(exit.probationEndsOn, '2026-04-05');
});
 
test('the 180-day ceiling truncates rather than voiding the clause', () => {
  const c: Contract = {
    ...contract,
    clause: {
      statedInContract: true,
      durationClearlyDefined: true,
      tranches: [
        { days: 90, agreedInWriting: false },
        { days: 150, agreedInWriting: true },
      ],
    },
  };
  const exit = classifyExit(c, '2026-06-29', [], []);
  assert.equal(exit.branch, 'probation'); // day 180
  assert.equal(classifyExit(c, '2026-06-30', [], []).branch, 'article-77');
});
 
test('a rehire into the same profession inside six months cannot be re-probated', () => {
  const history: PriorEngagement[] = [
    { profession: 'accountant', endedOn: '2025-10-01', hadProbation: true },
  ];
  assert.equal(classifyExit(contract, '2026-02-01', [], history).branch, 'article-77');
});
 
test('a rehire into a different profession may be re-probated', () => {
  const history: PriorEngagement[] = [
    { profession: 'driver', endedOn: '2025-12-01', hadProbation: true },
  ];
  assert.equal(classifyExit(contract, '2026-02-01', [], history).branch, 'probation');
});