@openinc/parse-server-opendash 4.1.8 → 4.2.1

package/dist/features/openservice/serviceSchedules/calendarSync/functions/outlookRecurrence.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRRule = parseRRule;
+exports.buildRRule = buildRRule;
+exports.eventToCadence = eventToCadence;
+exports.calendarUnsupportedReason = calendarUnsupportedReason;
+exports.cadenceToRecurrence = cadenceToRecurrence;
+/**
+ * Outlook recurrence ↔ RRULE, both directions.
+ *
+ * **Why this module exists.** v1 stored a recurrence as `{number, unit}` — every
+ * Outlook pattern had to be flattened into "every n days/weeks/months", and
+ * anything else ("last Friday of the month") silently became something else. v2
+ * stores an RFC 5545 rule, which is the same language Outlook's patterns are a
+ * subset of, so the mapping can be lossless in both directions.
+ *
+ * Everything here is **pure** — no Parse, no Graph client — because a wrong
+ * mapping is the one bug in a calendar sync you cannot see until someone misses
+ * a maintenance date. `pnpm tsx scripts/…` round-trips it (see the module test
+ * at the bottom of the file's docs in OPENSERVICE_V2_SCHEDULES.md).
+ *
+ * **Where the two vocabularies differ**: Outlook's patterns are a subset of the
+ * RRULE grammar. A positional weekday (`BYDAY=+2TU`) maps to `relativeMonthly`
+ * and back, but `BYSETPOS` over several weekdays ("last workday"), several
+ * days of the month, or several months do not exist there at all —
+ * {@link calendarUnsupportedReason} names them, and the sync skips such plans
+ * instead of approximating a maintenance date.
+ */
+const WEEKDAY_TO_RRULE = {
+    Sunday: "SU",
+    Monday: "MO",
+    Tuesday: "TU",
+    Wednesday: "WE",
+    Thursday: "TH",
+    Friday: "FR",
+    Saturday: "SA",
+};
+const RRULE_TO_WEEKDAY = {
+    SU: "Sunday",
+    MO: "Monday",
+    TU: "Tuesday",
+    WE: "Wednesday",
+    TH: "Thursday",
+    FR: "Friday",
+    SA: "Saturday",
+};
+/** Outlook's `index` ↔ the RRULE ordinal prefix of a `BYDAY` entry. */
+const INDEX_TO_ORDINAL = {
+    first: 1,
+    second: 2,
+    third: 3,
+    fourth: 4,
+    last: -1,
+};
+const ORDINAL_TO_INDEX = {
+    1: "first",
+    2: "second",
+    3: "third",
+    4: "fourth",
+    [-1]: "last",
+};
+/**
+ * Read an RRULE string into its parts.
+ *
+ * Tolerant on purpose: an unknown key is dropped rather than throwing, because
+ * a rule that came from Outlook, from the editor, or from a hand-written import
+ * all end up here, and a single unexpected part must not stop a sync.
+ */
+function parseRRule(rrule) {
+    const parts = {};
+    if (!rrule)
+        return parts;
+    for (const chunk of rrule.replace(/^RRULE:/i, "").split(";")) {
+        const [rawKey, rawValue] = chunk.split("=");
+        if (!rawKey || !rawValue)
+            continue;
+        const key = rawKey.trim().toUpperCase();
+        const value = rawValue.trim().toUpperCase();
+        switch (key) {
+            case "FREQ":
+                if (value === "DAILY" ||
+                    value === "WEEKLY" ||
+                    value === "MONTHLY" ||
+                    value === "YEARLY") {
+                    parts.freq = value;
+                }
+                break;
+            case "INTERVAL":
+                parts.interval = toPositiveInt(value);
+                break;
+            case "COUNT":
+                parts.count = toPositiveInt(value);
+                break;
+            case "BYDAY":
+                parts.byday = value.split(",").filter(Boolean);
+                break;
+            case "BYMONTHDAY":
+                parts.bymonthday = value.split(",").map(Number).filter(Number.isFinite);
+                break;
+            case "BYMONTH":
+                parts.bymonth = value.split(",").map(Number).filter(Number.isFinite);
+                break;
+            case "WKST":
+                parts.wkst = value;
+                break;
+            case "BYSETPOS": {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed) && parsed !== 0)
+                    parts.bysetpos = parsed;
+                break;
+            }
+        }
+    }
+    return parts;
+}
+/** Write the parts back into an RRULE string, in the canonical part order. */
+function buildRRule(parts) {
+    const chunks = [`FREQ=${parts.freq ?? "DAILY"}`];
+    if (parts.interval && parts.interval > 1) {
+        chunks.push(`INTERVAL=${parts.interval}`);
+    }
+    if (parts.byday?.length)
+        chunks.push(`BYDAY=${parts.byday.join(",")}`);
+    if (parts.bymonthday?.length) {
+        chunks.push(`BYMONTHDAY=${parts.bymonthday.join(",")}`);
+    }
+    if (parts.bymonth?.length)
+        chunks.push(`BYMONTH=${parts.bymonth.join(",")}`);
+    if (parts.bysetpos)
+        chunks.push(`BYSETPOS=${parts.bysetpos}`);
+    if (parts.count)
+        chunks.push(`COUNT=${parts.count}`);
+    if (parts.wkst && parts.wkst !== "MO")
+        chunks.push(`WKST=${parts.wkst}`);
+    return chunks.join(";");
+}
+/**
+ * An Outlook event's timing, as a v2 cadence.
+ *
+ * A non-recurring event becomes a one-off — the same shape the frontend's
+ * `oneOffCadence()` produces (`FREQ=DAILY;INTERVAL=1;COUNT=1`), so a plan
+ * created from a single Outlook appointment is indistinguishable from one
+ * created by hand.
+ */
+function eventToCadence(start, recurrence) {
+    const dtstart = start.toISOString();
+    if (!recurrence?.pattern) {
+        return { kind: "rrule", rrule: "FREQ=DAILY;INTERVAL=1;COUNT=1", dtstart };
+    }
+    const { pattern, range } = recurrence;
+    const parts = { interval: pattern.interval };
+    switch (pattern.type) {
+        case "daily":
+            parts.freq = "DAILY";
+            break;
+        case "weekly":
+            parts.freq = "WEEKLY";
+            parts.byday = (pattern.daysOfWeek ?? [])
+                .map((day) => WEEKDAY_TO_RRULE[day])
+                .filter(Boolean);
+            if (pattern.firstDayOfWeek) {
+                parts.wkst = WEEKDAY_TO_RRULE[pattern.firstDayOfWeek];
+            }
+            break;
+        case "absoluteMonthly":
+            parts.freq = "MONTHLY";
+            parts.bymonthday = [pattern.dayOfMonth ?? start.getUTCDate()];
+            break;
+        case "relativeMonthly":
+            parts.freq = "MONTHLY";
+            parts.byday = positionalByDay(pattern);
+            break;
+        case "absoluteYearly":
+            parts.freq = "YEARLY";
+            parts.bymonth = [pattern.month ?? start.getUTCMonth() + 1];
+            parts.bymonthday = [pattern.dayOfMonth ?? start.getUTCDate()];
+            break;
+        case "relativeYearly":
+            parts.freq = "YEARLY";
+            parts.bymonth = [pattern.month ?? start.getUTCMonth() + 1];
+            parts.byday = positionalByDay(pattern);
+            break;
+    }
+    // A weekly series with no explicit days repeats on the start's weekday.
+    if (parts.freq === "WEEKLY" && !parts.byday?.length) {
+        parts.byday = [rruleWeekday(start)];
+    }
+    const cadence = {
+        kind: "rrule",
+        rrule: buildRRule(parts),
+        dtstart,
+    };
+    if (range?.type === "numbered") {
+        cadence.rrule = buildRRule({
+            ...parts,
+            count: range.numberOfOccurrences,
+        });
+    }
+    else if (range?.type === "endDate" && range.endDate) {
+        // Outlook's end date is a plain day and inclusive — the series may still
+        // occur on it, so the boundary is the end of that day.
+        cadence.until = endOfDay(range.endDate).toISOString();
+    }
+    return cadence;
+}
+/**
+ * Why this cadence cannot be written to a calendar — `undefined` when it can.
+ *
+ * Outlook's recurrence vocabulary is a **subset** of RFC 5545, and the gap is
+ * not cosmetic: a rule we cannot express would have to be approximated, and an
+ * approximated maintenance date in someone's calendar is worse than no entry
+ * at all. The sync therefore leaves such plans alone instead of guessing (see
+ * `syncPlanToCalendar`).
+ */
+function calendarUnsupportedReason(cadence) {
+    if (cadence?.kind !== "rrule" || !cadence.rrule)
+        return undefined;
+    const parts = parseRRule(cadence.rrule);
+    const days = parts.byday?.map(splitByDay) ?? [];
+    if (parts.bysetpos !== undefined && days.length > 1) {
+        return `BYSETPOS with ${days.length} weekdays has no Outlook equivalent`;
+    }
+    if (parts.byday && parts.byday.length > 1 && parts.freq !== "WEEKLY") {
+        return `several weekdays are only expressible for a weekly series (FREQ=${parts.freq})`;
+    }
+    if (parts.bymonthday && parts.bymonthday.length > 1) {
+        return "several days of the month have no Outlook equivalent";
+    }
+    if (parts.bymonth && parts.bymonth.length > 1) {
+        return "several months have no Outlook equivalent";
+    }
+    return undefined;
+}
+/**
+ * A v2 cadence as an Outlook recurrence — `undefined` for a one-off, which
+ * Graph expects as an event without a `recurrence` at all.
+ *
+ * `startDate` of the range is always the series start: Graph rejects a
+ * recurrence whose range starts on a different day than the event.
+ */
+function cadenceToRecurrence(cadence, start) {
+    if (cadence?.kind !== "rrule" || !cadence.rrule)
+        return undefined;
+    const parts = parseRRule(cadence.rrule);
+    // One occurrence is not a series — and Outlook has no way to say "once".
+    if (parts.count === 1)
+        return undefined;
+    const pattern = recurrencePattern(parts, start);
+    if (!pattern)
+        return undefined;
+    return { pattern, range: recurrenceRange(parts, cadence, start) };
+}
+function recurrencePattern(parts, start) {
+    const interval = parts.interval && parts.interval > 0 ? parts.interval : 1;
+    const days = parts.byday?.map(splitByDay) ?? [];
+    // A position comes either as an ordinal on the weekday (`+2TU`) or as
+    // BYSETPOS next to a single weekday — both are one Outlook `index`.
+    const positional = days.find((day) => !!day.ordinal) ??
+        (parts.bysetpos !== undefined && days.length === 1
+            ? { ordinal: parts.bysetpos, weekday: days[0].weekday }
+            : undefined);
+    switch (parts.freq ?? "DAILY") {
+        case "DAILY":
+            return { type: "daily", interval };
+        case "WEEKLY": {
+            const daysOfWeek = (parts.byday ?? [])
+                .map((entry) => RRULE_TO_WEEKDAY[splitByDay(entry).weekday])
+                .filter(Boolean);
+            return {
+                type: "weekly",
+                interval,
+                daysOfWeek: daysOfWeek.length
+                    ? daysOfWeek
+                    : [RRULE_TO_WEEKDAY[rruleWeekday(start)]],
+                firstDayOfWeek: RRULE_TO_WEEKDAY[parts.wkst ?? "MO"] ?? "Monday",
+            };
+        }
+        case "MONTHLY":
+            if (positional) {
+                return {
+                    type: "relativeMonthly",
+                    interval,
+                    daysOfWeek: [RRULE_TO_WEEKDAY[positional.weekday]],
+                    index: ORDINAL_TO_INDEX[positional.ordinal] ?? "first",
+                };
+            }
+            return {
+                type: "absoluteMonthly",
+                interval,
+                dayOfMonth: parts.bymonthday?.[0] ?? start.getUTCDate(),
+            };
+        case "YEARLY": {
+            const month = parts.bymonth?.[0] ?? start.getUTCMonth() + 1;
+            if (positional) {
+                return {
+                    type: "relativeYearly",
+                    interval,
+                    month,
+                    daysOfWeek: [RRULE_TO_WEEKDAY[positional.weekday]],
+                    index: ORDINAL_TO_INDEX[positional.ordinal] ?? "first",
+                };
+            }
+            return {
+                type: "absoluteYearly",
+                interval,
+                month,
+                dayOfMonth: parts.bymonthday?.[0] ?? start.getUTCDate(),
+            };
+        }
+    }
+    return undefined;
+}
+function recurrenceRange(parts, cadence, start) {
+    const startDate = graphDate(start);
+    if (parts.count && parts.count > 1) {
+        return { type: "numbered", startDate, numberOfOccurrences: parts.count };
+    }
+    if (cadence.until) {
+        return { type: "endDate", startDate, endDate: graphDate(cadence.until) };
+    }
+    return { type: "noEnd", startDate };
+}
+/** `["+2TU"]` for "second Tuesday" — the RRULE spelling of Outlook's `index`. */
+function positionalByDay(pattern) {
+    const weekday = WEEKDAY_TO_RRULE[pattern.daysOfWeek?.[0] ?? "Monday"];
+    const ordinal = INDEX_TO_ORDINAL[pattern.index ?? "first"] ?? 1;
+    return [`${ordinal > 0 ? "+" : ""}${ordinal}${weekday}`];
+}
+/** `"+2TU"` → `{ ordinal: 2, weekday: "TU" }`, `"TU"` → `{ weekday: "TU" }`. */
+function splitByDay(entry) {
+    const match = /^([+-]?\d+)?([A-Z]{2})$/.exec(entry.trim().toUpperCase());
+    if (!match)
+        return { weekday: "MO" };
+    return {
+        ordinal: match[1] ? Number(match[1]) : undefined,
+        weekday: match[2],
+    };
+}
+function rruleWeekday(date) {
+    return ["SU", "MO", "TU", "WE", "TH", "FR", "SA"][date.getUTCDay()];
+}
+/** Graph wants a plain `YYYY-MM-DD` in a recurrence range. */
+function graphDate(value) {
+    const date = value instanceof Date ? value : new Date(value);
+    return date.toISOString().slice(0, 10);
+}
+function endOfDay(day) {
+    return new Date(`${day.slice(0, 10)}T23:59:59.999Z`);
+}
+function toPositiveInt(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}

