@chipmobilesdk/rn-notification 0.4.0 → 0.4.1

package/src/reconcile/diff.ts

@@ -1,145 +1,142 @@
-/**
- * Desired-versus-device diffing.
- *
- * The package's central promise lives here: reconciling twice with unchanged
- * input must produce **zero** platform operations on the second run. That is
- * only true if "unchanged" is decided by comparing everything that would make
- * the delivered notification different — miss a field and the second run
- * rewrites entries needlessly; include a volatile one and it never settles.
- *
- * Anchoring mode is part of the comparison key deliberately. A mode change on
- * the same identifier must force a replacement rather than read as unchanged,
- * because the two modes resolve to different instants the moment a zone
- * changes.
- */
-
-import type { NotificationRequest, PendingEntry } from '../contract/notification';
-
-export type OperationKind = 'create' | 'replace' | 'cancel';
-
-export interface DiffOperation {
-	readonly kind: OperationKind;
-	readonly id: string;
-	/** Present for create and replace. */
-	readonly request?: NotificationRequest;
-	/** The instant the entry should fire, after anchoring resolution. */
-	readonly resolvedAt?: number;
-}
-
-export interface DiffResult {
-	readonly operations: readonly DiffOperation[];
-	readonly unchanged: readonly string[];
-}
-
-/** Stable serialization of the fields that make a delivered notification different. */
-function fingerprint(
-	request: NotificationRequest,
-	resolvedAt: number,
-): string {
-	return JSON.stringify([
-		resolvedAt,
-		request.moment.anchoring ?? 'wallClock',
-		request.content.title,
-		request.content.body,
-		request.content.subtitle ?? null,
-		request.tone,
-		request.ownerTag ?? null,
-		request.groupTag ?? null,
-		// Key order is not stable across constructions, so sort before comparing —
-		// otherwise two structurally identical payloads could compare unequal and
-		// the second pass would rewrite every entry carrying routing data.
-		request.routing === undefined ? null : stableStringify(request.routing),
-		request.actions === undefined
-			? null
-			: request.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null]),
-	]);
-}
-
-function entryFingerprint(entry: PendingEntry): string {
-	return JSON.stringify([
-		entry.resolvedAt,
-		entry.anchoring,
-		entry.content.title,
-		entry.content.body,
-		entry.content.subtitle ?? null,
-		entry.tone,
-		entry.ownerTag ?? null,
-		entry.groupTag ?? null,
-		entry.routing === undefined ? null : stableStringify(entry.routing),
-		entry.actions === undefined
-			? null
-			: entry.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null]),
-	]);
-}
-
-/** Key-order-independent JSON, so structurally equal payloads compare equal. */
-function stableStringify(value: unknown): string {
-	if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null';
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
-
-	const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>
-		a < b ? -1 : a > b ? 1 : 0,
-	);
-	return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
-}
-
-export interface DiffInput {
-	readonly desired: readonly NotificationRequest[];
-	/** Resolved firing instant per desired identifier, after anchoring. */
-	readonly resolvedAt: ReadonlyMap<string, number>;
-	/** What the device currently holds, already narrowed to the caller's domain. */
-	readonly device: readonly PendingEntry[];
-	/**
-	 * Identifiers that were rejected before diffing and must be left alone.
-	 *
-	 * Without this they would look like strays — present on the device, absent
-	 * from the desired set — and be cancelled. But a rejection is not a
-	 * cancellation: the package could not decide what the caller meant, so
-	 * destroying the existing notification would be the worst available answer.
-	 */
-	readonly protectedIds?: ReadonlySet<string>;
-}
-
-/**
- * Computes the minimal operation set.
- *
- * Cancels are emitted before creates so an interrupted pass leaves a
- * recoverable gap rather than a duplicate: a missing notification is fixed by
- * the next reconcile, whereas two notifications for one subject is a defect the
- * user sees.
- */
-export function diff(input: DiffInput): DiffResult {
-	const deviceById = new Map(input.device.map(entry => [entry.id, entry]));
-	const desiredIds = new Set(input.desired.map(request => request.id));
-
-	const cancels: DiffOperation[] = [];
-	const writes: DiffOperation[] = [];
-	const unchanged: string[] = [];
-
-	const protectedIds = input.protectedIds ?? new Set<string>();
-
-	for (const entry of input.device) {
-		if (!desiredIds.has(entry.id) && !protectedIds.has(entry.id)) {
-			cancels.push({ kind: 'cancel', id: entry.id });
-		}
-	}
-
-	for (const request of input.desired) {
-		const resolvedAt = input.resolvedAt.get(request.id) ?? request.moment.at;
-		const existing = deviceById.get(request.id);
-
-		if (existing === undefined) {
-			writes.push({ kind: 'create', id: request.id, request, resolvedAt });
-			continue;
-		}
-
-		if (fingerprint(request, resolvedAt) === entryFingerprint(existing)) {
-			unchanged.push(request.id);
-			continue;
-		}
-
-		writes.push({ kind: 'replace', id: request.id, request, resolvedAt });
-	}
-
-	return { operations: [...cancels, ...writes], unchanged };
-}
+/**
+ * Desired-versus-device diffing.
+ *
+ * The package's central promise lives here: reconciling twice with unchanged
+ * input must produce **zero** platform operations on the second run. That is
+ * only true if "unchanged" is decided by comparing everything that would make
+ * the delivered notification different — miss a field and the second run
+ * rewrites entries needlessly; include a volatile one and it never settles.
+ *
+ * Anchoring mode is part of the comparison key deliberately. A mode change on
+ * the same identifier must force a replacement rather than read as unchanged,
+ * because the two modes resolve to different instants the moment a zone
+ * changes.
+ */
+
+import type { NotificationRequest, PendingEntry } from '../contract/notification';
+
+export type OperationKind = 'create' | 'replace' | 'cancel';
+
+export interface DiffOperation {
+	readonly kind: OperationKind;
+	readonly id: string;
+	/** Present for create and replace. */
+	readonly request?: NotificationRequest;
+	/** The instant the entry should fire, after anchoring resolution. */
+	readonly resolvedAt?: number;
+}
+
+export interface DiffResult {
+	readonly operations: readonly DiffOperation[];
+	readonly unchanged: readonly string[];
+}
+
+/** Stable serialization of the fields that make a delivered notification different. */
+function fingerprint(request: NotificationRequest, resolvedAt: number): string {
+	return JSON.stringify([
+		resolvedAt,
+		request.moment.anchoring ?? 'wallClock',
+		request.content.title,
+		request.content.body,
+		request.content.subtitle ?? null,
+		request.tone,
+		request.ownerTag ?? null,
+		request.groupTag ?? null,
+		// Key order is not stable across constructions, so sort before comparing —
+		// otherwise two structurally identical payloads could compare unequal and
+		// the second pass would rewrite every entry carrying routing data.
+		request.routing === undefined ? null : stableStringify(request.routing),
+		request.actions === undefined
+			? null
+			: request.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null]),
+	]);
+}
+
+function entryFingerprint(entry: PendingEntry): string {
+	return JSON.stringify([
+		entry.resolvedAt,
+		entry.anchoring,
+		entry.content.title,
+		entry.content.body,
+		entry.content.subtitle ?? null,
+		entry.tone,
+		entry.ownerTag ?? null,
+		entry.groupTag ?? null,
+		entry.routing === undefined ? null : stableStringify(entry.routing),
+		entry.actions === undefined
+			? null
+			: entry.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null]),
+	]);
+}
+
+/** Key-order-independent JSON, so structurally equal payloads compare equal. */
+function stableStringify(value: unknown): string {
+	if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null';
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+
+	const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>
+		a < b ? -1 : a > b ? 1 : 0,
+	);
+	return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
+}
+
+export interface DiffInput {
+	readonly desired: readonly NotificationRequest[];
+	/** Resolved firing instant per desired identifier, after anchoring. */
+	readonly resolvedAt: ReadonlyMap<string, number>;
+	/** What the device currently holds, already narrowed to the caller's domain. */
+	readonly device: readonly PendingEntry[];
+	/**
+	 * Identifiers that were rejected before diffing and must be left alone.
+	 *
+	 * Without this they would look like strays — present on the device, absent
+	 * from the desired set — and be cancelled. But a rejection is not a
+	 * cancellation: the package could not decide what the caller meant, so
+	 * destroying the existing notification would be the worst available answer.
+	 */
+	readonly protectedIds?: ReadonlySet<string>;
+}
+
+/**
+ * Computes the minimal operation set.
+ *
+ * Cancels are emitted before creates so an interrupted pass leaves a
+ * recoverable gap rather than a duplicate: a missing notification is fixed by
+ * the next reconcile, whereas two notifications for one subject is a defect the
+ * user sees.
+ */
+export function diff(input: DiffInput): DiffResult {
+	const deviceById = new Map(input.device.map(entry => [entry.id, entry]));
+	const desiredIds = new Set(input.desired.map(request => request.id));
+
+	const cancels: DiffOperation[] = [];
+	const writes: DiffOperation[] = [];
+	const unchanged: string[] = [];
+
+	const protectedIds = input.protectedIds ?? new Set<string>();
+
+	for (const entry of input.device) {
+		if (!desiredIds.has(entry.id) && !protectedIds.has(entry.id)) {
+			cancels.push({ kind: 'cancel', id: entry.id });
+		}
+	}
+
+	for (const request of input.desired) {
+		const resolvedAt = input.resolvedAt.get(request.id) ?? request.moment.at;
+		const existing = deviceById.get(request.id);
+
+		if (existing === undefined) {
+			writes.push({ kind: 'create', id: request.id, request, resolvedAt });
+			continue;
+		}
+
+		if (fingerprint(request, resolvedAt) === entryFingerprint(existing)) {
+			unchanged.push(request.id);
+			continue;
+		}
+
+		writes.push({ kind: 'replace', id: request.id, request, resolvedAt });
+	}
+
+	return { operations: [...cancels, ...writes], unchanged };
+}

