@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/module/push/provider-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["push/provider-adapter.ts"],"mappings":"","ignoreList":[]}

package/lib/module/push/signout.js

@@ -0,0 +1,51 @@
+"use strict";
+
+/**
+ * Sign-out cleanup.
+ *
+ * Three things must happen together, and the order matters: invalidate the
+ * token first so no further messages arrive for the account being left, then
+ * cancel its notifications, then clear its persisted state.
+ *
+ * Deliberately **scoped to one owner tag**. On a shared device, signing one
+ * account out must not clear another's deduplication history or cancel their
+ * reminders — and must not discard the channel migration ledger, which
+ * describes the device rather than any account.
+ */
+
+import { clearOwner } from "../state/reset.js";
+export function createSignOut(deps) {
+  return {
+    async signOut(ownerTag) {
+      // Token first: stop the inbound flow before removing what would have
+      // handled it, so nothing arrives for an account that is already gone.
+      let tokenInvalidated = false;
+      if (deps.push !== undefined) {
+        try {
+          tokenInvalidated = await deps.push.invalidateToken();
+        } catch {
+          // A failed invalidation must not prevent local cleanup — leaving a
+          // signed-out account's notifications on the device is the worse of
+          // the two outcomes.
+          tokenInvalidated = false;
+        }
+      }
+      const cancelledIds = await deps.scheduler.cancelByOwner(ownerTag);
+      const {
+        clearedCollections
+      } = clearOwner(deps.state, ownerTag);
+      deps.emit?.('SIGN_OUT', `Signed out ${ownerTag}: token ${tokenInvalidated ? 'invalidated' : 'not invalidated'}, ${cancelledIds.length} notification(s) cancelled, per-owner state cleared.`, {
+        ownerTag,
+        tokenInvalidated,
+        cancelled: cancelledIds.length
+      });
+      return {
+        ownerTag,
+        tokenInvalidated,
+        cancelledIds,
+        clearedCollections
+      };
+    }
+  };
+}
+//# sourceMappingURL=signout.js.map

