@nowline/export-msproj 0.8.5 → 0.9.0

package/src/calendar.ts

@@ -1,19 +1,29 @@
 // Minimal Standard base calendar emitted on every MS Project XML export.
 //
-// Spec: specs/handoffs/m2c.md § 8 + Resolution 6.
-//   - One base calendar (UID=1, Name=Standard) — Mon–Fri working
-//     08:00–12:00 / 13:00–17:00, Sat/Sun non-working. Matches Microsoft's
-//     default project template; reliably accepted across MSProject versions.
+// Spec: specs/handoffs/m2c.md § 8 + Resolution 6, specs/working-calendar.md §8.
+//   - One base calendar (UID=1, Name=Standard). Its working weekdays are the
+//     file calendar's open week (`WorkingCalendar.workingWeekdays`), each
+//     08:00–12:00 / 13:00–17:00: Mon–Fri for business, which matches
+//     Microsoft's default project template, and all seven days for
+//     `calendar:full` and `calendar:custom`.
 //   - One resource calendar (UID=2, Name=Standard, BaseCalendarUID=1).
 //
+//   - `<Exceptions>` in the base calendar (UID=1), right after `</WeekDays>`,
+//     one per `CalendarException`: a named closure, a bounded recurrence's
+//     closed days, or a working day the open week closes (m2p phase 5b).
+//     There is no `<WorkWeeks>`: a bounded recurrence becomes one exception
+//     per run of days it changes, and the exceptions never overlap.
+//
 // Calendar UIDs are fixed (1 / 2). No timestamps in the calendar block →
 // deterministic across runs.
 
+import type { CalendarException } from '@nowline/layout';
+import { escapeXml } from './xml.js';
+
 const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 
