@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/commonjs/recurrence/index.js

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRecurrence = createRecurrence;
+var _anchor = require("../schedule/anchor.js");
+var _validateIdentifier = require("../schedule/validate-identifier.js");
+var _index = require("../schedule/index.js");
+var _writer = require("../schedule/writer.js");
+var _errors = require("../contract/errors.js");
+var _expand = require("./expand.js");
+var _clockGuard = require("./clock-guard.js");
+var _seriesLedger = require("../state/series-ledger.js");
+/**
+ * Series registration and the lookahead window.
+ *
+ * A caller declares a rule once. The package expands it inside a finite window
+ * and refreshes that window on its own, because only it knows when the horizon
+ * has moved — that is the one piece of recurrence knowledge the consumer does
+ * not have.
+ *
+ * Occurrences carry derived identifiers, so re-expanding a series recognises
+ * what it already scheduled instead of creating duplicates. That is what makes
+ * a window refresh with nothing to do cost zero platform operations.
+ *
+ * Occurrences are written through the shared `ScheduleWriter`, like every other
+ * consumer notification, so a repeating tone gets its stop marker and the
+ * platform ceiling is respected here too.
+ */
+
+/** Builds the request for one occurrence from the series template. */
+function toRequest(rule, occurrence) {
+  return {
+    id: occurrence.id,
+    content: rule.template.content,
+    tone: rule.template.tone,
+    moment: {
+      at: occurrence.at,
+      anchoring: occurrence.anchoring
+    },
+    routing: rule.template.routing,
+    actions: rule.template.actions,
+    ownerTag: rule.template.ownerTag,
+    groupTag: rule.template.groupTag
+  };
+}
+const belongsTo = (entry, seriesId) => entry.seriesId === seriesId || entry.id.startsWith(`${seriesId}#`);
+
+/**
+ * The latest occurrence a ledger entry written before 0.4.0 had emitted. Those
+ * entries kept no key, so it is read back off the device: the last occurrence
+ * still pending is the last one emitted.
+ */
+function recoverLastEmittedKey(pending, anchoring, zone) {
+  if (pending.length === 0) return undefined;
+  const latest = Math.max(...pending.map(entry => entry.resolvedAt));
+  return (0, _expand.occurrenceKey)((0, _anchor.partsInZone)(latest, anchoring === 'absolute' ? 'UTC' : zone));
+}
+function createRecurrence(deps) {
+  const emit = deps.emit ?? (() => {});
+  const writer = (0, _writer.createScheduleWriter)(deps.engine);
+
+  /**
+   * Validates the template as the request every occurrence will be, once, so
+   * a series is refused at registration for exactly what a direct schedule
+   * would be refused for — an undeclared tone, too many actions, an oversized
+   * routing payload — rather than failing later inside maintenance.
+   */
+  const validateTemplate = rule => (0, _index.validateRequest)({
+    id: rule.id,
+    content: rule.template.content,
+    tone: rule.template.tone,
+    moment: {
+      at: deps.now(),
+      anchoring: rule.anchoring ?? 'wallClock'
+    },
+    routing: rule.template.routing,
+    actions: rule.template.actions,
+    ownerTag: rule.template.ownerTag,
+    groupTag: rule.template.groupTag
+  }, deps.resolveTone);
+  const toneFor = rule => {
+    const tone = deps.resolveTone(rule.template.tone);
+    if (tone === undefined) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.UNDECLARED_TONE, `Tone "${rule.template.tone}" was never declared in the package configuration.`, {
+        toneId: rule.template.tone,
+        seriesId: rule.id
+      });
+    }
+    return tone;
+  };
+
+  /** Expands and registers, scheduling only occurrences the device lacks. */
+  const materialize = async (rule, tone) => {
+    const now = deps.now();
+    const zone = deps.timeZone();
+    const previous = (0, _seriesLedger.readSeries)(deps.state, rule.id);
+    const pending = await deps.engine.getPending();
+    const ofSeries = pending.filter(entry => belongsTo(entry, rule.id));
+    const expansion = (0, _expand.expand)({
+      rule,
+      from: now,
+      lookahead: deps.lookahead,
+      timeZone: zone,
+      alreadyEmitted: previous?.emittedCount ?? 0,
+      lastEmittedKey: previous?.lastEmittedKey ?? (previous !== undefined ? recoverLastEmittedKey(ofSeries, rule.anchoring, zone) : undefined)
+    });
+    const guarded = (0, _clockGuard.guardAgainstClockChange)({
+      occurrences: expansion.occurrences,
+      previousHorizon: previous?.expandedThrough,
+      now,
+      previousNow: previous?.at
+    });
+    if (guarded.discontinuity !== 'none') {
+      emit('CLOCK_DISCONTINUITY', `Device clock moved ${guarded.discontinuity}; ${guarded.suppressed} already-handled occurrence(s) were suppressed rather than re-delivered.`, {
+        direction: guarded.discontinuity,
+        suppressed: guarded.suppressed,
+        seriesId: rule.id
+      });
+    }
+    const wanted = new Set(guarded.occurrences.map(occurrence => occurrence.id));
+
+    // Upcoming entries of this series the expansion no longer produces: ones
+    // written under the instant-based identity before 0.4.0, or ones whose slot
+    // the rule no longer has. Left in place, each would fire beside its
+    // replacement. Entries already due are left alone — they may be firing now.
+    const stale = ofSeries.filter(entry => !wanted.has(entry.id) && entry.resolvedAt > now);
+    for (const entry of stale) {
+      await writer.cancel(entry.id);
+    }
+    const onDevice = new Set(ofSeries.filter(entry => !stale.includes(entry)).map(entry => entry.id));
+    const missing = guarded.occurrences.filter(occurrence => !onDevice.has(occurrence.id));
+
+    // The same ceiling reconciliation respects: soonest first, the rest
+    // registered by a later refresh once they move into range.
+    const room = Math.max(0, (await writer.capacity()) - (pending.length - stale.length));
+    const toSchedule = missing.slice(0, room);
+    if (toSchedule.length < missing.length) {
+      emit(_errors.DIAGNOSTIC_CODES.TRUNCATED_OVER_CEILING, `Series "${rule.id}" has ${missing.length - toSchedule.length} occurrence(s) beyond the platform ceiling; they are registered by a later window refresh.`, {
+        seriesId: rule.id,
+        dropped: missing.length - toSchedule.length
+      });
+    }
+    const approximate = !deps.canScheduleExactly();
+    for (const occurrence of toSchedule) {
+      await writer.write({
+        request: toRequest(rule, occurrence),
+        resolvedAt: occurrence.at,
+        tone,
+        // The zone the series was expanded against; absent for absolute series.
+        anchoringGeneration: occurrence.anchoring === 'absolute' ? undefined : zone,
+        approximate,
+        seriesId: rule.id
+      });
+    }
+
+    // Counted once, when first emitted — whether or not the ceiling let it on
+    // the device yet. Occurrences re-produced from an earlier expansion are not
+    // counted again.
+    const newlyEmitted = guarded.occurrences.filter(occurrence => !occurrence.previouslyEmitted);
+    const lastEmittedKey = newlyEmitted.length > 0 ? newlyEmitted[newlyEmitted.length - 1].key : previous?.lastEmittedKey;
+    (0, _seriesLedger.upsertSeries)(deps.state, rule, {
+      expandedThrough: expansion.expandedThrough,
+      emittedCount: (previous?.emittedCount ?? 0) + newlyEmitted.length,
+      exhausted: expansion.exhausted,
+      lastEmittedKey
+    }, now);
+    return {
+      seriesId: rule.id,
+      scheduled: toSchedule.length,
+      expandedThrough: expansion.expandedThrough,
+      exhausted: expansion.exhausted,
+      cancelled: stale.map(entry => entry.id)
+    };
+  };
+  return {
+    async registerSeries(rule) {
+      (0, _validateIdentifier.validateIdentifier)(rule.id, 'seriesId');
+      return materialize(rule, validateTemplate(rule));
+    },
+    /** Re-expands a tracked series. Called by the window-refresh maintenance step. */
+    async refreshSeries(rule) {
+      return materialize(rule, toneFor(rule));
+    },
+    async cancelSeries(seriesId) {
+      (0, _validateIdentifier.validateIdentifier)(seriesId, 'seriesId');
+
+      // Every occurrence already scheduled from this series goes, identified by
+      // its derived prefix rather than by a list the ledger would have to keep
+      // in sync with the device.
+      const pending = await deps.engine.getPending();
+      const ids = pending.filter(entry => belongsTo(entry, seriesId)).map(entry => entry.id);
+      await deps.engine.cancelMany(ids);
+      const pass = writer.pass();
+      for (const id of ids) await pass.releaseStop(id);
+      (0, _seriesLedger.removeSeries)(deps.state, seriesId);
+      return ids;
+    },
+    async listSeries() {
+      const pending = await deps.engine.getPending();
+      return (0, _seriesLedger.listSeries)(deps.state).map(entry => ({
+        seriesId: entry.seriesId,
+        anchoring: entry.anchoring,
+        expandedThrough: entry.expandedThrough,
+        pendingOccurrences: pending.filter(p => belongsTo(p, entry.seriesId)).length,
+        exhausted: entry.exhausted
+      }));
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/recurrence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_anchor","require","_validateIdentifier","_index","_writer","_errors","_expand","_clockGuard","_seriesLedger","toRequest","rule","occurrence","id","content","template","tone","moment","at","anchoring","routing","actions","ownerTag","groupTag","belongsTo","entry","seriesId","startsWith","recoverLastEmittedKey","pending","zone","length","undefined","latest","Math","max","map","resolvedAt","occurrenceKey","partsInZone","createRecurrence","deps","emit","writer","createScheduleWriter","engine","validateTemplate","validateRequest","now","resolveTone","toneFor","NotificationError","DIAGNOSTIC_CODES","UNDECLARED_TONE","toneId","materialize","timeZone","previous","readSeries","state","getPending","ofSeries","filter","expansion","expand","from","lookahead","alreadyEmitted","emittedCount","lastEmittedKey","guarded","guardAgainstClockChange","occurrences","previousHorizon","expandedThrough","previousNow","discontinuity","suppressed","direction","wanted","Set","stale","has","cancel","onDevice","includes","missing","room","capacity","toSchedule","slice","TRUNCATED_OVER_CEILING","dropped","approximate","canScheduleExactly","write","request","anchoringGeneration","newlyEmitted","previouslyEmitted","key","upsertSeries","exhausted","scheduled","cancelled","registerSeries","validateIdentifier","refreshSeries","cancelSeries","ids","cancelMany","pass","releaseStop","removeSeries","listSeries","readLedger","pendingOccurrences","p"],"sourceRoot":"../../../src","sources":["recurrence/index.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/repeat/expiry.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRepeatExpiryHandler = createRepeatExpiryHandler;
+var _place = require("./place.js");
+/**
+ * Repeat expiry.
+ *
+ * When a stop marker is delivered, the alert it guards has run its declared
+ * course. This handler ends the sound and leaves the notification exactly where
+ * it is, then removes the marker.
+ *
+ * Nothing here imports the engine. It talks to the port, which is what lets the
+ * whole mechanism be proven on a virtual clock with no device.
+ */
+
+function createRepeatExpiryHandler(deps) {
+  return {
+    async handle(event) {
+      const stop = event.repeatStop;
+      if (stop === undefined) return;
+
+      // Order matters. Silence first, remove the marker second: if the
+      // process dies between the two, a marker left behind is harmless
+      // noise, whereas a device left sounding is the failure this exists to
+      // prevent.
+      //
+      // `silenceDelivered` returning false is the ordinary case, not an
+      // error — it means the user already handled the notification. Checking
+      // the tray rather than racing to cancel the marker on interaction is
+      // what makes early handling correct by construction: even if the marker
+      // fires, there is nothing left to act on.
+      await deps.engine.silenceDelivered(stop.targetId);
+      await deps.engine.cancel(stop.markerId);
+    },
+    release: targetId => (0, _place.createStopPlacement)(deps.engine).release(targetId)
+  };
+}
+//# sourceMappingURL=expiry.js.map

package/lib/commonjs/repeat/expiry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_place","require","createRepeatExpiryHandler","deps","handle","event","stop","repeatStop","undefined","engine","silenceDelivered","targetId","cancel","markerId","release","createStopPlacement"],"sourceRoot":"../../../src","sources":["repeat/expiry.ts"],"mappings":";;;;;;AAYA,IAAAA,MAAA,GAAAC,OAAA;AAZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAiBO,SAASC,yBAAyBA,CAACC,IAA8B,EAAuB;EAC9F,OAAO;IACN,MAAMC,MAAMA,CAACC,KAAoB,EAAiB;MACjD,MAAMC,IAAI,GAAGD,KAAK,CAACE,UAAU;MAC7B,IAAID,IAAI,KAAKE,SAAS,EAAE;;MAExB;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,MAAML,IAAI,CAACM,MAAM,CAACC,gBAAgB,CAACJ,IAAI,CAACK,QAAQ,CAAC;MACjD,MAAMR,IAAI,CAACM,MAAM,CAACG,MAAM,CAACN,IAAI,CAACO,QAAQ,CAAC;IACxC,CAAC;IAEDC,OAAO,EAAEH,QAAQ,IAAI,IAAAI,0BAAmB,EAACZ,IAAI,CAACM,MAAM,CAAC,CAACK,OAAO,CAACH,QAAQ;EACvE,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/repeat/index.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "REPEAT_STOP_PREFIX", {
+  enumerable: true,
+  get: function () {
+    return _marker.REPEAT_STOP_PREFIX;
+  }
+});
+Object.defineProperty(exports, "createRepeatExpiryHandler", {
+  enumerable: true,
+  get: function () {
+    return _expiry.createRepeatExpiryHandler;
+  }
+});
+Object.defineProperty(exports, "isRepeatStopId", {
+  enumerable: true,
+  get: function () {
+    return _marker.isRepeatStopId;
+  }
+});
+Object.defineProperty(exports, "markerIdFor", {
+  enumerable: true,
+  get: function () {
+    return _marker.markerIdFor;
+  }
+});
+exports.registerBackgroundNotificationHandler = registerBackgroundNotificationHandler;
+Object.defineProperty(exports, "repeatStopFor", {
+  enumerable: true,
+  get: function () {
+    return _marker.repeatStopFor;
+  }
+});
+var _interactionBuffer = require("../state/interaction-buffer.js");
+var _record = require("../state/record.js");
+var _expiry = require("./expiry.js");
+var _marker = require("./marker.js");
+/**
+ * Repeat expiry — bounding an alert that repeats until it is handled.
+ *
+ * The one piece of this package a consumer has to wire up themselves. The
+ * engine registers its background task at module scope, outside the React tree,
+ * and no library can perform that registration on an app's behalf.
+ *
+ * An app that declares no repeating tone needs none of this.
+ */
+
+/**
+ * Registers the handler that ends a repeating alert while the app is dead.
+ *
+ * Call this at module scope in `index.js`, beside the app registration — not
+ * inside a component, and not inside an effect. By the time a component mounts,
+ * the process that needed this handler has already been asked to run it.
+ *
+ * Without it a repeating alert still starts and still stops when the user
+ * handles it, but nothing ends it on a device left face-down on a table. That
+ * is the whole reason the feature exists, so `apply()` reports its absence
+ * rather than letting anyone find out the hard way.
+ */
+function registerBackgroundNotificationHandler(registration) {
+  const handler = (0, _expiry.createRepeatExpiryHandler)(registration);
+  const keep = event => {
+    if (registration.store === undefined) return;
+    // A manager of its own: this runs in a process with no runtime, and the
+    // runtime created later loads what is written here.
+    (0, _interactionBuffer.buffer)(new _record.StateManager({
+      store: registration.store,
+      now: registration.now ?? (() => Date.now())
+    }), event);
+  };
+  registration.engine.registerBackgroundDeliveryHandler(event => handler.handle(event), async event => {
+    if (registration.onInteraction === undefined) {
+      keep(event);
+      return;
+    }
+    try {
+      await registration.onInteraction(event);
+    } catch {
+      // The app's handler failed; the interaction is kept rather than lost.
+      keep(event);
+    }
+  });
+
+  // Both paths, not just the background one. The engine routes a delivery to
+  // the foreground listener while the app is alive and to the headless task
+  // only when it is not — so registering only the latter leaves the alert
+  // sounding for anyone holding the phone when the window runs out, which is
+  // the one case they would certainly notice.
+  registration.engine.subscribeToDeliveries(event => {
+    // Deliberately not awaited: the engine's foreground listener is
+    // synchronous, and a rejection here must not take the subscription down
+    // with it — a handler that stopped listening would leave every later
+    // alarm unbounded.
+    handler.handle(event).catch(() => {});
+  });
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/repeat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_interactionBuffer","require","_record","_expiry","_marker","registerBackgroundNotificationHandler","registration","handler","createRepeatExpiryHandler","keep","event","store","undefined","buffer","StateManager","now","Date","engine","registerBackgroundDeliveryHandler","handle","onInteraction","subscribeToDeliveries","catch"],"sourceRoot":"../../../src","sources":["repeat/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,IAAAA,kBAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,OAAA,GAAAF,OAAA;AAIA,IAAAG,OAAA,GAAAH,OAAA;AAnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,qCAAqCA,CACpDC,YAA2C,EACpC;EACP,MAAMC,OAAO,GAAG,IAAAC,iCAAyB,EAACF,YAAY,CAAC;EAEvD,MAAMG,IAAI,GAAIC,KAAuB,IAAW;IAC/C,IAAIJ,YAAY,CAACK,KAAK,KAAKC,SAAS,EAAE;IACtC;IACA;IACA,IAAAC,yBAAM,EACL,IAAIC,oBAAY,CAAC;MAAEH,KAAK,EAAEL,YAAY,CAACK,KAAK;MAAEI,GAAG,EAAET,YAAY,CAACS,GAAG,KAAK,MAAMC,IAAI,CAACD,GAAG,CAAC,CAAC;IAAE,CAAC,CAAC,EAC5FL,KACD,CAAC;EACF,CAAC;EAEDJ,YAAY,CAACW,MAAM,CAACC,iCAAiC,CACpDR,KAAK,IAAIH,OAAO,CAACY,MAAM,CAACT,KAAK,CAAC,EAC9B,MAAMA,KAAK,IAAI;IACd,IAAIJ,YAAY,CAACc,aAAa,KAAKR,SAAS,EAAE;MAC7CH,IAAI,CAACC,KAAK,CAAC;MACX;IACD;IACA,IAAI;MACH,MAAMJ,YAAY,CAACc,aAAa,CAACV,KAAK,CAAC;IACxC,CAAC,CAAC,MAAM;MACP;MACAD,IAAI,CAACC,KAAK,CAAC;IACZ;EACD,CACD,CAAC;;EAED;EACA;EACA;EACA;EACA;EACAJ,YAAY,CAACW,MAAM,CAACI,qBAAqB,CAACX,KAAK,IAAI;IAClD;IACA;IACA;IACA;IACAH,OAAO,CAACY,MAAM,CAACT,KAAK,CAAC,CAACY,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;EACtC,CAAC,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/repeat/marker.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.REPEAT_STOP_PREFIX = void 0;
+exports.isRepeatStopId = isRepeatStopId;
+exports.markerIdFor = markerIdFor;
+exports.repeatStopFor = repeatStopFor;
+var _hash = require("../contract/hash.js");
+/**
+ * Stop-marker identity.
+ *
+ * A repeating alert has to end without the app being alive, and no platform
+ * offers "stop the sound at time T but keep the notification". So the package
+ * schedules its own notification at T and reacts to its delivery. That
+ * notification is a *marker*: it exists to be delivered and immediately
+ * removed, never to be read.
+ *
+ * The marker's identifier is derived from the target's by hashing rather than by
+ * concatenation. Concatenation would overflow the package's 128-character
+ * identifier limit for any target already near it, and would make the marker's
+ * identity a function of a value the consumer controls — which is how a
+ * consumer identifier ends up colliding with an internal one.
+ */
+
+/**
+ * Reserved identifier namespace.
+ *
+ * Rejected as a consumer identifier prefix. A consumer id colliding with a
+ * marker would not merely confuse a listing: the expiry handler cancels
+ * markers, so the collision would delete a real notification.
+ */
+const REPEAT_STOP_PREFIX = exports.REPEAT_STOP_PREFIX = 'cms.stop:';
+
+/**
+ * The marker identifier for a target notification.
+ *
+ * Two independent hashes rather than one: a single 32-bit hash collides often
+ * enough to matter once a device holds a handful of alarms, and a collision here
+ * means one alarm's marker silences the other alarm and never silences its own.
+ */
+function markerIdFor(targetId) {
+  return `${REPEAT_STOP_PREFIX}${(0, _hash.hex8)((0, _hash.fnv1a)(targetId, 0x811c9dc5))}${(0, _hash.hex8)((0, _hash.fnv1a)(targetId, 0x9e3779b9))}`;
+}
+function isRepeatStopId(id) {
+  return id.startsWith(REPEAT_STOP_PREFIX);
+}
+
+/** Describes the stop for a target whose alert must end at a known instant. */
+function repeatStopFor(targetId, deliveredAt, forMs) {
+  return {
+    markerId: markerIdFor(targetId),
+    targetId,
+    dueAt: deliveredAt + forMs
+  };
+}
+//# sourceMappingURL=marker.js.map

package/lib/commonjs/repeat/marker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hash","require","REPEAT_STOP_PREFIX","exports","markerIdFor","targetId","hex8","fnv1a","isRepeatStopId","id","startsWith","repeatStopFor","deliveredAt","forMs","markerId","dueAt"],"sourceRoot":"../../../src","sources":["repeat/marker.ts"],"mappings":";;;;;;;;;AAgBA,IAAAA,KAAA,GAAAC,OAAA;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,WAAW;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,WAAWA,CAACC,QAAgB,EAAU;EACrD,OAAO,GAAGH,kBAAkB,GAAG,IAAAI,UAAI,EAAC,IAAAC,WAAK,EAACF,QAAQ,EAAE,UAAU,CAAC,CAAC,GAAG,IAAAC,UAAI,EAAC,IAAAC,WAAK,EAACF,QAAQ,EAAE,UAAU,CAAC,CAAC,EAAE;AACvG;AAEO,SAASG,cAAcA,CAACC,EAAU,EAAW;EACnD,OAAOA,EAAE,CAACC,UAAU,CAACR,kBAAkB,CAAC;AACzC;;AAEA;AACO,SAASS,aAAaA,CAACN,QAAgB,EAAEO,WAAmB,EAAEC,KAAa,EAAc;EAC/F,OAAO;IACNC,QAAQ,EAAEV,WAAW,CAACC,QAAQ,CAAC;IAC/BA,QAAQ;IACRU,KAAK,EAAEH,WAAW,GAAGC;EACtB,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/repeat/place.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStopPlacement = createStopPlacement;
+var _marker = require("./marker.js");
+/**
+ * Keeping a notification's stop marker in step with the notification.
+ *
+ * Shared by the scheduler and the reconciler rather than written twice. They are
+ * two doors into the same act — reconciliation is how most consumers schedule —
+ * and a bound that only existed on one path would be a bound that mostly did not
+ * exist.
+ */
+
+function createStopPlacement(engine) {
+  /** `snapshot`: read once and kept current, for a pass; otherwise read on every call. */
+  function placement(snapshot) {
+    let known;
+
+    /** targetId → markerId of every outstanding stop. */
+    const outstanding = async () => {
+      if (snapshot && known) {
+        return known;
+      }
+      const read = new Map((await engine.listRepeatStops()).map(stop => [stop.targetId, stop.markerId]));
+      if (snapshot) {
+        known = read;
+      }
+      return read;
+    };
+    const release = async targetId => {
+      const stops = await outstanding();
+      const markerId = stops.get(targetId);
+      if (markerId !== undefined) {
+        await engine.cancel(markerId);
+        stops.delete(targetId);
+      }
+    };
+    return {
+      release,
+      async count() {
+        return (await outstanding()).size;
+      },
+      async sync(targetId, tone, deliversAt) {
+        await release(targetId);
+        const forMs = tone.android.repeatForMs;
+        if (!tone.android.loopSound || forMs === undefined) return;
+        const capabilities = await engine.getCapabilities();
+        if (!capabilities.supportsRepeatingAlert) return;
+        const stop = (0, _marker.repeatStopFor)(targetId, deliversAt, forMs);
+        await engine.schedule({
+          request: {
+            id: stop.markerId,
+            // Deliberately empty. A marker is delivered and removed within the
+            // same handler invocation; anything readable here would be text a
+            // user might glimpse and be confused by.
+            content: {
+              title: '',
+              body: ''
+            },
+            tone: tone.toneId,
+            // Absolute: the bound is a duration from a known instant, not a
+            // wall-clock time that should follow the user across time zones.
+            moment: {
+              at: stop.dueAt,
+              anchoring: 'absolute'
+            }
+          },
+          resolvedAt: stop.dueAt,
+          tone,
+          approximate: false,
+          repeatStop: stop
+        });
+        known?.set(targetId, stop.markerId);
+      },
+      pass: () => placement(true)
+    };
+  }
+  return placement(false);
+}
+//# sourceMappingURL=place.js.map

package/lib/commonjs/repeat/place.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_marker","require","createStopPlacement","engine","placement","snapshot","known","outstanding","read","Map","listRepeatStops","map","stop","targetId","markerId","release","stops","get","undefined","cancel","delete","count","size","sync","tone","deliversAt","forMs","android","repeatForMs","loopSound","capabilities","getCapabilities","supportsRepeatingAlert","repeatStopFor","schedule","request","id","content","title","body","toneId","moment","at","dueAt","anchoring","resolvedAt","approximate","repeatStop","set","pass"],"sourceRoot":"../../../src","sources":["repeat/place.ts"],"mappings":";;;;;;AAWA,IAAAA,OAAA,GAAAC,OAAA;AAXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkCO,SAASC,mBAAmBA,CAACC,MAAiC,EAAiB;EACrF;EACA,SAASC,SAASA,CAACC,QAAiB,EAAiB;IACpD,IAAIC,KAAsC;;IAE1C;IACA,MAAMC,WAAW,GAAG,MAAAA,CAAA,KAA0C;MAC7D,IAAIF,QAAQ,IAAIC,KAAK,EAAE;QACtB,OAAOA,KAAK;MACb;MACA,MAAME,IAAI,GAAG,IAAIC,GAAG,CACnB,CAAC,MAAMN,MAAM,CAACO,eAAe,CAAC,CAAC,EAAEC,GAAG,CAACC,IAAI,IAAI,CAACA,IAAI,CAACC,QAAQ,EAAED,IAAI,CAACE,QAAQ,CAAU,CACrF,CAAC;MACD,IAAIT,QAAQ,EAAE;QACbC,KAAK,GAAGE,IAAI;MACb;MACA,OAAOA,IAAI;IACZ,CAAC;IAED,MAAMO,OAAO,GAAG,MAAOF,QAAgB,IAAoB;MAC1D,MAAMG,KAAK,GAAG,MAAMT,WAAW,CAAC,CAAC;MACjC,MAAMO,QAAQ,GAAGE,KAAK,CAACC,GAAG,CAACJ,QAAQ,CAAC;MACpC,IAAIC,QAAQ,KAAKI,SAAS,EAAE;QAC3B,MAAMf,MAAM,CAACgB,MAAM,CAACL,QAAQ,CAAC;QAC7BE,KAAK,CAACI,MAAM,CAACP,QAAQ,CAAC;MACvB;IACD,CAAC;IAED,OAAO;MACNE,OAAO;MAEP,MAAMM,KAAKA,CAAA,EAAG;QACb,OAAO,CAAC,MAAMd,WAAW,CAAC,CAAC,EAAEe,IAAI;MAClC,CAAC;MAED,MAAMC,IAAIA,CAACV,QAAQ,EAAEW,IAAI,EAAEC,UAAU,EAAE;QACtC,MAAMV,OAAO,CAACF,QAAQ,CAAC;QAEvB,MAAMa,KAAK,GAAGF,IAAI,CAACG,OAAO,CAACC,WAAW;QACtC,IAAI,CAACJ,IAAI,CAACG,OAAO,CAACE,SAAS,IAAIH,KAAK,KAAKR,SAAS,EAAE;QAEpD,MAAMY,YAAY,GAAG,MAAM3B,MAAM,CAAC4B,eAAe,CAAC,CAAC;QACnD,IAAI,CAACD,YAAY,CAACE,sBAAsB,EAAE;QAE1C,MAAMpB,IAAI,GAAG,IAAAqB,qBAAa,EAACpB,QAAQ,EAAEY,UAAU,EAAEC,KAAK,CAAC;QACvD,MAAMvB,MAAM,CAAC+B,QAAQ,CAAC;UACrBC,OAAO,EAAE;YACRC,EAAE,EAAExB,IAAI,CAACE,QAAQ;YACjB;YACA;YACA;YACAuB,OAAO,EAAE;cAAEC,KAAK,EAAE,EAAE;cAAEC,IAAI,EAAE;YAAG,CAAC;YAChCf,IAAI,EAAEA,IAAI,CAACgB,MAAM;YACjB;YACA;YACAC,MAAM,EAAE;cAAEC,EAAE,EAAE9B,IAAI,CAAC+B,KAAK;cAAEC,SAAS,EAAE;YAAW;UACjD,CAAC;UACDC,UAAU,EAAEjC,IAAI,CAAC+B,KAAK;UACtBnB,IAAI;UACJsB,WAAW,EAAE,KAAK;UAClBC,UAAU,EAAEnC;QACb,CAAC,CAAC;QACFN,KAAK,EAAE0C,GAAG,CAACnC,QAAQ,EAAED,IAAI,CAACE,QAAQ,CAAC;MACpC,CAAC;MAEDmC,IAAI,EAAEA,CAAA,KAAM7C,SAAS,CAAC,IAAI;IAC3B,CAAC;EACF;EAEA,OAAOA,SAAS,CAAC,KAAK,CAAC;AACxB","ignoreList":[]}