package/dist/features/openservice/serviceSchedules/calendarSync/functions/planToEvent.d.ts

@@ -0,0 +1,27 @@
+import type { GraphEvent } from "../../../schedules/calendarSync/types/Event.js";
+import type { ServiceCalendarEventSnapshot } from "../service/serviceCalendarMeta.js";
+import type { ServiceCadence, ServiceNotificationRule } from "../types/ServiceSyncTypes.js";
+/** A step of the plan, as far as the calendar entry shows it. */
+type PlanStep = {
+    order?: number;
+    title?: string;
+};
+export type PlanEventInput = {
+    title?: string;
+    cadence?: ServiceCadence;
+    steps?: PlanStep[];
+    notifications?: ServiceNotificationRule[];
+    /** Machine name — becomes the subject prefix. */
+    equipmentName?: string;
+    /** The event as it currently stands in Outlook, if it exists already. */
+    snapshot?: ServiceCalendarEventSnapshot;
+};
+/**
+ * A maintenance plan as a calendar event.
+ *
+ * Returns `undefined` for a plan that has no date to put in a calendar — a
+ * manual, sensor- or meter-driven plan has no due date until something happens,
+ * and inventing one would show maintenance that nobody scheduled.
+ */
+export declare function planToEvent(plan: PlanEventInput): GraphEvent | undefined;
+export {};