-function dayBlock(dayIndex: number): string {
-    const isWeekend = dayIndex === 0 || dayIndex === 6;
-    if (isWeekend) {
+function dayBlock(dayIndex: number, isWorking: boolean): string {
+    if (!isWorking) {
         return `      <WeekDay>
         <DayType>${dayIndex + 1}</DayType>
         <DayWorking>0</DayWorking>
@@ -35,8 +45,60 @@ function dayBlock(dayIndex: number): string {
       </WeekDay>`;
 }
 
-export function buildCalendarsBlock(): string {
-    const weekDays = [0, 1, 2, 3, 4, 5, 6].map(dayBlock).join('\n');
+function isoDate(date: Date): string {
+    return date.toISOString().slice(0, 10);
+}
+
+/** One `<Exception>`: element order follows the MSPDI schema. */
+function exceptionBlock(exception: CalendarException): string {
+    const lines = [
+        '      <Exception>',
+        '        <EnteredByOccurrences>0</EnteredByOccurrences>',
+        '        <TimePeriod>',
+        `          <FromDate>${isoDate(exception.from)}T00:00:00</FromDate>`,
+        `          <ToDate>${isoDate(exception.through)}T23:59:00</ToDate>`,
+        '        </TimePeriod>',
+        '        <Occurrences>1</Occurrences>',
+    ];
+    if (exception.titles && exception.titles.length > 0) {
+        lines.push(`        <Name>${escapeXml(exception.titles.join(', '))}</Name>`);
+    }
+    lines.push('        <Type>1</Type>');
+    lines.push(`        <DayWorking>${exception.working ? 1 : 0}</DayWorking>`);
+    if (exception.working) {
+        lines.push(
+            '        <WorkingTimes>',
+            '          <WorkingTime>',
+            '            <FromTime>08:00:00</FromTime>',
+            '            <ToTime>12:00:00</ToTime>',
+            '          </WorkingTime>',
+            '          <WorkingTime>',
+            '            <FromTime>13:00:00</FromTime>',
+            '            <ToTime>17:00:00</ToTime>',
+            '          </WorkingTime>',
+            '        </WorkingTimes>',
+        );
+    }
+    lines.push('      </Exception>');
+    return lines.join('\n');
+}
+
+function exceptionsBlock(exceptions: readonly CalendarException[]): string {
+    if (exceptions.length === 0) return '';
+    return `\n      <Exceptions>\n${exceptions.map(exceptionBlock).join('\n')}\n      </Exceptions>`;
+}
+
+/**
+ * `workingWeekdays`: 0 = Sunday … 6 = Saturday. `exceptions`: the days the
+ * file's calendar differs from that week (`calendarExceptions`), ascending.
+ */
+export function buildCalendarsBlock(
+    workingWeekdays: ReadonlySet<number>,
+    exceptions: readonly CalendarException[],
+): string {
+    const weekDays = [0, 1, 2, 3, 4, 5, 6]
+        .map((dayIndex) => dayBlock(dayIndex, workingWeekdays.has(dayIndex)))
+        .join('\n');
     return `  <Calendars>
     <Calendar>
       <UID>1</UID>
@@ -45,7 +107,7 @@ export function buildCalendarsBlock(): string {
       <BaseCalendarUID>-1</BaseCalendarUID>
       <WeekDays>
 ${weekDays}
-      </WeekDays>
+      </WeekDays>${exceptionsBlock(exceptions)}
     </Calendar>
     <Calendar>
       <UID>2</UID>

package/src/duration.ts

@@ -1,45 +1,18 @@
-// Convert Nowline duration tokens into MS Project's `PT...H...M...S` form.
+// Task durations in MS Project's `PT<minutes>M0S` form.
 //
-// MS Project uses ISO 8601 duration "PT<minutes>M0S" (e.g. `PT480M0S` = 8h)
-// for Standard-calendar working time. We resolve every duration to working
-// minutes under the calendar emitted by `calendar.ts` (Mon–Fri, 8h/day).
-//
-// Size buckets resolve the same way as in @nowline/export-mermaid.
-
-const SIZE_BUCKET_DAYS: Readonly<Record<string, number>> = {
-    xs: 1,
-    sm: 3,
-    s: 3,
-    md: 5,
-    m: 5,
-    lg: 10,
-    l: 10,
-    xl: 15,
-};
-
-const NUMERIC_RE = /^(\d+(?:\.\d+)?)\s*(d|w|m|y)?$/i;
+// The day count is engine C's `ScheduledItem.days` under the file's calendar
+// (specs/working-calendar.md §8), so sizes, `capacity:` and `q` match the
+// chart. Each working day is 8 hours of the Standard calendar `calendar.ts`
+// emits.
 
-const MINUTES_PER_WORKING_DAY = 8 * 60; // Standard calendar
-const WORKING_DAYS_PER_WEEK = 5;
-const WORKING_DAYS_PER_MONTH = 22;
-const WORKING_DAYS_PER_YEAR = 252;
+const MINUTES_PER_WORKING_DAY = 8 * 60;
 
-export function durationToMsProjMinutes(literal: string | undefined): number {
-    if (!literal) return MINUTES_PER_WORKING_DAY; // 1d default
-    const trimmed = literal.trim().toLowerCase();
-    if (!trimmed) return MINUTES_PER_WORKING_DAY;
-    if (trimmed in SIZE_BUCKET_DAYS) {
-        return SIZE_BUCKET_DAYS[trimmed] * MINUTES_PER_WORKING_DAY;
-    }
-    const match = NUMERIC_RE.exec(trimmed);
-    if (!match) return MINUTES_PER_WORKING_DAY;
-    const value = Number(match[1]);
-    const unit = (match[2] ?? 'd').toLowerCase();
-    if (!Number.isFinite(value) || value <= 0) return MINUTES_PER_WORKING_DAY;
-    let days = value;
-    if (unit === 'w') days = value * WORKING_DAYS_PER_WEEK;
-    else if (unit === 'm') days = value * WORKING_DAYS_PER_MONTH;
-    else if (unit === 'y') days = value * WORKING_DAYS_PER_YEAR;
+/**
+ * Working minutes for a task of `days` working days. An item with no
+ * duration gets one day: a zero-length task is a milestone in MS Project.
+ */
+export function workingDaysToMinutes(days: number | undefined): number {
+    if (days === undefined || !(days > 0)) return MINUTES_PER_WORKING_DAY;
     return Math.round(days * MINUTES_PER_WORKING_DAY);
 }