package/src/reconcile/duplicates.ts

@@ -1,73 +1,73 @@
-/**
- * Duplicate identifier resolution.
- *
- * An identifier appearing twice in one desired set means the caller's key
- * derivation produced two notifications for one identity. That is a bug, not a
- * preference, so the package refuses rather than silently picking a winner.
- *
- * **Every** copy is rejected — no entry wins. Order-independence then follows
- * for free rather than having to be engineered: there is no "first" or "last"
- * to depend on.
- *
- * The rule applies even to byte-identical duplicates. Treating those as
- * mergeable would require a deep-equality definition that becomes a contract of
- * its own, and a repeated identifier is a key-derivation bug either way.
- */
-
-import type { NotificationRequest } from '../contract/notification';
-import type { RejectedEntry } from '../contract/reconcile';
-import { DIAGNOSTIC_CODES } from '../contract/errors';
-
-export interface DuplicateSplit {
-	/** Entries whose identifier appeared exactly once. */
-	readonly unique: readonly NotificationRequest[];
-	/** One rejection record per repeated identifier, not per copy. */
-	readonly rejected: readonly RejectedEntry[];
-}
-
-/**
- * Splits a desired set into applicable entries and rejections.
- *
- * `existingIds` lets the rejection state whether a notification already
- * scheduled under that identifier was left in place — without it a caller could
- * reasonably read "rejected" as "cancelled".
- */
-export function splitDuplicates(
-	desired: readonly NotificationRequest[],
-	existingIds: ReadonlySet<string> = new Set(),
-): DuplicateSplit {
-	const counts = new Map<string, number>();
-	for (const request of desired) {
-		counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
-	}
-
-	const unique: NotificationRequest[] = [];
-	const rejected: RejectedEntry[] = [];
-
-	for (const request of desired) {
-		if ((counts.get(request.id) ?? 0) === 1) {
-			unique.push(request);
-		}
-	}
-
-	// Sorted so the report itself is order-independent, not merely its effect.
-	const repeated = [...counts.entries()]
-		.filter(([, count]) => count > 1)
-		.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-
-	for (const [id, occurrences] of repeated) {
-		rejected.push({
-			id,
-			code: DIAGNOSTIC_CODES.DUPLICATE_IDENTIFIER,
-			reason:
-				`Identifier appeared ${occurrences} times in one desired set. Every copy was rejected, because the package cannot know which was intended.` +
-				(existingIds.has(id)
-					? ' Any notification already scheduled under it was left in place — this is a rejection, not a cancellation.'
-					: ''),
-			occurrences,
-			existingLeftInPlace: existingIds.has(id),
-		});
-	}
-
-	return { unique, rejected };
-}
+/**
+ * Duplicate identifier resolution.
+ *
+ * An identifier appearing twice in one desired set means the caller's key
+ * derivation produced two notifications for one identity. That is a bug, not a
+ * preference, so the package refuses rather than silently picking a winner.
+ *
+ * **Every** copy is rejected — no entry wins. Order-independence then follows
+ * for free rather than having to be engineered: there is no "first" or "last"
+ * to depend on.
+ *
+ * The rule applies even to byte-identical duplicates. Treating those as
+ * mergeable would require a deep-equality definition that becomes a contract of
+ * its own, and a repeated identifier is a key-derivation bug either way.
+ */
+
+import type { NotificationRequest } from '../contract/notification';
+import type { RejectedEntry } from '../contract/reconcile';
+import { DIAGNOSTIC_CODES } from '../contract/errors';
+
+export interface DuplicateSplit {
+	/** Entries whose identifier appeared exactly once. */
+	readonly unique: readonly NotificationRequest[];
+	/** One rejection record per repeated identifier, not per copy. */
+	readonly rejected: readonly RejectedEntry[];
+}
+
+/**
+ * Splits a desired set into applicable entries and rejections.
+ *
+ * `existingIds` lets the rejection state whether a notification already
+ * scheduled under that identifier was left in place — without it a caller could
+ * reasonably read "rejected" as "cancelled".
+ */
+export function splitDuplicates(
+	desired: readonly NotificationRequest[],
+	existingIds: ReadonlySet<string> = new Set(),
+): DuplicateSplit {
+	const counts = new Map<string, number>();
+	for (const request of desired) {
+		counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
+	}
+
+	const unique: NotificationRequest[] = [];
+	const rejected: RejectedEntry[] = [];
+
+	for (const request of desired) {
+		if ((counts.get(request.id) ?? 0) === 1) {
+			unique.push(request);
+		}
+	}
+
+	// Sorted so the report itself is order-independent, not merely its effect.
+	const repeated = [...counts.entries()]
+		.filter(([, count]) => count > 1)
+		.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+
+	for (const [id, occurrences] of repeated) {
+		rejected.push({
+			id,
+			code: DIAGNOSTIC_CODES.DUPLICATE_IDENTIFIER,
+			reason:
+				`Identifier appeared ${occurrences} times in one desired set. Every copy was rejected, because the package cannot know which was intended.` +
+				(existingIds.has(id)
+					? ' Any notification already scheduled under it was left in place — this is a rejection, not a cancellation.'
+					: ''),
+			occurrences,
+			existingLeftInPlace: existingIds.has(id),
+		});
+	}
+
+	return { unique, rejected };
+}