package/dist/features/openservice/serviceSchedules/calendarSync/functions/planToEvent.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planToEvent = planToEvent;
+const dayjs_1 = __importDefault(require("dayjs"));
+const outlookRecurrence_js_1 = require("./outlookRecurrence.js");
+/**
+ * A maintenance plan as a calendar event.
+ *
+ * Returns `undefined` for a plan that has no date to put in a calendar — a
+ * manual, sensor- or meter-driven plan has no due date until something happens,
+ * and inventing one would show maintenance that nobody scheduled.
+ */
+function planToEvent(plan) {
+    const start = cadenceStart(plan.cadence);
+    if (!start)
+        return undefined;
+    const timed = timeOfDay(plan, start);
+    const event = {
+        subject: eventSubject(plan),
+        body: { contentType: "Text", content: stepsAsText(plan.steps) },
+        start: graphStart(start, timed),
+        end: graphEnd(start, timed),
+        isAllDay: timed ? undefined : true,
+        isReminderOn: false,
+    };
+    const reminder = reminderMinutes(plan.notifications);
+    if (reminder !== undefined) {
+        event.isReminderOn = true;
+        event.reminderMinutesBeforeStart = reminder;
+    }
+    const recurrence = (0, outlookRecurrence_js_1.cadenceToRecurrence)(plan.cadence, start);
+    if (recurrence)
+        event.recurrence = recurrence;
+    return event;
+}
+/**
+ * The instant the series starts.
+ *
+ * Only an RRULE cadence has one. `until` is not consulted here: it bounds the
+ * series (the recurrence range does that), it does not start it.
+ */
+function cadenceStart(cadence) {
+    if (cadence?.kind !== "rrule" || !cadence.dtstart)
+        return undefined;
+    const start = new Date(cadence.dtstart);
+    return Number.isNaN(start.getTime()) ? undefined : start;
+}
+/**
+ * The time of day the event should keep, as `{hour, minute}` — or `undefined`
+ * for an all-day event.
+ *
+ * Two sources, in this order:
+ *
+ * 1. the plan's own `dtstart`, if it names a time (not UTC midnight) — the plan
+ *    is the leading side for anything the plan can express;
+ * 2. otherwise the time the **event** has in Outlook, so a user who dragged a
+ *    maintenance appointment to 9:00 keeps it. A plan whose due date shifts
+ *    then moves the appointment to the new *day* at the same time — which is
+ *    where v1 went wrong: it kept the whole original start and quietly ignored
+ *    the new date.
+ */
+function timeOfDay(plan, start) {
+    if (start.getUTCHours() !== 0 || start.getUTCMinutes() !== 0) {
+        return { hour: start.getUTCHours(), minute: start.getUTCMinutes() };
+    }
+    const snapshot = plan.snapshot;
+    if (!snapshot || snapshot.isAllDay || !snapshot.start?.dateTime) {
+        return undefined;
+    }
+    const previous = new Date(snapshot.start.dateTime.endsWith("Z")
+        ? snapshot.start.dateTime
+        : `${snapshot.start.dateTime.slice(0, 23)}Z`);
+    if (Number.isNaN(previous.getTime()))
+        return undefined;
+    if (previous.getUTCHours() === 0 && previous.getUTCMinutes() === 0) {
+        return undefined;
+    }
+    return { hour: previous.getUTCHours(), minute: previous.getUTCMinutes() };
+}
+function graphStart(start, timed) {
+    if (!timed) {
+        return { dateTime: dateOnly(start), timeZone: "UTC" };
+    }
+    return { dateTime: atTime(start, timed), timeZone: "UTC" };
+}
+function graphEnd(start, timed) {
+    if (!timed) {
+        // An all-day event ends on the following day — Graph's half-open interval.
+        return {
+            dateTime: dateOnly((0, dayjs_1.default)(start).add(1, "day").toDate()),
+            timeZone: "UTC",
+        };
+    }
+    const end = (0, dayjs_1.default)(atTime(start, timed)).add(1, "hour");
+    return { dateTime: end.format("YYYY-MM-DDTHH:mm:ss"), timeZone: "UTC" };
+}
+function dateOnly(date) {
+    return date.toISOString().slice(0, 10);
+}
+function atTime(date, timed) {
+    return `${dateOnly(date)}T${pad(timed.hour)}:${pad(timed.minute)}:00`;
+}
+function pad(value) {
+    return String(value).padStart(2, "0");
+}
+/**
+ * `"Flex 1" - Ölwechsel` — the convention the inbound direction reads back
+ * ([`parseSubject`](./eventToPlan.ts)), so a plan created here and edited in
+ * Outlook keeps its machine.
+ */
+function eventSubject(plan) {
+    const title = plan.title?.trim() || "Wartung";
+    return plan.equipmentName ? `"${plan.equipmentName}" - ${title}` : title;
+}
+/**
+ * The checklist as the event's note.
+ *
+ * The point of the appointment is that someone reads it in Outlook and knows
+ * what to bring — a title alone rarely says that.
+ */
+function stepsAsText(steps) {
+    const lines = [...(steps ?? [])]
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+        .map((step) => step.title?.trim())
+        .filter((title) => !!title)
+        .map((title) => `• ${title}`);
+    return lines.join("\n");
+}
+/**
+ * The plan's earliest warning as Outlook reminder minutes.
+ *
+ * A plan can warn several groups at different times; a calendar event has one
+ * reminder. The earliest one is the useful one — it is the moment the work
+ * first needs attention. `0` (reminder on the due date) is deliberate, not
+ * "no reminder": `undefined` means the plan warns nobody.
+ */
+function reminderMinutes(notifications) {
+    if (!notifications?.length)
+        return undefined;
+    const offsets = notifications.map((rule) => rule.trigger === "before" ? Math.max(0, rule.offsetDays ?? 0) : 0);
+    return Math.max(...offsets) * 24 * 60;
+}

