@chipmobilesdk/rn-notification 0.3.0 → 0.4.1

package/src/state/series-ledger.ts

@@ -1,84 +1,91 @@
-/**
- * The recurrence series ledger.
- *
- * What makes automatic maintenance possible without a desired set from the
- * consumer: the package remembers which series it owns, how far each has been
- * expanded, and how many occurrences a count-limited series has already
- * emitted. None of that is derivable from the platform's pending set, which
- * knows only about individual notifications.
- *
- * It also defines what maintenance is allowed to touch. An occurrence belongs
- * to a series in this ledger, so cancelling it is within scope; anything else
- * is a directly-scheduled notification the package does not own.
- */
-
-import type { StateManager, SeriesEntry } from './record';
-import type { RecurrenceRule } from '../contract/recurrence';
-import type { AnchoringMode } from '../contract/notification';
-
-export interface SeriesRecord {
-	readonly seriesId: string;
-	readonly anchoring: AnchoringMode;
-	readonly expandedThrough: number;
-	readonly emittedCount: number;
-	readonly exhausted: boolean;
-	readonly at: number;
-}
-
-export function readSeries(state: StateManager, seriesId: string): SeriesRecord | undefined {
-	return state.read().seriesLedger.find(entry => entry.seriesId === seriesId);
-}
-
-export function listSeries(state: StateManager): readonly SeriesRecord[] {
-	return state.read().seriesLedger;
-}
-
-/** Records or updates a series. Replaces in place so a re-registration cannot duplicate. */
-export function upsertSeries(
-	state: StateManager,
-	rule: RecurrenceRule,
-	update: { readonly expandedThrough: number; readonly emittedCount: number; readonly exhausted: boolean },
-	now: number,
-): void {
-	const entry: SeriesEntry = {
-		at: now,
-		seriesId: rule.id,
-		anchoring: rule.anchoring ?? 'wallClock',
-		expandedThrough: update.expandedThrough,
-		emittedCount: update.emittedCount,
-		exhausted: update.exhausted,
-	};
-
-	state.update('seriesLedger', current => [
-		...current.filter(existing => existing.seriesId !== rule.id),
-		entry,
-	]);
-}
-
-export function removeSeries(state: StateManager, seriesId: string): void {
-	state.update('seriesLedger', current => current.filter(entry => entry.seriesId !== seriesId));
-}
-
-/**
- * Identifiers the package owns.
- *
- * An occurrence identifier is `<seriesId>#<instant>`, so ownership is decided
- * by prefix rather than by an enumeration the ledger would have to keep in sync
- * with the device. That keeps the check correct even for occurrences scheduled
- * before the app last restarted.
- */
-export function ownsIdentifier(state: StateManager, id: string): boolean {
-	const separator = id.lastIndexOf('#');
-	if (separator === -1) return false;
-
-	const seriesId = id.slice(0, separator);
-	return state.read().seriesLedger.some(entry => entry.seriesId === seriesId);
-}
-
-/** Every occurrence identifier currently attributable to a tracked series. */
-export function ownedIdentifiers(
-	state: StateManager,
-	pendingIds: readonly string[],
-): ReadonlySet<string> {
-	return new Set(pendingIds.filter(id => ownsIdentifier(state, id)));
-}
+/**
+ * The recurrence series ledger.
+ *
+ * What makes automatic maintenance possible without a desired set from the
+ * consumer: the package remembers which series it owns, how far each has been
+ * expanded, and how many occurrences a count-limited series has already
+ * emitted. None of that is derivable from the platform's pending set, which
+ * knows only about individual notifications.
+ *
+ * It also defines what maintenance is allowed to touch. An occurrence belongs
+ * to a series in this ledger, so cancelling it is within scope; anything else
+ * is a directly-scheduled notification the package does not own.
+ */
+
+import type { StateManager, SeriesEntry } from './record';
+import type { RecurrenceRule } from '../contract/recurrence';
+import type { AnchoringMode } from '../contract/notification';
+
+export interface SeriesRecord {
+	readonly seriesId: string;
+	readonly anchoring: AnchoringMode;
+	readonly expandedThrough: number;
+	readonly emittedCount: number;
+	readonly exhausted: boolean;
+	readonly lastEmittedKey?: string;
+	readonly at: number;
+}
+
+export function readSeries(state: StateManager, seriesId: string): SeriesRecord | undefined {
+	return state.read().seriesLedger.find(entry => entry.seriesId === seriesId);
+}
+
+export function listSeries(state: StateManager): readonly SeriesRecord[] {
+	return state.read().seriesLedger;
+}
+
+/** Records or updates a series. Replaces in place so a re-registration cannot duplicate. */
+export function upsertSeries(
+	state: StateManager,
+	rule: RecurrenceRule,
+	update: {
+		readonly expandedThrough: number;
+		readonly emittedCount: number;
+		readonly exhausted: boolean;
+		readonly lastEmittedKey?: string;
+	},
+	now: number,
+): void {
+	const entry: SeriesEntry = {
+		at: now,
+		seriesId: rule.id,
+		anchoring: rule.anchoring ?? 'wallClock',
+		expandedThrough: update.expandedThrough,
+		emittedCount: update.emittedCount,
+		exhausted: update.exhausted,
+		...(update.lastEmittedKey !== undefined ? { lastEmittedKey: update.lastEmittedKey } : {}),
+	};
+
+	state.update('seriesLedger', current => [
+		...current.filter(existing => existing.seriesId !== rule.id),
+		entry,
+	]);
+}
+
+export function removeSeries(state: StateManager, seriesId: string): void {
+	state.update('seriesLedger', current => current.filter(entry => entry.seriesId !== seriesId));
+}
+
+/**
+ * Identifiers the package owns.
+ *
+ * An occurrence identifier is `<seriesId>#<instant>`, so ownership is decided
+ * by prefix rather than by an enumeration the ledger would have to keep in sync
+ * with the device. That keeps the check correct even for occurrences scheduled
+ * before the app last restarted.
+ */
+export function ownsIdentifier(state: StateManager, id: string): boolean {
+	const separator = id.lastIndexOf('#');
+	if (separator === -1) return false;
+
+	const seriesId = id.slice(0, separator);
+	return state.read().seriesLedger.some(entry => entry.seriesId === seriesId);
+}
+
+/** Every occurrence identifier currently attributable to a tracked series. */
+export function ownedIdentifiers(
+	state: StateManager,
+	pendingIds: readonly string[],
+): ReadonlySet<string> {
+	return new Set(pendingIds.filter(id => ownsIdentifier(state, id)));
+}