package/lib/module/push/signout.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["clearOwner","createSignOut","deps","signOut","ownerTag","tokenInvalidated","push","undefined","invalidateToken","cancelledIds","scheduler","cancelByOwner","clearedCollections","state","emit","length","cancelled"],"sourceRoot":"../../../src","sources":["push/signout.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA,SAASA,UAAU,QAAQ,mBAAgB;AAiB3C,OAAO,SAASC,aAAaA,CAACC,IAAyB,EAAE;EACxD,OAAO;IACN,MAAMC,OAAOA,CAACC,QAAgB,EAA0B;MACvD;MACA;MACA,IAAIC,gBAAgB,GAAG,KAAK;MAC5B,IAAIH,IAAI,CAACI,IAAI,KAAKC,SAAS,EAAE;QAC5B,IAAI;UACHF,gBAAgB,GAAG,MAAMH,IAAI,CAACI,IAAI,CAACE,eAAe,CAAC,CAAC;QACrD,CAAC,CAAC,MAAM;UACP;UACA;UACA;UACAH,gBAAgB,GAAG,KAAK;QACzB;MACD;MAEA,MAAMI,YAAY,GAAG,MAAMP,IAAI,CAACQ,SAAS,CAACC,aAAa,CAACP,QAAQ,CAAC;MACjE,MAAM;QAAEQ;MAAmB,CAAC,GAAGZ,UAAU,CAACE,IAAI,CAACW,KAAK,EAAET,QAAQ,CAAC;MAE/DF,IAAI,CAACY,IAAI,GACR,UAAU,EACV,cAAcV,QAAQ,WAAWC,gBAAgB,GAAG,aAAa,GAAG,iBAAiB,KAAKI,YAAY,CAACM,MAAM,sDAAsD,EACnK;QAAEX,QAAQ;QAAEC,gBAAgB;QAAEW,SAAS,EAAEP,YAAY,CAACM;MAAO,CAC9D,CAAC;MAED,OAAO;QAAEX,QAAQ;QAAEC,gBAAgB;QAAEI,YAAY;QAAEG;MAAmB,CAAC;IACxE;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/reconcile/chunk.js

@@ -0,0 +1,43 @@
+"use strict";
+
+/**
+ * Chunked application.
+ *
+ * A 500-entry reconciliation must not drop frames on a list screen, so work is
+ * applied in slices with a yield between them. No single slice may occupy the
+ * interface thread for more than 16 ms, which is what holds 60 fps while
+ * reconciliation is in flight.
+ */
+
+export const DEFAULT_CHUNK_SIZE = 25;
+
+/** Yields to the event loop so the interface thread can render between slices. */
+export function yieldToEventLoop() {
+  return new Promise(resolve => setTimeout(resolve, 0));
+}
+/**
+ * Applies `work` to every item, yielding between chunks.
+ *
+ * Sequential within a chunk rather than parallel: these calls bridge to native,
+ * and a burst of concurrent scheduling is where duplicate-delivery races come
+ * from.
+ */
+export async function applyInChunks(items, work, options = {}) {
+  const size = Math.max(1, options.size ?? DEFAULT_CHUNK_SIZE);
+  const yieldFn = options.onYield ?? yieldToEventLoop;
+  let applied = 0;
+  for (let start = 0; start < items.length; start += size) {
+    const chunk = items.slice(start, start + size);
+    for (const item of chunk) {
+      await work(item);
+      applied += 1;
+    }
+
+    // No yield after the final chunk — the caller is about to resume anyway.
+    if (start + size < items.length) {
+      await yieldFn();
+    }
+  }
+  return applied;
+}
+//# sourceMappingURL=chunk.js.map

package/lib/module/reconcile/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_CHUNK_SIZE","yieldToEventLoop","Promise","resolve","setTimeout","applyInChunks","items","work","options","size","Math","max","yieldFn","onYield","applied","start","length","chunk","slice","item"],"sourceRoot":"../../../src","sources":["reconcile/chunk.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,MAAMA,kBAAkB,GAAG,EAAE;;AAEpC;AACA,OAAO,SAASC,gBAAgBA,CAAA,EAAkB;EACjD,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIC,UAAU,CAACD,OAAO,EAAE,CAAC,CAAC,CAAC;AACtD;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeE,aAAaA,CAClCC,KAAmB,EACnBC,IAAgC,EAChCC,OAAqB,GAAG,CAAC,CAAC,EACR;EAClB,MAAMC,IAAI,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,OAAO,CAACC,IAAI,IAAIT,kBAAkB,CAAC;EAC5D,MAAMY,OAAO,GAAGJ,OAAO,CAACK,OAAO,IAAIZ,gBAAgB;EACnD,IAAIa,OAAO,GAAG,CAAC;EAEf,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGT,KAAK,CAACU,MAAM,EAAED,KAAK,IAAIN,IAAI,EAAE;IACxD,MAAMQ,KAAK,GAAGX,KAAK,CAACY,KAAK,CAACH,KAAK,EAAEA,KAAK,GAAGN,IAAI,CAAC;IAE9C,KAAK,MAAMU,IAAI,IAAIF,KAAK,EAAE;MACzB,MAAMV,IAAI,CAACY,IAAI,CAAC;MAChBL,OAAO,IAAI,CAAC;IACb;;IAEA;IACA,IAAIC,KAAK,GAAGN,IAAI,GAAGH,KAAK,CAACU,MAAM,EAAE;MAChC,MAAMJ,OAAO,CAAC,CAAC;IAChB;EACD;EAEA,OAAOE,OAAO;AACf","ignoreList":[]}

package/lib/module/reconcile/diff.js

@@ -0,0 +1,101 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+/** The fields that make one delivered notification different from another. */
+
+/**
+ * Stable serialization of those fields. One function for what the app wants and
+ * what the device holds, so the two cannot drift into comparing different
+ * things (NOT-19).
+ */
+function fingerprintFields(fields) {
+  return JSON.stringify([fields.resolvedAt, fields.anchoring, fields.content.title, fields.content.body, fields.content.subtitle ?? null, fields.tone, fields.ownerTag ?? null, fields.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.
+  fields.routing === undefined ? null : stableStringify(fields.routing), fields.actions === undefined ? null : fields.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null])]);
+}
+function fingerprint(request, resolvedAt) {
+  return fingerprintFields({
+    ...request,
+    resolvedAt,
+    anchoring: request.moment.anchoring ?? 'wallClock'
+  });
+}
+function entryFingerprint(entry) {
+  return fingerprintFields(entry);
+}
+
+/** Key-order-independent JSON, so structurally equal payloads compare equal. */
+function stableStringify(value) {
+  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).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
+}
+/**
+ * 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) {
+  const deviceById = new Map(input.device.map(entry => [entry.id, entry]));
+  const desiredIds = new Set(input.desired.map(request => request.id));
+  const cancels = [];
+  const writes = [];
+  const unchanged = [];
+  const protectedIds = input.protectedIds ?? new Set();
+  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
+  };
+}
+//# sourceMappingURL=diff.js.map

package/lib/module/reconcile/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fingerprintFields","fields","JSON","stringify","resolvedAt","anchoring","content","title","body","subtitle","tone","ownerTag","groupTag","routing","undefined","stableStringify","actions","map","a","id","mode","input","placeholder","fingerprint","request","moment","entryFingerprint","entry","value","Array","isArray","join","entries","Object","sort","b","k","v","diff","deviceById","Map","device","desiredIds","Set","desired","cancels","writes","unchanged","protectedIds","has","push","kind","get","at","existing","operations"],"sourceRoot":"../../../src","sources":["reconcile/diff.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/reconcile/duplicates.js

@@ -0,0 +1,56 @@
+"use strict";
+
+/**
+ * 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 { DIAGNOSTIC_CODES } from "../contract/errors.js";
+/**
+ * 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, existingIds = new Set()) {
+  const counts = new Map();
+  for (const request of desired) {
+    counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
+  }
+  const unique = [];
+  const rejected = [];
+  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
+  };
+}
+//# sourceMappingURL=duplicates.js.map

package/lib/module/reconcile/duplicates.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DIAGNOSTIC_CODES","splitDuplicates","desired","existingIds","Set","counts","Map","request","set","id","get","unique","rejected","push","repeated","entries","filter","count","sort","a","b","occurrences","code","DUPLICATE_IDENTIFIER","reason","has","existingLeftInPlace"],"sourceRoot":"../../../src","sources":["reconcile/duplicates.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAASA,gBAAgB,QAAQ,uBAAoB;AASrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAC9BC,OAAuC,EACvCC,WAAgC,GAAG,IAAIC,GAAG,CAAC,CAAC,EAC3B;EACjB,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAAiB,CAAC;EACxC,KAAK,MAAMC,OAAO,IAAIL,OAAO,EAAE;IAC9BG,MAAM,CAACG,GAAG,CAACD,OAAO,CAACE,EAAE,EAAE,CAACJ,MAAM,CAACK,GAAG,CAACH,OAAO,CAACE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;EAC1D;EAEA,MAAME,MAA6B,GAAG,EAAE;EACxC,MAAMC,QAAyB,GAAG,EAAE;EAEpC,KAAK,MAAML,OAAO,IAAIL,OAAO,EAAE;IAC9B,IAAI,CAACG,MAAM,CAACK,GAAG,CAACH,OAAO,CAACE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;MACxCE,MAAM,CAACE,IAAI,CAACN,OAAO,CAAC;IACrB;EACD;;EAEA;EACA,MAAMO,QAAQ,GAAG,CAAC,GAAGT,MAAM,CAACU,OAAO,CAAC,CAAC,CAAC,CACpCC,MAAM,CAAC,CAAC,GAAGC,KAAK,CAAC,KAAKA,KAAK,GAAG,CAAC,CAAC,CAChCC,IAAI,CAAC,CAAC,CAACC,CAAC,CAAC,EAAE,CAACC,CAAC,CAAC,KAAMD,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;EAElD,KAAK,MAAM,CAACX,EAAE,EAAEY,WAAW,CAAC,IAAIP,QAAQ,EAAE;IACzCF,QAAQ,CAACC,IAAI,CAAC;MACbJ,EAAE;MACFa,IAAI,EAAEtB,gBAAgB,CAACuB,oBAAoB;MAC3CC,MAAM,EACL,uBAAuBH,WAAW,yGAAyG,IAC1IlB,WAAW,CAACsB,GAAG,CAAChB,EAAE,CAAC,GACjB,2GAA2G,GAC3G,EAAE,CAAC;MACPY,WAAW;MACXK,mBAAmB,EAAEvB,WAAW,CAACsB,GAAG,CAAChB,EAAE;IACxC,CAAC,CAAC;EACH;EAEA,OAAO;IAAEE,MAAM;IAAEC;EAAS,CAAC;AAC5B","ignoreList":[]}

package/lib/module/reconcile/index.js

@@ -0,0 +1,161 @@
+"use strict";
+
+/**
+ * The reconciliation operation.
+ *
+ * A caller hands over the complete set its data implies; the package works out
+ * what to add, replace, and remove. This is **never** run automatically — only
+ * the caller knows what its data implies, and a package that guessed a desired
+ * set would cancel notifications it does not understand.
+ *
+ * Overlapping calls are serialized rather than run concurrently, because two
+ * passes interleaving their cancels and creates is exactly how duplicates
+ * appear.
+ */
+
+import { DIAGNOSTIC_CODES } from "../contract/errors.js";
+import { anchorMoment } from "../schedule/anchor.js";
+import { resolveMoment } from "../schedule/resolve-moment.js";
+import { validateRequest } from "../schedule/index.js";
+import { isNotificationError } from "../contract/errors.js";
+import { splitDuplicates } from "./duplicates.js";
+import { truncateToCeiling } from "./truncate.js";
+import { createScheduleWriter } from "../schedule/writer.js";
+import { diff } from "./diff.js";
+import { applyInChunks } from "./chunk.js";
+/**
+ * Narrows the device set to the caller's declared domain.
+ *
+ * Everything outside it is invisible to this pass, which is what makes it safe
+ * to cancel strays: a notification from another domain or another library is
+ * never a stray, it simply is not ours.
+ */
+function inDomain(entry, input) {
+  if (entry.pushCreated && input.includePushCreated !== true) return false;
+  return entry.groupTag === input.domain;
+}
+export function createReconciler(deps) {
+  const emit = deps.emit ?? (() => {});
+  const writer = createScheduleWriter(deps.engine);
+  let inFlight = Promise.resolve();
+  const run = async input => {
+    const startedAt = deps.now();
+    const zone = deps.timeZone();
+    const everything = await deps.engine.getPending();
+    const device = everything.filter(entry => inDomain(entry, input));
+    // The ceiling is the platform's, shared with every other domain, every
+    // recurring series and every directly scheduled notification. Budgeting a
+    // domain against the whole of it let two domains and a series overflow iOS's
+    // 64 together while each reported "nothing truncated" (NOT-11).
+    const heldElsewhere = everything.length - device.length;
+    const existingIds = new Set(device.map(entry => entry.id));
+
+    // Duplicates first: a repeated identifier is refused before anything else
+    // looks at it, so no later stage has to decide which copy it meant.
+    const {
+      unique,
+      rejected: duplicateRejections
+    } = splitDuplicates(input.desired, existingIds);
+    const rejected = [...duplicateRejections];
+
+    // Validate and anchor. A rejection here removes one entry; it never fails
+    // the pass, because 499 valid entries should not be lost to one bad one.
+    const valid = [];
+    const resolvedAt = new Map();
+    for (const request of unique) {
+      try {
+        validateRequest(request, deps.resolveTone);
+        const anchored = anchorMoment(request.moment, zone);
+        const resolution = resolveMoment(anchored.resolvedAt, deps.now());
+        resolvedAt.set(request.id, resolution.at);
+        valid.push(request);
+      } catch (error) {
+        rejected.push({
+          id: request.id,
+          code: isNotificationError(error) ? error.code : 'UNKNOWN',
+          reason: error instanceof Error ? error.message : String(error),
+          occurrences: 1,
+          existingLeftInPlace: existingIds.has(request.id)
+        });
+      }
+    }
+
+    // Stop markers occupy real platform capacity, so the ceiling a consumer's
+    // notifications can actually use is smaller than the platform's own.
+    // Hiding that would let the package quietly reduce how many notifications
+    // fit and report a full set as registered when it was not.
+    // One pass: the outstanding stop markers are read once for the capacity and
+    // every operation below, not once per operation (NOT-08).
+    const pass = writer.pass();
+    const {
+      kept,
+      report: truncation
+    } = truncateToCeiling(valid, resolvedAt, Math.max(0, (await pass.capacity()) - heldElsewhere));
+    if (truncation !== undefined) {
+      emit(DIAGNOSTIC_CODES.TRUNCATED_OVER_CEILING, `Desired set exceeded the platform ceiling of ${truncation.ceiling}; ${truncation.droppedCount} furthest-out entries were not registered. They are re-evaluated at the next window refresh.`, {
+        ceiling: truncation.ceiling,
+        dropped: truncation.droppedCount
+      });
+    }
+
+    // Every rejected identifier is protected from cancellation. A rejection
+    // means the package could not tell what the caller intended, and
+    // destroying the existing notification on that basis would be the worst
+    // available answer (FR-028c).
+    const {
+      operations,
+      unchanged
+    } = diff({
+      desired: kept,
+      resolvedAt,
+      device,
+      protectedIds: new Set(rejected.map(entry => entry.id))
+    });
+    const created = [];
+    const replaced = [];
+    const cancelled = [];
+    const approximate = !deps.canScheduleExactly();
+    await applyInChunks(operations, async operation => {
+      if (operation.kind === 'cancel') {
+        await pass.cancel(operation.id);
+        cancelled.push(operation.id);
+        return;
+      }
+      const request = operation.request;
+      const tone = deps.resolveTone(request.tone);
+      await pass.write({
+        request,
+        resolvedAt: operation.resolvedAt,
+        tone,
+        anchoringGeneration: (request.moment.anchoring ?? 'wallClock') === 'absolute' ? undefined : zone,
+        approximate
+      });
+      (operation.kind === 'create' ? created : replaced).push(operation.id);
+    }, {
+      size: deps.chunkSize
+    });
+    return {
+      domain: input.domain,
+      created,
+      replaced,
+      cancelled,
+      unchanged,
+      rejected,
+      truncated: truncation,
+      operationCount: operations.length,
+      durationMs: deps.now() - startedAt
+    };
+  };
+  return {
+    /**
+     * Serialized against itself: a second call waits for the first rather than
+     * interleaving with it.
+     */
+    async reconcile(input) {
+      const next = inFlight.then(() => run(input), () => run(input));
+      inFlight = next.catch(() => undefined);
+      return next;
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/lib/module/reconcile/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DIAGNOSTIC_CODES","anchorMoment","resolveMoment","validateRequest","isNotificationError","splitDuplicates","truncateToCeiling","createScheduleWriter","diff","applyInChunks","inDomain","entry","input","pushCreated","includePushCreated","groupTag","domain","createReconciler","deps","emit","writer","engine","inFlight","Promise","resolve","run","startedAt","now","zone","timeZone","everything","getPending","device","filter","heldElsewhere","length","existingIds","Set","map","id","unique","rejected","duplicateRejections","desired","valid","resolvedAt","Map","request","resolveTone","anchored","moment","resolution","set","at","push","error","code","reason","Error","message","String","occurrences","existingLeftInPlace","has","pass","kept","report","truncation","Math","max","capacity","undefined","TRUNCATED_OVER_CEILING","ceiling","droppedCount","dropped","operations","unchanged","protectedIds","created","replaced","cancelled","approximate","canScheduleExactly","operation","kind","cancel","tone","write","anchoringGeneration","anchoring","size","chunkSize","truncated","operationCount","durationMs","reconcile","next","then","catch"],"sourceRoot":"../../../src","sources":["reconcile/index.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/reconcile/truncate.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * Platform-ceiling truncation.
+ *
+ * iOS keeps only the 64 soonest pending notifications and silently discards the
+ * rest. The package computes the same cut deliberately, so the outcome is
+ * reported rather than discovered as missing notifications.
+ *
+ * Soonest-first is the only rule that degrades gracefully: dropped entries are
+ * not lost, they are simply not yet registered, and each window refresh
+ * registers those that have moved into range.
+ */
+
+/**
+ * Keeps the `ceiling` soonest entries.
+ *
+ * Ties on the delivery instant are broken by identifier so the cut is
+ * deterministic — otherwise two runs over the same data could drop different
+ * entries and the idempotence guarantee would not hold.
+ */
+export function truncateToCeiling(desired, resolvedAt, ceiling) {
+  if (desired.length <= ceiling) {
+    return {
+      kept: desired
+    };
+  }
+  const ordered = [...desired].sort((a, b) => {
+    const aAt = resolvedAt.get(a.id) ?? a.moment.at;
+    const bAt = resolvedAt.get(b.id) ?? b.moment.at;
+    if (aAt !== bAt) return aAt - bAt;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  const kept = ordered.slice(0, ceiling);
+  const dropped = ordered.slice(ceiling);
+  return {
+    kept,
+    report: {
+      ceiling,
+      droppedCount: dropped.length,
+      droppedIds: dropped.map(entry => entry.id),
+      reEvaluatedOnNextRefresh: true
+    }
+  };
+}
+//# sourceMappingURL=truncate.js.map

package/lib/module/reconcile/truncate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["truncateToCeiling","desired","resolvedAt","ceiling","length","kept","ordered","sort","a","b","aAt","get","id","moment","at","bAt","slice","dropped","report","droppedCount","droppedIds","map","entry","reEvaluatedOnNextRefresh"],"sourceRoot":"../../../src","sources":["reconcile/truncate.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,iBAAiBA,CAChCC,OAAuC,EACvCC,UAAuC,EACvCC,OAAe,EACK;EACpB,IAAIF,OAAO,CAACG,MAAM,IAAID,OAAO,EAAE;IAC9B,OAAO;MAAEE,IAAI,EAAEJ;IAAQ,CAAC;EACzB;EAEA,MAAMK,OAAO,GAAG,CAAC,GAAGL,OAAO,CAAC,CAACM,IAAI,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAK;IAC3C,MAAMC,GAAG,GAAGR,UAAU,CAACS,GAAG,CAACH,CAAC,CAACI,EAAE,CAAC,IAAIJ,CAAC,CAACK,MAAM,CAACC,EAAE;IAC/C,MAAMC,GAAG,GAAGb,UAAU,CAACS,GAAG,CAACF,CAAC,CAACG,EAAE,CAAC,IAAIH,CAAC,CAACI,MAAM,CAACC,EAAE;IAC/C,IAAIJ,GAAG,KAAKK,GAAG,EAAE,OAAOL,GAAG,GAAGK,GAAG;IACjC,OAAOP,CAAC,CAACI,EAAE,GAAGH,CAAC,CAACG,EAAE,GAAG,CAAC,CAAC,GAAGJ,CAAC,CAACI,EAAE,GAAGH,CAAC,CAACG,EAAE,GAAG,CAAC,GAAG,CAAC;EAC9C,CAAC,CAAC;EAEF,MAAMP,IAAI,GAAGC,OAAO,CAACU,KAAK,CAAC,CAAC,EAAEb,OAAO,CAAC;EACtC,MAAMc,OAAO,GAAGX,OAAO,CAACU,KAAK,CAACb,OAAO,CAAC;EAEtC,OAAO;IACNE,IAAI;IACJa,MAAM,EAAE;MACPf,OAAO;MACPgB,YAAY,EAAEF,OAAO,CAACb,MAAM;MAC5BgB,UAAU,EAAEH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAIA,KAAK,CAACV,EAAE,CAAC;MAC1CW,wBAAwB,EAAE;IAC3B;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/recurrence/clock-guard.js

@@ -0,0 +1,60 @@
+"use strict";
+
+/**
+ * Clock-discontinuity bounding.
+ *
+ * A device clock moved backwards makes past occurrences look future again. Left
+ * alone, the next expansion would re-register every occurrence the user already
+ * received, and moving the clock forward again would fire them all at once.
+ *
+ * The guard is deliberately blunt: occurrences at or before the last horizon the
+ * series already expanded through are never re-emitted. The package would
+ * rather lose an occurrence after a manual clock change than deliver a burst of
+ * notifications for events that already happened.
+ */
+
+/** A jump larger than this is treated as a clock change rather than ordinary drift. */
+export const CLOCK_DISCONTINUITY_THRESHOLD_MS = 60 * 60 * 1000;
+/**
+ * Drops occurrences that a clock discontinuity would otherwise resurrect.
+ *
+ * Forward jumps are detected and reported but not filtered: an occurrence that
+ * became due because time genuinely passed is legitimate, and the platform's
+ * own delivery is the right place for it to be resolved.
+ */
+export function guardAgainstClockChange(input) {
+  const {
+    occurrences,
+    previousHorizon,
+    now,
+    previousNow
+  } = input;
+  let discontinuity = 'none';
+  if (previousNow !== undefined) {
+    const delta = now - previousNow;
+    if (delta < -CLOCK_DISCONTINUITY_THRESHOLD_MS) {
+      discontinuity = 'backwards';
+    } else if (delta > CLOCK_DISCONTINUITY_THRESHOLD_MS * 24) {
+      discontinuity = 'forwards';
+    }
+  }
+  if (previousHorizon === undefined) {
+    return {
+      occurrences,
+      suppressed: 0,
+      discontinuity
+    };
+  }
+
+  // Anything at or before the previously-expanded horizon was already handled
+  // once. Re-emitting it would mean delivering a notification for an event the
+  // user has already seen.
+  const kept = occurrences.filter(occurrence => occurrence.at > previousHorizon || occurrence.at > now);
+  const alreadyHandled = occurrences.filter(occurrence => occurrence.at <= previousHorizon && occurrence.at <= now);
+  return {
+    occurrences: kept,
+    suppressed: alreadyHandled.length,
+    discontinuity
+  };
+}
+//# sourceMappingURL=clock-guard.js.map

package/lib/module/recurrence/clock-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CLOCK_DISCONTINUITY_THRESHOLD_MS","guardAgainstClockChange","input","occurrences","previousHorizon","now","previousNow","discontinuity","undefined","delta","suppressed","kept","filter","occurrence","at","alreadyHandled","length"],"sourceRoot":"../../../src","sources":["recurrence/clock-guard.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA,OAAO,MAAMA,gCAAgC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI;AAiB9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,uBAAuBA,CAACC,KAAsB,EAAoB;EACjF,MAAM;IAAEC,WAAW;IAAEC,eAAe;IAAEC,GAAG;IAAEC;EAAY,CAAC,GAAGJ,KAAK;EAEhE,IAAIK,aAAgD,GAAG,MAAM;EAC7D,IAAID,WAAW,KAAKE,SAAS,EAAE;IAC9B,MAAMC,KAAK,GAAGJ,GAAG,GAAGC,WAAW;IAC/B,IAAIG,KAAK,GAAG,CAACT,gCAAgC,EAAE;MAC9CO,aAAa,GAAG,WAAW;IAC5B,CAAC,MAAM,IAAIE,KAAK,GAAGT,gCAAgC,GAAG,EAAE,EAAE;MACzDO,aAAa,GAAG,UAAU;IAC3B;EACD;EAEA,IAAIH,eAAe,KAAKI,SAAS,EAAE;IAClC,OAAO;MAAEL,WAAW;MAAEO,UAAU,EAAE,CAAC;MAAEH;IAAc,CAAC;EACrD;;EAEA;EACA;EACA;EACA,MAAMI,IAAI,GAAGR,WAAW,CAACS,MAAM,CAC9BC,UAAU,IAAIA,UAAU,CAACC,EAAE,GAAGV,eAAe,IAAIS,UAAU,CAACC,EAAE,GAAGT,GAClE,CAAC;EACD,MAAMU,cAAc,GAAGZ,WAAW,CAACS,MAAM,CACxCC,UAAU,IAAIA,UAAU,CAACC,EAAE,IAAIV,eAAe,IAAIS,UAAU,CAACC,EAAE,IAAIT,GACpE,CAAC;EAED,OAAO;IACNF,WAAW,EAAEQ,IAAI;IACjBD,UAAU,EAAEK,cAAc,CAACC,MAAM;IACjCT;EACD,CAAC;AACF","ignoreList":[]}