package/dist/features/openservice/serviceSchedules/calendarSync/index.d.ts

@@ -0,0 +1,8 @@
+export { eventToPlanFields, mergeReminderRule, OUTLOOK_REMINDER_RULE_ID, parseSubject, } from "./functions/eventToPlan.js";
+export { buildRRule, cadenceToRecurrence, eventToCadence, parseRRule, } from "./functions/outlookRecurrence.js";
+export { planToEvent } from "./functions/planToEvent.js";
+export { findMetaForEvent, findMetaForPlan, SERVICE_CALENDAR_SYNC_CONTEXT, ServiceCalendarMetaConfig, } from "./service/serviceCalendarMeta.js";
+export { CALENDAR_SYNC_CONTEXT_FLAG, ServiceCalendarSyncPoller, } from "./service/ServiceCalendarSyncPoller.js";
+export { connectionForTenant, syncPlanToCalendar, } from "./service/syncPlanToCalendar.js";
+export { OUTLOOK_CONFIG_KEY } from "./types/ServiceSyncTypes.js";
+export type { ServiceCadence, ServiceNotificationRule, ServiceSyncConfigValues, } from "./types/ServiceSyncTypes.js";

package/dist/features/openservice/serviceSchedules/calendarSync/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTLOOK_CONFIG_KEY = exports.syncPlanToCalendar = exports.connectionForTenant = exports.ServiceCalendarSyncPoller = exports.CALENDAR_SYNC_CONTEXT_FLAG = exports.ServiceCalendarMetaConfig = exports.SERVICE_CALENDAR_SYNC_CONTEXT = exports.findMetaForPlan = exports.findMetaForEvent = exports.planToEvent = exports.parseRRule = exports.eventToCadence = exports.cadenceToRecurrence = exports.buildRRule = exports.parseSubject = exports.OUTLOOK_REMINDER_RULE_ID = exports.mergeReminderRule = exports.eventToPlanFields = void 0;
+var eventToPlan_js_1 = require("./functions/eventToPlan.js");
+Object.defineProperty(exports, "eventToPlanFields", { enumerable: true, get: function () { return eventToPlan_js_1.eventToPlanFields; } });
+Object.defineProperty(exports, "mergeReminderRule", { enumerable: true, get: function () { return eventToPlan_js_1.mergeReminderRule; } });
+Object.defineProperty(exports, "OUTLOOK_REMINDER_RULE_ID", { enumerable: true, get: function () { return eventToPlan_js_1.OUTLOOK_REMINDER_RULE_ID; } });
+Object.defineProperty(exports, "parseSubject", { enumerable: true, get: function () { return eventToPlan_js_1.parseSubject; } });
+var outlookRecurrence_js_1 = require("./functions/outlookRecurrence.js");
+Object.defineProperty(exports, "buildRRule", { enumerable: true, get: function () { return outlookRecurrence_js_1.buildRRule; } });
+Object.defineProperty(exports, "cadenceToRecurrence", { enumerable: true, get: function () { return outlookRecurrence_js_1.cadenceToRecurrence; } });
+Object.defineProperty(exports, "eventToCadence", { enumerable: true, get: function () { return outlookRecurrence_js_1.eventToCadence; } });
+Object.defineProperty(exports, "parseRRule", { enumerable: true, get: function () { return outlookRecurrence_js_1.parseRRule; } });
+var planToEvent_js_1 = require("./functions/planToEvent.js");
+Object.defineProperty(exports, "planToEvent", { enumerable: true, get: function () { return planToEvent_js_1.planToEvent; } });
+var serviceCalendarMeta_js_1 = require("./service/serviceCalendarMeta.js");
+Object.defineProperty(exports, "findMetaForEvent", { enumerable: true, get: function () { return serviceCalendarMeta_js_1.findMetaForEvent; } });
+Object.defineProperty(exports, "findMetaForPlan", { enumerable: true, get: function () { return serviceCalendarMeta_js_1.findMetaForPlan; } });
+Object.defineProperty(exports, "SERVICE_CALENDAR_SYNC_CONTEXT", { enumerable: true, get: function () { return serviceCalendarMeta_js_1.SERVICE_CALENDAR_SYNC_CONTEXT; } });
+Object.defineProperty(exports, "ServiceCalendarMetaConfig", { enumerable: true, get: function () { return serviceCalendarMeta_js_1.ServiceCalendarMetaConfig; } });
+var ServiceCalendarSyncPoller_js_1 = require("./service/ServiceCalendarSyncPoller.js");
+Object.defineProperty(exports, "CALENDAR_SYNC_CONTEXT_FLAG", { enumerable: true, get: function () { return ServiceCalendarSyncPoller_js_1.CALENDAR_SYNC_CONTEXT_FLAG; } });
+Object.defineProperty(exports, "ServiceCalendarSyncPoller", { enumerable: true, get: function () { return ServiceCalendarSyncPoller_js_1.ServiceCalendarSyncPoller; } });
+var syncPlanToCalendar_js_1 = require("./service/syncPlanToCalendar.js");
+Object.defineProperty(exports, "connectionForTenant", { enumerable: true, get: function () { return syncPlanToCalendar_js_1.connectionForTenant; } });
+Object.defineProperty(exports, "syncPlanToCalendar", { enumerable: true, get: function () { return syncPlanToCalendar_js_1.syncPlanToCalendar; } });
+var ServiceSyncTypes_js_1 = require("./types/ServiceSyncTypes.js");
+Object.defineProperty(exports, "OUTLOOK_CONFIG_KEY", { enumerable: true, get: function () { return ServiceSyncTypes_js_1.OUTLOOK_CONFIG_KEY; } });