package/src/state/store.ts

@@ -1,40 +1,40 @@
-/**
- * The storage port behind the persisted state record.
- *
- * Kept as a port so the pure state logic is testable with no native module,
- * and so MMKV stays confined to one file. This is internal — a consumer can
- * reset or clear state, but can never read or write the record directly.
- */
-
-export interface StateStore {
-	getString(key: string): string | undefined;
-	setString(key: string, value: string): void;
-	delete(key: string): void;
-	clearAll(): void;
-	/** Approximate on-disk size, for the health report. */
-	approximateBytes(): number;
-}
-
-/** In-memory store, used by tests and as the fallback when MMKV is unavailable. */
-export function createMemoryStore(): StateStore {
-	const map = new Map<string, string>();
-	return {
-		getString: key => map.get(key),
-		setString: (key, value) => {
-			map.set(key, value);
-		},
-		delete: key => {
-			map.delete(key);
-		},
-		clearAll: () => {
-			map.clear();
-		},
-		approximateBytes: () => {
-			let total = 0;
-			for (const [key, value] of map) {
-				total += key.length + value.length;
-			}
-			return total;
-		},
-	};
-}
+/**
+ * The storage port behind the persisted state record.
+ *
+ * Kept as a port so the pure state logic is testable with no native module,
+ * and so MMKV stays confined to one file. This is internal — a consumer can
+ * reset or clear state, but can never read or write the record directly.
+ */
+
+export interface StateStore {
+	getString(key: string): string | undefined;
+	setString(key: string, value: string): void;
+	delete(key: string): void;
+	clearAll(): void;
+	/** Approximate on-disk size, for the health report. */
+	approximateBytes(): number;
+}
+
+/** In-memory store, used by tests and as the fallback when MMKV is unavailable. */
+export function createMemoryStore(): StateStore {
+	const map = new Map<string, string>();
+	return {
+		getString: key => map.get(key),
+		setString: (key, value) => {
+			map.set(key, value);
+		},
+		delete: key => {
+			map.delete(key);
+		},
+		clearAll: () => {
+			map.clear();
+		},
+		approximateBytes: () => {
+			let total = 0;
+			for (const [key, value] of map) {
+				total += key.length + value.length;
+			}
+			return total;
+		},
+	};
+}