@metamask/snaps-controllers 12.3.1 → 13.1.0

package/dist/cronjob/CronjobController.mjs

@@ -1,122 +1,71 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _CronjobController_instances, _CronjobController_dailyTimer, _CronjobController_timers, _CronjobController_snapIds, _CronjobController_getAllJobs, _CronjobController_getSnapJobs, _CronjobController_schedule, _CronjobController_executeCronjob, _CronjobController_setUpBackgroundEvent, _CronjobController_updateJobLastRunState, _CronjobController_rescheduleBackgroundEvents;
 import { BaseController } from "@metamask/base-controller";
 import { getCronjobCaveatJobs, SnapEndowments } from "@metamask/snaps-rpc-methods";
-import { HandlerType, parseCronExpression, logError, logWarning, toCensoredISO8601String } from "@metamask/snaps-utils";
-import { assert, Duration, hasProperty, inMilliseconds } from "@metamask/utils";
+import { toCensoredISO8601String, HandlerType, logError } from "@metamask/snaps-utils";
+import { assert, Duration, inMilliseconds } from "@metamask/utils";
 import { castDraft } from "immer";
 import { DateTime } from "luxon";
 import { nanoid } from "nanoid";
-import { getRunnableSnaps } from "../index.mjs";
+import { getCronjobSpecificationSchedule, getExecutionDate } from "./utils.mjs";
+import { METAMASK_ORIGIN } from "../snaps/constants.mjs";
 import { Timer } from "../snaps/Timer.mjs";
 export const DAILY_TIMEOUT = inMilliseconds(24, Duration.Hour);
 const controllerName = 'CronjobController';
 /**
- * Use this controller to register and schedule periodically executed jobs
- * using RPC method hooks.
+ * The cronjob controller is responsible for managing cronjobs and background
+ * events for Snaps. It allows Snaps to schedule events that will be executed
+ * at a later time.
  */
 export class CronjobController extends BaseController {
+    #timers;
+    #dailyTimer = new Timer(DAILY_TIMEOUT);
     constructor({ messenger, state }) {
         super({
             messenger,
             metadata: {
-                jobs: { persist: true, anonymous: false },
                 events: { persist: true, anonymous: false },
             },
             name: controllerName,
             state: {
-                jobs: {},
                 events: {},
                 ...state,
             },
         });
-        _CronjobController_instances.add(this);
-        _CronjobController_dailyTimer.set(this, void 0);
-        _CronjobController_timers.set(this, void 0);
-        // Mapping from jobId to snapId
-        _CronjobController_snapIds.set(this, void 0);
-        __classPrivateFieldSet(this, _CronjobController_timers, new Map(), "f");
-        __classPrivateFieldSet(this, _CronjobController_snapIds, new Map(), "f");
-        this._handleSnapRegisterEvent = this._handleSnapRegisterEvent.bind(this);
-        this._handleSnapUnregisterEvent =
-            this._handleSnapUnregisterEvent.bind(this);
-        this._handleEventSnapUpdated = this._handleEventSnapUpdated.bind(this);
-        this._handleSnapDisabledEvent = this._handleSnapDisabledEvent.bind(this);
-        this._handleSnapEnabledEvent = this._handleSnapEnabledEvent.bind(this);
-        // Subscribe to Snap events
-        /* eslint-disable @typescript-eslint/unbound-method */
-        this.messagingSystem.subscribe('SnapController:snapInstalled', this._handleSnapRegisterEvent);
-        this.messagingSystem.subscribe('SnapController:snapUninstalled', this._handleSnapUnregisterEvent);
-        this.messagingSystem.subscribe('SnapController:snapEnabled', this._handleSnapEnabledEvent);
-        this.messagingSystem.subscribe('SnapController:snapDisabled', this._handleSnapDisabledEvent);
-        this.messagingSystem.subscribe('SnapController:snapUpdated', this._handleEventSnapUpdated);
-        /* eslint-enable @typescript-eslint/unbound-method */
-        this.messagingSystem.registerActionHandler(`${controllerName}:scheduleBackgroundEvent`, (...args) => this.scheduleBackgroundEvent(...args));
-        this.messagingSystem.registerActionHandler(`${controllerName}:cancelBackgroundEvent`, (...args) => this.cancelBackgroundEvent(...args));
-        this.messagingSystem.registerActionHandler(`${controllerName}:getBackgroundEvents`, (...args) => this.getBackgroundEvents(...args));
-        this.dailyCheckIn();
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_rescheduleBackgroundEvents).call(this, Object.values(this.state.events));
+        this.#timers = new Map();
+        this.messagingSystem.subscribe('SnapController:snapInstalled', this.#handleSnapInstalledEvent);
+        this.messagingSystem.subscribe('SnapController:snapUninstalled', this.#handleSnapUninstalledEvent);
+        this.messagingSystem.subscribe('SnapController:snapEnabled', this.#handleSnapEnabledEvent);
+        this.messagingSystem.subscribe('SnapController:snapDisabled', this.#handleSnapDisabledEvent);
+        this.messagingSystem.subscribe('SnapController:snapUpdated', this.#handleSnapUpdatedEvent);
+        this.messagingSystem.registerActionHandler(`${controllerName}:schedule`, (...args) => this.schedule(...args));
+        this.messagingSystem.registerActionHandler(`${controllerName}:cancel`, (...args) => this.cancel(...args));
+        this.messagingSystem.registerActionHandler(`${controllerName}:get`, (...args) => this.get(...args));
+        this.#start();
+        this.#clear();
+        this.#reschedule();
     }
     /**
-     * Register cron jobs for a given snap by getting specification from a permission caveats.
-     * Once registered, each job will be scheduled.
+     * Schedule a non-recurring background event.
      *
-     * @param snapId - ID of a snap.
+     * @param event - The event to schedule.
+     * @returns The ID of the scheduled event.
      */
-    register(snapId) {
-        const jobs = __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_getSnapJobs).call(this, snapId);
-        jobs?.forEach((job) => __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_schedule).call(this, job));
-    }
-    /**
-     * Schedule a background event.
-     *
-     * @param backgroundEventWithoutId - Background event.
-     * @returns An id representing the background event.
-     */
-    scheduleBackgroundEvent(backgroundEventWithoutId) {
-        // Remove millisecond precision and convert to UTC.
-        const scheduledAt = DateTime.fromJSDate(new Date())
-            .toUTC()
-            .startOf('second')
-            .toISO({
-            suppressMilliseconds: true,
+    schedule(event) {
+        return this.#add({
+            ...event,
+            recurring: false,
         });
-        assert(scheduledAt);
-        const event = {
-            ...backgroundEventWithoutId,
-            id: nanoid(),
-            scheduledAt,
-        };
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_setUpBackgroundEvent).call(this, event);
-        return event.id;
     }
     /**
-     * Cancel a background event.
+     * Cancel an event.
      *
      * @param origin - The origin making the cancel call.
-     * @param id - The id of the background event to cancel.
+     * @param id - The id of the event to cancel.
      * @throws If the event does not exist.
      */
-    cancelBackgroundEvent(origin, id) {
+    cancel(origin, id) {
         assert(this.state.events[id], `A background event with the id of "${id}" does not exist.`);
         assert(this.state.events[id].snapId === origin, 'Only the origin that scheduled this event can cancel it.');
-        const timer = __classPrivateFieldGet(this, _CronjobController_timers, "f").get(id);
-        timer?.cancel();
-        __classPrivateFieldGet(this, _CronjobController_timers, "f").delete(id);
-        __classPrivateFieldGet(this, _CronjobController_snapIds, "f").delete(id);
-        this.update((state) => {
-            delete state.events[id];
-        });
+        this.#cancel(id);
     }
     /**
      * Get a list of a Snap's background events.
@@ -124,251 +73,276 @@ export class CronjobController extends BaseController {
      * @param snapId - The id of the Snap to fetch background events for.
      * @returns An array of background events.
      */
-    getBackgroundEvents(snapId) {
+    get(snapId) {
         return Object.values(this.state.events)
-            .filter((snapEvent) => snapEvent.snapId === snapId)
+            .filter((snapEvent) => snapEvent.snapId === snapId && !snapEvent.recurring)
             .map((event) => ({
             ...event,
-            // Truncate dates to remove milliseconds.
             date: toCensoredISO8601String(event.date),
+            scheduledAt: toCensoredISO8601String(event.scheduledAt),
         }));
     }
     /**
-     * Unregister all jobs and background events related to the given snapId.
+     * Register cronjobs for a given Snap by getting specification from the
+     * permission caveats. Once registered, each job will be scheduled.
      *
-     * @param snapId - ID of a snap.
-     * @param skipEvents - Whether the unregistration process should skip scheduled background events.
+     * @param snapId - The snap ID to register jobs for.
      */
-    unregister(snapId, skipEvents = false) {
-        const jobs = [...__classPrivateFieldGet(this, _CronjobController_snapIds, "f").entries()].filter(([_, jobSnapId]) => jobSnapId === snapId);
-        if (jobs.length) {
-            const eventIds = [];
-            jobs.forEach(([id]) => {
-                const timer = __classPrivateFieldGet(this, _CronjobController_timers, "f").get(id);
-                if (timer) {
-                    timer.cancel();
-                    __classPrivateFieldGet(this, _CronjobController_timers, "f").delete(id);
-                    __classPrivateFieldGet(this, _CronjobController_snapIds, "f").delete(id);
-                    if (!skipEvents && this.state.events[id]) {
-                        eventIds.push(id);
-                    }
-                }
-            });
-            if (eventIds.length > 0) {
-                this.update((state) => {
-                    eventIds.forEach((id) => {
-                        delete state.events[id];
-                    });
-                });
-            }
-        }
+    register(snapId) {
+        const jobs = this.#getSnapCronjobs(snapId);
+        jobs?.forEach((job) => this.#add(job));
     }
     /**
-     * Runs every 24 hours to check if new jobs need to be scheduled.
+     * Unregister all cronjobs and background events for a given Snap.
      *
-     * This is necessary for longer running jobs that execute with more than 24 hours between them.
+     * @param snapId - ID of a snap.
      */
-    dailyCheckIn() {
-        const jobs = __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_getAllJobs).call(this);
-        for (const job of jobs) {
-            const parsed = parseCronExpression(job.expression);
-            const lastRun = this.state.jobs[job.id]?.lastRun;
-            // If a job was supposed to run while we were shut down but wasn't we run it now
-            if (lastRun !== undefined &&
-                parsed.hasPrev() &&
-                parsed.prev().getTime() > lastRun) {
-                __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_executeCronjob).call(this, job).catch((error) => {
-                    logError(error);
-                });
+    unregister(snapId) {
+        for (const [id, event] of Object.entries(this.state.events)) {
+            if (event.snapId === snapId) {
+                this.#cancel(id);
             }
-            // Try scheduling, will fail if an existing scheduled job is found
-            __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_schedule).call(this, job);
         }
-        __classPrivateFieldSet(this, _CronjobController_dailyTimer, new Timer(DAILY_TIMEOUT), "f");
-        __classPrivateFieldGet(this, _CronjobController_dailyTimer, "f").start(() => {
-            this.dailyCheckIn();
-        });
     }
     /**
      * Run controller teardown process and unsubscribe from Snap events.
      */
     destroy() {
         super.destroy();
-        /* eslint-disable @typescript-eslint/unbound-method */
-        this.messagingSystem.unsubscribe('SnapController:snapInstalled', this._handleSnapRegisterEvent);
-        this.messagingSystem.unsubscribe('SnapController:snapUninstalled', this._handleSnapUnregisterEvent);
-        this.messagingSystem.unsubscribe('SnapController:snapEnabled', this._handleSnapEnabledEvent);
-        this.messagingSystem.unsubscribe('SnapController:snapDisabled', this._handleSnapDisabledEvent);
-        this.messagingSystem.unsubscribe('SnapController:snapUpdated', this._handleEventSnapUpdated);
-        /* eslint-enable @typescript-eslint/unbound-method */
-        __classPrivateFieldGet(this, _CronjobController_snapIds, "f").forEach((snapId) => this.unregister(snapId));
+        this.messagingSystem.unsubscribe('SnapController:snapInstalled', this.#handleSnapInstalledEvent);
+        this.messagingSystem.unsubscribe('SnapController:snapUninstalled', this.#handleSnapUninstalledEvent);
+        this.messagingSystem.unsubscribe('SnapController:snapEnabled', this.#handleSnapEnabledEvent);
+        this.messagingSystem.unsubscribe('SnapController:snapDisabled', this.#handleSnapDisabledEvent);
+        this.messagingSystem.unsubscribe('SnapController:snapUpdated', this.#handleSnapUpdatedEvent);
+        // Cancel all timers and clear the map.
+        this.#timers.forEach((timer) => timer.cancel());
+        this.#timers.clear();
+        if (this.#dailyTimer.status === 'running') {
+            this.#dailyTimer.cancel();
+        }
     }
     /**
-     * Handle events that should cause cronjobs to be registered.
-     *
-     * @param snap - Basic Snap information.
+     * Start the daily timer that will reschedule events every 24 hours.
      */
-    // TODO: Either fix this lint violation or explain why it's necessary to
-    //  ignore.
-    // eslint-disable-next-line no-restricted-syntax
-    _handleSnapRegisterEvent(snap) {
-        this.register(snap.id);
+    #start() {
+        this.#dailyTimer = new Timer(DAILY_TIMEOUT);
+        this.#dailyTimer.start(() => {
+            this.#reschedule();
+            this.#start();
+        });
     }
     /**
-     * Handle events that could cause cronjobs to be registered
-     * and for background events to be rescheduled.
+     * Add a cronjob or background event to the controller state and schedule it
+     * for execution.
      *
-     * @param snap - Basic Snap information.
+     * @param event - The event to schedule.
+     * @returns The ID of the scheduled event.
      */
-    // TODO: Either fix this lint violation or explain why it's necessary to
-    //  ignore.
-    // eslint-disable-next-line no-restricted-syntax
-    _handleSnapEnabledEvent(snap) {
-        const events = this.getBackgroundEvents(snap.id);
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_rescheduleBackgroundEvents).call(this, events);
-        this.register(snap.id);
+    #add(event) {
+        const id = event.id ?? nanoid();
+        const internalEvent = {
+            ...event,
+            id,
+            date: getExecutionDate(event.schedule),
+            scheduledAt: new Date().toISOString(),
+        };
+        this.update((state) => {
+            state.events[internalEvent.id] = castDraft(internalEvent);
+        });
+        this.#schedule(internalEvent);
+        return id;
     }
     /**
-     * Handle events that should cause cronjobs and background events to be unregistered.
+     * Get the next execution date for a given event and start a timer for it.
      *
-     * @param snap - Basic Snap information.
+     * @param event - The event to schedule.
      */
-    // TODO: Either fix this lint violation or explain why it's necessary to
-    //  ignore.
-    // eslint-disable-next-line no-restricted-syntax
-    _handleSnapUnregisterEvent(snap) {
-        this.unregister(snap.id);
+    #schedule(event) {
+        const date = getExecutionDate(event.schedule);
+        this.update((state) => {
+            state.events[event.id].date = date;
+        });
+        this.#startTimer({
+            ...event,
+            date,
+        });
     }
     /**
-     * Handle events that should cause cronjobs and background events to be unregistered.
+     * Set up and start a timer for the given event.
      *
-     * @param snap - Basic Snap information.
+     * @param event - The event to schedule.
+     * @throws If the event is scheduled in the past.
      */
-    // TODO: Either fix this lint violation or explain why it's necessary to
-    //  ignore.
-    // eslint-disable-next-line no-restricted-syntax
-    _handleSnapDisabledEvent(snap) {
-        this.unregister(snap.id, true);
+    #startTimer(event) {
+        const ms = DateTime.fromISO(event.date, { setZone: true }).toMillis() - Date.now();
+        // We don't schedule this job yet as it is too far in the future.
+        if (ms > DAILY_TIMEOUT) {
+            return;
+        }
+        const timer = new Timer(ms);
+        timer.start(() => {
+            this.#execute(event);
+        });
+        this.#timers.set(event.id, timer);
     }
     /**
-     * Handle cron jobs on 'snapUpdated' event.
+     * Execute a background event. This method is called when the event's timer
+     * expires.
      *
-     * @param snap - Basic Snap information.
+     * If the event is not recurring, it will be removed from the state after
+     * execution. If it is recurring, it will be rescheduled.
+     *
+     * @param event - The event to execute.
      */
-    // TODO: Either fix this lint violation or explain why it's necessary to
-    //  ignore.
-    // eslint-disable-next-line no-restricted-syntax
-    _handleEventSnapUpdated(snap) {
-        this.unregister(snap.id);
-        this.register(snap.id);
-    }
-}
-_CronjobController_dailyTimer = new WeakMap(), _CronjobController_timers = new WeakMap(), _CronjobController_snapIds = new WeakMap(), _CronjobController_instances = new WeakSet(), _CronjobController_getAllJobs = function _CronjobController_getAllJobs() {
-    const snaps = this.messagingSystem.call('SnapController:getAll');
-    const filteredSnaps = getRunnableSnaps(snaps);
-    const jobs = filteredSnaps.map((snap) => __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_getSnapJobs).call(this, snap.id));
-    return jobs.flat().filter((job) => job !== undefined);
-}, _CronjobController_getSnapJobs = function _CronjobController_getSnapJobs(snapId) {
-    const permissions = this.messagingSystem.call('PermissionController:getPermissions', snapId);
-    const permission = permissions?.[SnapEndowments.Cronjob];
-    const definitions = getCronjobCaveatJobs(permission);
-    return definitions?.map((definition, idx) => {
-        return { ...definition, id: `${snapId}-${idx}`, snapId };
-    });
-}, _CronjobController_schedule = function _CronjobController_schedule(job) {
-    if (__classPrivateFieldGet(this, _CronjobController_timers, "f").has(job.id)) {
-        return;
-    }
-    const parsed = parseCronExpression(job.expression);
-    const next = parsed.next();
-    const now = new Date();
-    const ms = next.getTime() - now.getTime();
-    // Don't schedule this job yet as it is too far in the future
-    if (ms > DAILY_TIMEOUT) {
-        return;
-    }
-    const timer = new Timer(ms);
-    timer.start(() => {
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_executeCronjob).call(this, job).catch((error) => {
-            // TODO: Decide how to handle errors.
-            logError(error);
-        });
-        __classPrivateFieldGet(this, _CronjobController_timers, "f").delete(job.id);
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_schedule).call(this, job);
-    });
-    if (!this.state.jobs[job.id]?.lastRun) {
-        __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_updateJobLastRunState).call(this, job.id, 0); // 0 for init, never ran actually
-    }
-    __classPrivateFieldGet(this, _CronjobController_timers, "f").set(job.id, timer);
-    __classPrivateFieldGet(this, _CronjobController_snapIds, "f").set(job.id, job.snapId);
-}, _CronjobController_executeCronjob = 
-/**
- * Execute job.
- *
- * @param job - Cronjob specification.
- */
-async function _CronjobController_executeCronjob(job) {
-    __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_updateJobLastRunState).call(this, job.id, Date.now());
-    await this.messagingSystem.call('SnapController:handleRequest', {
-        snapId: job.snapId,
-        origin: 'metamask',
-        handler: HandlerType.OnCronjob,
-        request: job.request,
-    });
-}, _CronjobController_setUpBackgroundEvent = function _CronjobController_setUpBackgroundEvent(event) {
-    const date = new Date(event.date);
-    const now = new Date();
-    const ms = date.getTime() - now.getTime();
-    if (ms <= 0) {
-        throw new Error('Cannot schedule an event in the past.');
-    }
-    // The event may already be in state when we get here.
-    if (!hasProperty(this.state.events, event.id)) {
-        this.update((state) => {
-            state.events[event.id] = castDraft(event);
-        });
-    }
-    const timer = new Timer(ms);
-    timer.start(() => {
+    #execute(event) {
         this.messagingSystem
             .call('SnapController:handleRequest', {
             snapId: event.snapId,
-            origin: 'metamask',
+            origin: METAMASK_ORIGIN,
             handler: HandlerType.OnCronjob,
             request: event.request,
         })
             .catch((error) => {
-            logError(error);
+            logError(`An error occurred while executing an event for Snap "${event.snapId}":`, error);
         });
-        __classPrivateFieldGet(this, _CronjobController_timers, "f").delete(event.id);
-        __classPrivateFieldGet(this, _CronjobController_snapIds, "f").delete(event.id);
-        this.update((state) => {
-            delete state.events[event.id];
-        });
-    });
-    __classPrivateFieldGet(this, _CronjobController_timers, "f").set(event.id, timer);
-    __classPrivateFieldGet(this, _CronjobController_snapIds, "f").set(event.id, event.snapId);
-}, _CronjobController_updateJobLastRunState = function _CronjobController_updateJobLastRunState(jobId, lastRun) {
-    this.update((state) => {
-        state.jobs[jobId] = {
-            lastRun,
-        };
-    });
-}, _CronjobController_rescheduleBackgroundEvents = function _CronjobController_rescheduleBackgroundEvents(backgroundEvents) {
-    for (const snapEvent of backgroundEvents) {
-        const { date } = snapEvent;
-        const now = new Date();
-        const then = new Date(date);
-        if (then.getTime() < now.getTime()) {
-            // Remove expired events from state
+        this.#timers.delete(event.id);
+        // Non-recurring events are removed from the state after execution, and
+        // recurring events are rescheduled.
+        if (!event.recurring) {
             this.update((state) => {
-                delete state.events[snapEvent.id];
+                delete state.events[event.id];
             });
-            logWarning(`Background event with id "${snapEvent.id}" not scheduled as its date has expired.`);
+            return;
+        }
+        this.#schedule(event);
+    }
+    /**
+     * Cancel a background event by its ID. Unlike {@link cancel}, this method
+     * does not check the origin of the event, so it can be used internally.
+     *
+     * @param id - The ID of the background event to cancel.
+     */
+    #cancel(id) {
+        const timer = this.#timers.get(id);
+        timer?.cancel();
+        this.#timers.delete(id);
+        this.update((state) => {
+            delete state.events[id];
+        });
+    }
+    /**
+     * Retrieve all cronjob specifications for a Snap.
+     *
+     * @param snapId - ID of a Snap.
+     * @returns Array of cronjob specifications.
+     */
+    #getSnapCronjobs(snapId) {
+        const permissions = this.messagingSystem.call('PermissionController:getPermissions', snapId);
+        const permission = permissions?.[SnapEndowments.Cronjob];
+        const definitions = getCronjobCaveatJobs(permission);
+        if (!definitions) {
+            return [];
+        }
+        return definitions.map((definition, idx) => {
+            return {
+                snapId,
+                id: `cronjob-${snapId}-${idx}`,
+                request: definition.request,
+                schedule: getCronjobSpecificationSchedule(definition),
+                recurring: true,
+            };
+        });
+    }
+    /**
+     * Handle events that should cause cron jobs to be registered.
+     *
+     * @param snap - Basic Snap information.
+     */
+    #handleSnapInstalledEvent = (snap) => {
+        this.register(snap.id);
+    };
+    /**
+     * Handle the Snap enabled event. This checks if the Snap has any cronjobs or
+     * background events that need to be rescheduled.
+     *
+     * @param snap - Basic Snap information.
+     */
+    #handleSnapEnabledEvent = (snap) => {
+        const events = this.get(snap.id);
+        this.#reschedule(events);
+        this.register(snap.id);
+    };
+    /**
+     * Handle events that should cause cronjobs and background events to be
+     * unregistered.
+     *
+     * @param snap - Basic Snap information.
+     */
+    #handleSnapUninstalledEvent = (snap) => {
+        this.unregister(snap.id);
+    };
+    /**
+     * Handle events that should cause cronjobs and background events to be
+     * unregistered.
+     *
+     * @param snap - Basic Snap information.
+     */
+    #handleSnapDisabledEvent = (snap) => {
+        this.unregister(snap.id);
+    };
+    /**
+     * Handle cron jobs on 'snapUpdated' event.
+     *
+     * @param snap - Basic Snap information.
+     */
+    #handleSnapUpdatedEvent = (snap) => {
+        this.unregister(snap.id);
+        this.register(snap.id);
+    };
+    /**
+     * Reschedule events that are yet to be executed. This should be called on
+     * controller initialization and once every 24 hours to ensure that
+     * background events are scheduled correctly.
+     *
+     * @param events - An array of events to reschedule. Defaults to all events in
+     * the controller state.
+     */
+    #reschedule(events = Object.values(this.state.events)) {
+        const now = Date.now();
+        for (const event of events) {
+            if (this.#timers.has(event.id)) {
+                // If the timer for this event already exists, we don't need to
+                // reschedule it.
+                continue;
+            }
+            const eventDate = DateTime.fromISO(event.date, {
+                setZone: true,
+            })
+                .toUTC()
+                .toMillis();
+            // If the event is recurring and the date is in the past, execute it
+            // immediately.
+            if (event.recurring && eventDate <= now) {
+                this.#execute(event);
+            }
+            this.#schedule(event);
         }
-        else {
-            __classPrivateFieldGet(this, _CronjobController_instances, "m", _CronjobController_setUpBackgroundEvent).call(this, snapEvent);
+    }
+    /**
+     * Clear non-recurring events that are past their scheduled time.
+     */
+    #clear() {
+        const now = Date.now();
+        for (const event of Object.values(this.state.events)) {
+            const eventDate = DateTime.fromISO(event.date, {
+                setZone: true,
+            })
+                .toUTC()
+                .toMillis();
+            if (!event.recurring && eventDate < now) {
+                this.#cancel(event.id);
+            }
         }
     }
-};
+}
 //# sourceMappingURL=CronjobController.mjs.map