mirror of
https://github.com/kennethnym/aris.git
synced 2026-06-16 20:41:18 +01:00
feat: add reminder source (#126)
This commit is contained in:
GitHub
633
packages/freya-source-reminders/src/reminder-source.ts
Normal file
633
packages/freya-source-reminders/src/reminder-source.ts
Normal file
@@ -0,0 +1,633 @@
|
||||
import type {
|
||||
ActionDefinition,
|
||||
Context,
|
||||
ContextEntry,
|
||||
FeedItemSignals,
|
||||
FeedSource,
|
||||
} from "@freya/core"
|
||||
|
||||
import { TimeRelevance, UnknownActionError } from "@freya/core"
|
||||
import { type } from "arktype"
|
||||
|
||||
import type {
|
||||
CompleteReminderInput,
|
||||
CreateReminderInput,
|
||||
DeleteReminderInput,
|
||||
Reminder,
|
||||
ReminderDeleteResult,
|
||||
ReminderEditScope,
|
||||
ReminderFeedItem,
|
||||
ReminderOccurrence,
|
||||
ReminderOccurrenceOverride,
|
||||
ReminderOccurrenceOverrideInput,
|
||||
ReminderOccurrencePatch,
|
||||
ReminderPatch,
|
||||
ReminderPriority,
|
||||
ReminderStorage,
|
||||
ReminderUpdateResult,
|
||||
UncompleteReminderInput,
|
||||
UpdateReminderInput,
|
||||
} from "./types.ts"
|
||||
|
||||
import {
|
||||
createReminderOccurrenceId,
|
||||
expandReminderOccurrences,
|
||||
findReminderOccurrenceIndex,
|
||||
recurrenceAfterSplit,
|
||||
stopRecurrenceAfterOccurrenceCount,
|
||||
} from "./recurrence.ts"
|
||||
import {
|
||||
CompleteReminderInput as CompleteReminderInputSchema,
|
||||
DeleteReminderInput as DeleteReminderInputSchema,
|
||||
ReminderAction,
|
||||
ReminderDeleteResultType,
|
||||
ReminderEditScope as ReminderEditScopeValue,
|
||||
ReminderFeedItemType,
|
||||
ReminderPriority as ReminderPriorityValue,
|
||||
ReminderRecurrenceFrequency,
|
||||
ReminderTimeZoneInput,
|
||||
ReminderUpdateResultType,
|
||||
ReminderWeekday,
|
||||
UncompleteReminderInput as UncompleteReminderInputSchema,
|
||||
UpdateReminderInput as UpdateReminderInputSchema,
|
||||
createReminderInputSchema,
|
||||
} from "./types.ts"
|
||||
|
||||
interface ArkSchema<T> {
|
||||
(value: unknown): T | InstanceType<typeof type.errors>
|
||||
}
|
||||
|
||||
export interface ReminderSourceOptions {
|
||||
storage: ReminderStorage
|
||||
/** Default: 24 hours. */
|
||||
lookAheadMs?: number
|
||||
/** Default: 24 hours, so earlier reminders from today remain visible. */
|
||||
lookBackMs?: number
|
||||
/** Default: false. */
|
||||
includeCompleted?: boolean
|
||||
/** Default: UTC. Used when create input omits timeZone. */
|
||||
defaultTimeZone?: string
|
||||
}
|
||||
|
||||
const DEFAULT_LOOK_AHEAD_MS = 24 * 60 * 60 * 1000
|
||||
const DEFAULT_LOOK_BACK_MS = 24 * 60 * 60 * 1000
|
||||
const DEFAULT_TIME_ZONE = "UTC"
|
||||
|
||||
const FIFTEEN_MINUTES_MS = 15 * 60 * 1000
|
||||
const ONE_HOUR_MS = 60 * 60 * 1000
|
||||
const ONE_DAY_MS = 24 * 60 * 60 * 1000
|
||||
|
||||
/**
|
||||
* FeedSource for one-off and recurring reminders.
|
||||
*
|
||||
* ReminderSource stores only canonical reminders plus occurrence overrides.
|
||||
* It owns recurrence expansion, edit-scope semantics, and feed item signals.
|
||||
*/
|
||||
export class ReminderSource implements FeedSource<ReminderFeedItem> {
|
||||
readonly id = "freya.reminders"
|
||||
|
||||
private readonly storage: ReminderStorage
|
||||
private readonly lookAheadMs: number
|
||||
private readonly lookBackMs: number
|
||||
private readonly includeCompleted: boolean
|
||||
private readonly defaultTimeZone: string
|
||||
private readonly createReminderInput: ReturnType<typeof createReminderInputSchema>
|
||||
private readonly itemListeners = new Set<(items: ReminderFeedItem[]) => void>()
|
||||
|
||||
constructor(options: ReminderSourceOptions) {
|
||||
this.storage = options.storage
|
||||
this.lookAheadMs = options.lookAheadMs ?? DEFAULT_LOOK_AHEAD_MS
|
||||
this.lookBackMs = options.lookBackMs ?? DEFAULT_LOOK_BACK_MS
|
||||
this.includeCompleted = options.includeCompleted ?? false
|
||||
this.defaultTimeZone = options.defaultTimeZone ?? DEFAULT_TIME_ZONE
|
||||
assertSchema(ReminderTimeZoneInput, this.defaultTimeZone)
|
||||
this.createReminderInput = createReminderInputSchema(this.defaultTimeZone)
|
||||
}
|
||||
|
||||
async listActions(): Promise<Record<string, ActionDefinition>> {
|
||||
return {
|
||||
[ReminderAction.CreateReminder]: {
|
||||
id: ReminderAction.CreateReminder,
|
||||
description: "Create a reminder",
|
||||
},
|
||||
[ReminderAction.UpdateReminder]: {
|
||||
id: ReminderAction.UpdateReminder,
|
||||
description: "Update a reminder or scoped recurrence occurrence",
|
||||
},
|
||||
[ReminderAction.DeleteReminder]: {
|
||||
id: ReminderAction.DeleteReminder,
|
||||
description: "Delete a reminder or scoped recurrence occurrence",
|
||||
},
|
||||
[ReminderAction.CompleteReminder]: {
|
||||
id: ReminderAction.CompleteReminder,
|
||||
description: "Complete a reminder occurrence",
|
||||
},
|
||||
[ReminderAction.UncompleteReminder]: {
|
||||
id: ReminderAction.UncompleteReminder,
|
||||
description: "Clear completion for a reminder occurrence",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
async executeAction(actionId: string, params: unknown): Promise<unknown> {
|
||||
switch (actionId) {
|
||||
case ReminderAction.CreateReminder:
|
||||
return this.createReminder(assertSchema(this.createReminderInput, params))
|
||||
case ReminderAction.UpdateReminder:
|
||||
return this.updateReminder(assertSchema(UpdateReminderInputSchema, params))
|
||||
case ReminderAction.DeleteReminder:
|
||||
return this.deleteReminder(assertSchema(DeleteReminderInputSchema, params))
|
||||
case ReminderAction.CompleteReminder:
|
||||
return this.completeReminder(assertSchema(CompleteReminderInputSchema, params))
|
||||
case ReminderAction.UncompleteReminder:
|
||||
return this.uncompleteReminder(assertSchema(UncompleteReminderInputSchema, params))
|
||||
default:
|
||||
throw new UnknownActionError(actionId)
|
||||
}
|
||||
}
|
||||
|
||||
async fetchContext(_context: Context): Promise<readonly ContextEntry[] | null> {
|
||||
return null
|
||||
}
|
||||
|
||||
onItemsUpdate(callback: (items: ReminderFeedItem[]) => void): () => void {
|
||||
this.itemListeners.add(callback)
|
||||
const cleanupStorage = this.storage.subscribe?.(() => {
|
||||
this.notifyItemsChanged()
|
||||
})
|
||||
|
||||
return () => {
|
||||
this.itemListeners.delete(callback)
|
||||
cleanupStorage?.()
|
||||
}
|
||||
}
|
||||
|
||||
async fetchItems(context: Context): Promise<ReminderFeedItem[]> {
|
||||
const from = new Date(context.time.getTime() - this.lookBackMs)
|
||||
const to = new Date(context.time.getTime() + this.lookAheadMs)
|
||||
const reminders = await this.storage.listReminders({
|
||||
from,
|
||||
to,
|
||||
includeCompleted: this.includeCompleted,
|
||||
})
|
||||
|
||||
if (reminders.length === 0) return []
|
||||
|
||||
const reminderIds = reminders.map(function reminderId(reminder) {
|
||||
return reminder.id
|
||||
})
|
||||
const overrides = await this.storage.listOccurrenceOverrides({ reminderIds, from, to })
|
||||
const overridesByReminderId = groupOverridesByReminderId(overrides)
|
||||
|
||||
const items: ReminderFeedItem[] = []
|
||||
for (const reminder of reminders) {
|
||||
const occurrences = expandReminderOccurrences(reminder, {
|
||||
from,
|
||||
to,
|
||||
includeCompleted: this.includeCompleted,
|
||||
overrides: overridesByReminderId.get(reminder.id),
|
||||
})
|
||||
|
||||
for (const occurrence of occurrences) {
|
||||
items.push(createFeedItem(occurrence, context.time, this.id))
|
||||
}
|
||||
}
|
||||
|
||||
return items.sort(compareFeedItems)
|
||||
}
|
||||
|
||||
async createReminder(input: CreateReminderInput): Promise<Reminder> {
|
||||
const reminder = await this.storage.createReminder(
|
||||
assertSchema(this.createReminderInput, input),
|
||||
)
|
||||
this.notifyItemsChanged()
|
||||
return reminder
|
||||
}
|
||||
|
||||
async updateReminder(input: UpdateReminderInput): Promise<ReminderUpdateResult> {
|
||||
const parsed = assertSchema(UpdateReminderInputSchema, input)
|
||||
const reminder = await this.requireReminder(parsed.reminderId)
|
||||
const result = await this.updateExistingReminder(reminder, parsed)
|
||||
this.notifyItemsChanged()
|
||||
return result
|
||||
}
|
||||
|
||||
async deleteReminder(input: DeleteReminderInput): Promise<ReminderDeleteResult> {
|
||||
const parsed = assertSchema(DeleteReminderInputSchema, input)
|
||||
const reminder = await this.requireReminder(parsed.reminderId)
|
||||
const result = await this.deleteExistingReminder(reminder, parsed)
|
||||
this.notifyItemsChanged()
|
||||
return result
|
||||
}
|
||||
|
||||
async completeReminder(input: CompleteReminderInput): Promise<ReminderOccurrenceOverride> {
|
||||
const parsed = assertSchema(CompleteReminderInputSchema, input)
|
||||
const reminder = await this.requireReminder(parsed.reminderId)
|
||||
const occurrenceDueAt = parsed.occurrenceDueAt
|
||||
this.requireKnownOccurrence(reminder, occurrenceDueAt)
|
||||
|
||||
const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
|
||||
completedAt: parsed.completedAt ?? new Date(),
|
||||
deletedAt: null,
|
||||
})
|
||||
|
||||
this.notifyItemsChanged()
|
||||
return override
|
||||
}
|
||||
|
||||
async uncompleteReminder(input: UncompleteReminderInput): Promise<ReminderOccurrenceOverride> {
|
||||
const parsed = assertSchema(UncompleteReminderInputSchema, input)
|
||||
const reminder = await this.requireReminder(parsed.reminderId)
|
||||
const occurrenceDueAt = parsed.occurrenceDueAt
|
||||
this.requireKnownOccurrence(reminder, occurrenceDueAt)
|
||||
|
||||
const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
|
||||
completedAt: null,
|
||||
})
|
||||
|
||||
this.notifyItemsChanged()
|
||||
return override
|
||||
}
|
||||
|
||||
private async updateExistingReminder(
|
||||
reminder: Reminder,
|
||||
input: UpdateReminderInput,
|
||||
): Promise<ReminderUpdateResult> {
|
||||
if (input.scope === ReminderEditScopeValue.EntireSeries) {
|
||||
const updated = await this.storage.updateReminder(reminder.id, input.patch)
|
||||
return {
|
||||
type: ReminderUpdateResultType.UpdatedReminder,
|
||||
reminder: updated,
|
||||
}
|
||||
}
|
||||
|
||||
const occurrenceDueAt = requireOccurrenceDueAt(input)
|
||||
this.requireKnownOccurrence(reminder, occurrenceDueAt)
|
||||
|
||||
if (!reminder.recurrence) {
|
||||
const updated = await this.storage.updateReminder(reminder.id, input.patch)
|
||||
return {
|
||||
type: ReminderUpdateResultType.UpdatedReminder,
|
||||
reminder: updated,
|
||||
}
|
||||
}
|
||||
|
||||
if (input.scope === ReminderEditScopeValue.ThisOccurrence) {
|
||||
if (hasOwn(input.patch, "recurrence")) {
|
||||
throw new Error("recurrence cannot be changed for a single occurrence")
|
||||
}
|
||||
|
||||
const { recurrence: _recurrence, ...occurrencePatch } = input.patch
|
||||
const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
|
||||
patch: occurrencePatch,
|
||||
})
|
||||
return {
|
||||
type: ReminderUpdateResultType.UpdatedOccurrence,
|
||||
override,
|
||||
}
|
||||
}
|
||||
|
||||
return this.splitReminder(reminder, occurrenceDueAt, input.patch)
|
||||
}
|
||||
|
||||
private async deleteExistingReminder(
|
||||
reminder: Reminder,
|
||||
input: DeleteReminderInput,
|
||||
): Promise<ReminderDeleteResult> {
|
||||
if (input.scope === ReminderEditScopeValue.EntireSeries) {
|
||||
await this.storage.deleteReminder(reminder.id)
|
||||
return { type: ReminderDeleteResultType.DeletedReminder }
|
||||
}
|
||||
|
||||
const occurrenceDueAt = requireOccurrenceDueAt(input)
|
||||
this.requireKnownOccurrence(reminder, occurrenceDueAt)
|
||||
|
||||
if (!reminder.recurrence) {
|
||||
await this.storage.deleteReminder(reminder.id)
|
||||
return { type: ReminderDeleteResultType.DeletedReminder }
|
||||
}
|
||||
|
||||
if (input.scope === ReminderEditScopeValue.ThisOccurrence) {
|
||||
const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
|
||||
deletedAt: new Date(),
|
||||
})
|
||||
return {
|
||||
type: ReminderDeleteResultType.DeletedOccurrence,
|
||||
override,
|
||||
}
|
||||
}
|
||||
|
||||
const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
|
||||
if (occurrenceIndex === null) {
|
||||
throw new Error("occurrenceDueAt does not match this reminder")
|
||||
}
|
||||
if (occurrenceIndex === 0) {
|
||||
await this.storage.deleteReminder(reminder.id)
|
||||
return { type: ReminderDeleteResultType.DeletedReminder }
|
||||
}
|
||||
|
||||
const recurrence = stopRecurrenceAfterOccurrenceCount(reminder.recurrence, occurrenceIndex)
|
||||
const updated = await this.storage.updateReminder(reminder.id, { recurrence })
|
||||
return {
|
||||
type: ReminderDeleteResultType.EndedReminder,
|
||||
reminder: updated,
|
||||
}
|
||||
}
|
||||
|
||||
private async splitReminder(
|
||||
reminder: Reminder,
|
||||
occurrenceDueAt: Date,
|
||||
patch: ReminderPatch,
|
||||
): Promise<ReminderUpdateResult> {
|
||||
if (!reminder.recurrence) {
|
||||
const updated = await this.storage.updateReminder(reminder.id, patch)
|
||||
return {
|
||||
type: ReminderUpdateResultType.UpdatedReminder,
|
||||
reminder: updated,
|
||||
}
|
||||
}
|
||||
|
||||
const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
|
||||
if (occurrenceIndex === null) {
|
||||
throw new Error("occurrenceDueAt does not match this reminder")
|
||||
}
|
||||
|
||||
if (occurrenceIndex === 0) {
|
||||
const updated = await this.storage.updateReminder(reminder.id, patch)
|
||||
return {
|
||||
type: ReminderUpdateResultType.UpdatedReminder,
|
||||
reminder: updated,
|
||||
}
|
||||
}
|
||||
|
||||
const previousRecurrence = stopRecurrenceAfterOccurrenceCount(
|
||||
reminder.recurrence,
|
||||
occurrenceIndex,
|
||||
)
|
||||
const previousReminder = await this.storage.updateReminder(reminder.id, {
|
||||
recurrence: previousRecurrence,
|
||||
})
|
||||
const newReminder = await this.storage.createReminder(
|
||||
createSplitReminderInput(reminder, occurrenceDueAt, occurrenceIndex, patch),
|
||||
)
|
||||
|
||||
return {
|
||||
type: ReminderUpdateResultType.SplitReminder,
|
||||
previousReminder,
|
||||
newReminder,
|
||||
}
|
||||
}
|
||||
|
||||
private requireKnownOccurrence(reminder: Reminder, occurrenceDueAt: Date): void {
|
||||
const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
|
||||
if (occurrenceIndex === null) {
|
||||
throw new Error("occurrenceDueAt does not match this reminder")
|
||||
}
|
||||
}
|
||||
|
||||
private async requireReminder(id: string): Promise<Reminder> {
|
||||
const reminder = await this.storage.getReminder(id)
|
||||
if (!reminder) {
|
||||
throw new Error(`Reminder not found: ${id}`)
|
||||
}
|
||||
return reminder
|
||||
}
|
||||
|
||||
private async mergeOccurrenceOverride(
|
||||
reminderId: string,
|
||||
originalDueAt: Date,
|
||||
patch: Partial<ReminderOccurrenceOverrideInput>,
|
||||
): Promise<ReminderOccurrenceOverride> {
|
||||
const occurrenceId = createReminderOccurrenceId(originalDueAt)
|
||||
const existing = await this.storage.getOccurrenceOverride(reminderId, occurrenceId)
|
||||
|
||||
const input: ReminderOccurrenceOverrideInput = {
|
||||
reminderId,
|
||||
occurrenceId,
|
||||
originalDueAt,
|
||||
patch: mergeOccurrencePatch(existing?.patch, patch.patch),
|
||||
completedAt: hasOwn(patch, "completedAt")
|
||||
? (patch.completedAt ?? null)
|
||||
: existing?.completedAt,
|
||||
deletedAt: hasOwn(patch, "deletedAt") ? (patch.deletedAt ?? null) : existing?.deletedAt,
|
||||
}
|
||||
|
||||
return this.storage.upsertOccurrenceOverride(input)
|
||||
}
|
||||
|
||||
private notifyItemsChanged(): void {
|
||||
for (const listener of this.itemListeners) {
|
||||
listener([])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function createFeedItem(
|
||||
occurrence: ReminderOccurrence,
|
||||
now: Date,
|
||||
sourceId: string,
|
||||
): ReminderFeedItem {
|
||||
return {
|
||||
id: `reminder-${occurrence.reminderId}-${occurrence.occurrenceId}`,
|
||||
sourceId,
|
||||
type: ReminderFeedItemType.Reminder,
|
||||
timestamp: now,
|
||||
data: {
|
||||
reminderId: occurrence.reminderId,
|
||||
occurrenceId: occurrence.occurrenceId,
|
||||
title: occurrence.title,
|
||||
notes: occurrence.notes,
|
||||
originalDueAt: occurrence.originalDueAt,
|
||||
dueAt: occurrence.dueAt,
|
||||
timeZone: occurrence.timeZone,
|
||||
recurrence: occurrence.recurrence,
|
||||
priority: occurrence.priority,
|
||||
completedAt: occurrence.completedAt,
|
||||
},
|
||||
signals: computeSignals(occurrence, now),
|
||||
}
|
||||
}
|
||||
|
||||
function computeSignals(occurrence: ReminderOccurrence, now: Date): FeedItemSignals {
|
||||
if (occurrence.completedAt) {
|
||||
return { urgency: 0, timeRelevance: TimeRelevance.Ambient }
|
||||
}
|
||||
|
||||
const msUntilDue = occurrence.dueAt.getTime() - now.getTime()
|
||||
let urgency: number
|
||||
let timeRelevance: TimeRelevance
|
||||
|
||||
if (msUntilDue < 0) {
|
||||
urgency = 1
|
||||
timeRelevance = TimeRelevance.Imminent
|
||||
} else if (msUntilDue <= FIFTEEN_MINUTES_MS) {
|
||||
urgency = 0.95
|
||||
timeRelevance = TimeRelevance.Imminent
|
||||
} else if (msUntilDue <= ONE_HOUR_MS) {
|
||||
urgency = 0.8
|
||||
timeRelevance = TimeRelevance.Imminent
|
||||
} else if (msUntilDue <= ONE_DAY_MS) {
|
||||
urgency = 0.5
|
||||
timeRelevance = TimeRelevance.Upcoming
|
||||
} else {
|
||||
urgency = 0.2
|
||||
timeRelevance = TimeRelevance.Ambient
|
||||
}
|
||||
|
||||
return {
|
||||
urgency: clamp01(urgency + priorityUrgencyAdjustment(occurrence.priority)),
|
||||
timeRelevance,
|
||||
}
|
||||
}
|
||||
|
||||
function createSplitReminderInput(
|
||||
reminder: Reminder,
|
||||
occurrenceDueAt: Date,
|
||||
occurrenceIndex: number,
|
||||
patch: ReminderPatch,
|
||||
): CreateReminderInput {
|
||||
const dueAt = patch.dueAt ?? occurrenceDueAt
|
||||
const timeZone = patch.timeZone ?? reminder.timeZone
|
||||
const recurrence = hasOwn(patch, "recurrence")
|
||||
? (patch.recurrence ?? null)
|
||||
: alignSplitRecurrence(
|
||||
recurrenceAfterSplit(reminder.recurrence!, occurrenceIndex),
|
||||
occurrenceDueAt,
|
||||
reminder.timeZone,
|
||||
dueAt,
|
||||
timeZone,
|
||||
)
|
||||
|
||||
return {
|
||||
title: patch.title ?? reminder.title,
|
||||
notes: hasOwn(patch, "notes") ? (patch.notes ?? null) : reminder.notes,
|
||||
dueAt,
|
||||
timeZone,
|
||||
recurrence,
|
||||
priority: patch.priority ?? reminder.priority,
|
||||
}
|
||||
}
|
||||
|
||||
function alignSplitRecurrence(
|
||||
recurrence: Reminder["recurrence"],
|
||||
occurrenceDueAt: Date,
|
||||
occurrenceTimeZone: string,
|
||||
dueAt: Date,
|
||||
timeZone: string,
|
||||
): Reminder["recurrence"] {
|
||||
if (
|
||||
!recurrence ||
|
||||
recurrence.frequency !== ReminderRecurrenceFrequency.Weekly ||
|
||||
!recurrence.weekdays?.length
|
||||
) {
|
||||
return recurrence
|
||||
}
|
||||
|
||||
const previousWeekday = weekdayForDate(occurrenceDueAt, occurrenceTimeZone)
|
||||
const nextWeekday = weekdayForDate(dueAt, timeZone)
|
||||
if (previousWeekday === nextWeekday || recurrence.weekdays.includes(nextWeekday)) {
|
||||
return recurrence
|
||||
}
|
||||
|
||||
const weekdays = recurrence.weekdays
|
||||
.filter(function keepOtherWeekdays(weekday) {
|
||||
return weekday !== previousWeekday
|
||||
})
|
||||
.concat(nextWeekday)
|
||||
.sort(compareWeekdays)
|
||||
|
||||
return { ...recurrence, weekdays }
|
||||
}
|
||||
|
||||
function weekdayForDate(date: Date, timeZone: string): ReminderWeekday {
|
||||
const parts = new Intl.DateTimeFormat("en-US", {
|
||||
timeZone,
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
}).formatToParts(date)
|
||||
|
||||
const year = numberDatePart(parts, "year")
|
||||
const month = numberDatePart(parts, "month")
|
||||
const day = numberDatePart(parts, "day")
|
||||
return new Date(Date.UTC(year, month - 1, day)).getUTCDay() as ReminderWeekday
|
||||
}
|
||||
|
||||
function numberDatePart(
|
||||
parts: Intl.DateTimeFormatPart[],
|
||||
type: Intl.DateTimeFormatPartTypes,
|
||||
): number {
|
||||
const part = parts.find(function matchesType(value) {
|
||||
return value.type === type
|
||||
})
|
||||
if (!part) {
|
||||
throw new Error(`Missing ${type} part while formatting reminder date`)
|
||||
}
|
||||
return Number(part.value)
|
||||
}
|
||||
|
||||
function compareWeekdays(a: ReminderWeekday, b: ReminderWeekday): number {
|
||||
return a - b
|
||||
}
|
||||
|
||||
function mergeOccurrencePatch(
|
||||
existing: ReminderOccurrencePatch | undefined,
|
||||
next: ReminderOccurrencePatch | undefined,
|
||||
): ReminderOccurrencePatch | undefined {
|
||||
if (!existing) return next
|
||||
if (!next) return existing
|
||||
return { ...existing, ...next }
|
||||
}
|
||||
|
||||
function groupOverridesByReminderId(
|
||||
overrides: readonly ReminderOccurrenceOverride[],
|
||||
): Map<string, ReminderOccurrenceOverride[]> {
|
||||
const grouped = new Map<string, ReminderOccurrenceOverride[]>()
|
||||
for (const override of overrides) {
|
||||
const list = grouped.get(override.reminderId) ?? []
|
||||
list.push(override)
|
||||
grouped.set(override.reminderId, list)
|
||||
}
|
||||
return grouped
|
||||
}
|
||||
|
||||
function priorityUrgencyAdjustment(priority: ReminderPriority): number {
|
||||
switch (priority) {
|
||||
case ReminderPriorityValue.High:
|
||||
return 0.1
|
||||
case ReminderPriorityValue.Low:
|
||||
return -0.1
|
||||
case ReminderPriorityValue.Normal:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
function requireOccurrenceDueAt(input: { scope: ReminderEditScope; occurrenceDueAt?: Date }): Date {
|
||||
if (!input.occurrenceDueAt) {
|
||||
throw new Error(`${input.scope} requires occurrenceDueAt`)
|
||||
}
|
||||
return input.occurrenceDueAt
|
||||
}
|
||||
|
||||
function assertSchema<T>(schema: ArkSchema<T>, value: unknown): T {
|
||||
const result = schema(value)
|
||||
if (result instanceof type.errors) {
|
||||
throw new Error(result.summary)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
function hasOwn<TObject extends object, TKey extends PropertyKey>(
|
||||
object: TObject,
|
||||
key: TKey,
|
||||
): object is TObject & Record<TKey, unknown> {
|
||||
return Object.prototype.hasOwnProperty.call(object, key)
|
||||
}
|
||||
|
||||
function clamp01(value: number): number {
|
||||
return Math.max(0, Math.min(1, value))
|
||||
}
|
||||
|
||||
function compareFeedItems(a: ReminderFeedItem, b: ReminderFeedItem): number {
|
||||
return a.data.dueAt.getTime() - b.data.dueAt.getTime()
|
||||
}
|
||||
Reference in New Issue
Block a user