package/dist/features/openservice/serviceSchedules/calendarSync/service/ServiceCalendarSyncPoller.d.ts

@@ -0,0 +1,54 @@
+import { Config } from "../../../../../types/index.js";
+/**
+ * Marker on a save that came from the calendar.
+ *
+ * The outbound side (`syncPlanToCalendar`, called from the `Service_Schedule`
+ * afterSave hook) checks it and stays quiet — otherwise every inbound change
+ * would be written straight back to Outlook, produce a new `changeKey`, come
+ * back through the delta feed as a foreign change, and loop forever. The stored
+ * `changeKey` is the second line of defence; this is the first, and unlike v1's
+ * `!master` check it does not disable outbound sync for every other
+ * master-key writer (the scheduler pausing a plan, a migration, a script).
+ */
+export declare const CALENDAR_SYNC_CONTEXT_FLAG = "fromCalendarSync";
+/**
+ * Pulls Outlook changes into open.SERVICE **v2** maintenance plans.
+ *
+ * One poller per configured connection, driven by the Graph *delta* feed: the
+ * first call reads the whole calendar, each later call only what changed, and
+ * the cursor lives in the Config row so a restart resumes instead of
+ * re-importing. The v1 poller does the same for `Maintenance_Schedule` from the
+ * same connection — the two keep separate cursors (`delta_link` vs
+ * `delta_link_v2`) so neither consumes the other's changes.
+ */
+export declare class ServiceCalendarSyncPoller {
+    private timer;
+    private config;
+    constructor(config: Config);
+    private get values();
+    private get manager();
+    start(intervalMs?: number): this;
+    stop(): void;
+    private poll;
+    private processEvent;
+    private createPlan;
+    private updatePlan;
+    /**
+     * A deleted appointment archives the plan — it never destroys it.
+     *
+     * Executions document that work happened; deleting the plan they point at
+     * would strand that history (the `beforeDelete` hook refuses it, too). The
+     * meta entry goes, so the same plan can be linked to a new event later.
+     */
+    private handleRemoved;
+    /** The machine named in the subject, else the configured fallback. */
+    private resolveEquipment;
+    private findEquipmentByLabel;
+    /**
+     * The cursor is re-read from the Config row on every tick, and written back
+     * after it: the row is also the admin form's storage, so it can change
+     * underneath us.
+     */
+    private loadDeltaLink;
+    private saveDeltaLink;
+}