@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/commonjs/index.js

@@ -0,0 +1,367 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ALL_DIAGNOSTIC_CODES", {
+  enumerable: true,
+  get: function () {
+    return _index.ALL_DIAGNOSTIC_CODES;
+  }
+});
+Object.defineProperty(exports, "CONTENT_LIMITS", {
+  enumerable: true,
+  get: function () {
+    return _validateContent.CONTENT_LIMITS;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_ANCHORING_MODE", {
+  enumerable: true,
+  get: function () {
+    return _index.DEFAULT_ANCHORING_MODE;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_BURST_THRESHOLD", {
+  enumerable: true,
+  get: function () {
+    return _index.DEFAULT_BURST_THRESHOLD;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_LOOKAHEAD", {
+  enumerable: true,
+  get: function () {
+    return _index.DEFAULT_LOOKAHEAD;
+  }
+});
+Object.defineProperty(exports, "DIAGNOSTIC_CODES", {
+  enumerable: true,
+  get: function () {
+    return _index.DIAGNOSTIC_CODES;
+  }
+});
+Object.defineProperty(exports, "DiagnosticEmitter", {
+  enumerable: true,
+  get: function () {
+    return _events.DiagnosticEmitter;
+  }
+});
+Object.defineProperty(exports, "INTERACTION_BUFFER_LIMITS", {
+  enumerable: true,
+  get: function () {
+    return _index.INTERACTION_BUFFER_LIMITS;
+  }
+});
+Object.defineProperty(exports, "LOOKAHEAD_BOUNDS", {
+  enumerable: true,
+  get: function () {
+    return _index.LOOKAHEAD_BOUNDS;
+  }
+});
+Object.defineProperty(exports, "MAX_ACTIONS_PER_NOTIFICATION", {
+  enumerable: true,
+  get: function () {
+    return _index.MAX_ACTIONS_PER_NOTIFICATION;
+  }
+});
+Object.defineProperty(exports, "MAX_IDENTIFIER_LENGTH", {
+  enumerable: true,
+  get: function () {
+    return _validateIdentifier.MAX_IDENTIFIER_LENGTH;
+  }
+});
+Object.defineProperty(exports, "MAX_ROUTING_PAYLOAD_BYTES", {
+  enumerable: true,
+  get: function () {
+    return _index.MAX_ROUTING_PAYLOAD_BYTES;
+  }
+});
+Object.defineProperty(exports, "MaintenanceController", {
+  enumerable: true,
+  get: function () {
+    return _toggle.MaintenanceController;
+  }
+});
+Object.defineProperty(exports, "MaintenanceRegistry", {
+  enumerable: true,
+  get: function () {
+    return _cycle.MaintenanceRegistry;
+  }
+});
+Object.defineProperty(exports, "MaintenanceScopeViolation", {
+  enumerable: true,
+  get: function () {
+    return _cycle.MaintenanceScopeViolation;
+  }
+});
+Object.defineProperty(exports, "NotificationError", {
+  enumerable: true,
+  get: function () {
+    return _index.NotificationError;
+  }
+});
+Object.defineProperty(exports, "PAST_TOLERANCE_MS", {
+  enumerable: true,
+  get: function () {
+    return _resolveMoment.PAST_TOLERANCE_MS;
+  }
+});
+Object.defineProperty(exports, "REPEAT_ALERT_BOUNDS", {
+  enumerable: true,
+  get: function () {
+    return _index.REPEAT_ALERT_BOUNDS;
+  }
+});
+Object.defineProperty(exports, "REPEAT_STOP_PREFIX", {
+  enumerable: true,
+  get: function () {
+    return _index5.REPEAT_STOP_PREFIX;
+  }
+});
+Object.defineProperty(exports, "StateManager", {
+  enumerable: true,
+  get: function () {
+    return _record.StateManager;
+  }
+});
+Object.defineProperty(exports, "canDisplay", {
+  enumerable: true,
+  get: function () {
+    return _state.canDisplay;
+  }
+});
+Object.defineProperty(exports, "capabilityFor", {
+  enumerable: true,
+  get: function () {
+    return _state.capabilityFor;
+  }
+});
+Object.defineProperty(exports, "channelIdFor", {
+  enumerable: true,
+  get: function () {
+    return _toneMap.channelIdFor;
+  }
+});
+Object.defineProperty(exports, "clearOwner", {
+  enumerable: true,
+  get: function () {
+    return _reset.clearOwner;
+  }
+});
+Object.defineProperty(exports, "createBurstDetector", {
+  enumerable: true,
+  get: function () {
+    return _burst.createBurstDetector;
+  }
+});
+Object.defineProperty(exports, "createChannels", {
+  enumerable: true,
+  get: function () {
+    return _migrate.createChannels;
+  }
+});
+Object.defineProperty(exports, "createInteractions", {
+  enumerable: true,
+  get: function () {
+    return _index6.createInteractions;
+  }
+});
+Object.defineProperty(exports, "createMmkvStore", {
+  enumerable: true,
+  get: function () {
+    return _mmkvStore.createMmkvStore;
+  }
+});
+Object.defineProperty(exports, "createNotifications", {
+  enumerable: true,
+  get: function () {
+    return _notifications.createNotifications;
+  }
+});
+Object.defineProperty(exports, "createNotifyKitEngine", {
+  enumerable: true,
+  get: function () {
+    return _notifyKitEngine.createNotifyKitEngine;
+  }
+});
+Object.defineProperty(exports, "createPermissionRefreshStep", {
+  enumerable: true,
+  get: function () {
+    return _permissionRefresh.createPermissionRefreshStep;
+  }
+});
+Object.defineProperty(exports, "createPermissions", {
+  enumerable: true,
+  get: function () {
+    return _index7.createPermissions;
+  }
+});
+Object.defineProperty(exports, "createPlatformTimeZoneReader", {
+  enumerable: true,
+  get: function () {
+    return _anchor.createPlatformTimeZoneReader;
+  }
+});
+Object.defineProperty(exports, "createReAnchorStep", {
+  enumerable: true,
+  get: function () {
+    return _reanchor.createReAnchorStep;
+  }
+});
+Object.defineProperty(exports, "createReconciler", {
+  enumerable: true,
+  get: function () {
+    return _index3.createReconciler;
+  }
+});
+Object.defineProperty(exports, "createRecurrence", {
+  enumerable: true,
+  get: function () {
+    return _index4.createRecurrence;
+  }
+});
+Object.defineProperty(exports, "createRepeatExpiryHandler", {
+  enumerable: true,
+  get: function () {
+    return _index5.createRepeatExpiryHandler;
+  }
+});
+Object.defineProperty(exports, "createScheduler", {
+  enumerable: true,
+  get: function () {
+    return _index2.createScheduler;
+  }
+});
+Object.defineProperty(exports, "createSnapshot", {
+  enumerable: true,
+  get: function () {
+    return _snapshot.createSnapshot;
+  }
+});
+Object.defineProperty(exports, "createToneResolver", {
+  enumerable: true,
+  get: function () {
+    return _toneMap.createToneResolver;
+  }
+});
+Object.defineProperty(exports, "createVerifyStep", {
+  enumerable: true,
+  get: function () {
+    return _verify.createVerifyStep;
+  }
+});
+Object.defineProperty(exports, "createWindowRefreshStep", {
+  enumerable: true,
+  get: function () {
+    return _windowRefresh.createWindowRefreshStep;
+  }
+});
+Object.defineProperty(exports, "initialize", {
+  enumerable: true,
+  get: function () {
+    return _initialize.initialize;
+  }
+});
+Object.defineProperty(exports, "isNonFailure", {
+  enumerable: true,
+  get: function () {
+    return _index.isNonFailure;
+  }
+});
+Object.defineProperty(exports, "isNotificationError", {
+  enumerable: true,
+  get: function () {
+    return _index.isNotificationError;
+  }
+});
+Object.defineProperty(exports, "isTerminal", {
+  enumerable: true,
+  get: function () {
+    return _state.isTerminal;
+  }
+});
+Object.defineProperty(exports, "isValidTimeZone", {
+  enumerable: true,
+  get: function () {
+    return _anchor.isValidTimeZone;
+  }
+});
+Object.defineProperty(exports, "occurrenceId", {
+  enumerable: true,
+  get: function () {
+    return _expand.occurrenceId;
+  }
+});
+Object.defineProperty(exports, "parseChannelId", {
+  enumerable: true,
+  get: function () {
+    return _toneMap.parseChannelId;
+  }
+});
+Object.defineProperty(exports, "registerBackgroundNotificationHandler", {
+  enumerable: true,
+  get: function () {
+    return _index5.registerBackgroundNotificationHandler;
+  }
+});
+Object.defineProperty(exports, "resetState", {
+  enumerable: true,
+  get: function () {
+    return _reset.resetState;
+  }
+});
+Object.defineProperty(exports, "resolveTone", {
+  enumerable: true,
+  get: function () {
+    return _toneMap.resolveTone;
+  }
+});
+Object.defineProperty(exports, "shouldOfferSettings", {
+  enumerable: true,
+  get: function () {
+    return _state.shouldOfferSettings;
+  }
+});
+Object.defineProperty(exports, "validateToneDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _validateTone.validateToneDeclaration;
+  }
+});
+Object.defineProperty(exports, "validateToneDeclarations", {
+  enumerable: true,
+  get: function () {
+    return _validateTone.validateToneDeclarations;
+  }
+});
+var _index = require("./contract/index.js");
+var _notifyKitEngine = require("./engine/notify-kit-engine.js");
+var _notifications = require("./notifications.js");
+var _initialize = require("./initialize.js");
+var _index2 = require("./schedule/index.js");
+var _index3 = require("./reconcile/index.js");
+var _index4 = require("./recurrence/index.js");
+var _expand = require("./recurrence/expand.js");
+var _migrate = require("./channel/migrate.js");
+var _toneMap = require("./channel/tone-map.js");
+var _validateTone = require("./channel/validate-tone.js");
+var _index5 = require("./repeat/index.js");
+var _index6 = require("./interaction/index.js");
+var _snapshot = require("./diagnostics/snapshot.js");
+var _burst = require("./diagnostics/burst.js");
+var _events = require("./diagnostics/events.js");
+var _index7 = require("./permission/index.js");
+var _state = require("./permission/state.js");
+var _permissionRefresh = require("./maintenance/permission-refresh.js");
+var _reanchor = require("./maintenance/reanchor.js");
+var _verify = require("./maintenance/verify.js");
+var _windowRefresh = require("./maintenance/window-refresh.js");
+var _cycle = require("./maintenance/cycle.js");
+var _toggle = require("./maintenance/toggle.js");
+var _reset = require("./state/reset.js");
+var _mmkvStore = require("./state/mmkv-store.js");
+var _record = require("./state/record.js");
+var _validateIdentifier = require("./schedule/validate-identifier.js");
+var _validateContent = require("./schedule/validate-content.js");
+var _resolveMoment = require("./schedule/resolve-moment.js");
+var _anchor = require("./schedule/anchor.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_notifyKitEngine","_notifications","_initialize","_index2","_index3","_index4","_expand","_migrate","_toneMap","_validateTone","_index5","_index6","_snapshot","_burst","_events","_index7","_state","_permissionRefresh","_reanchor","_verify","_windowRefresh","_cycle","_toggle","_reset","_mmkvStore","_record","_validateIdentifier","_validateContent","_resolveMoment","_anchor"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,IAAAA,MAAA,GAAAC,OAAA;AAgCA,IAAAC,gBAAA,GAAAD,OAAA;AAQA,IAAAE,cAAA,GAAAF,OAAA;AAIA,IAAAG,WAAA,GAAAH,OAAA;AAIA,IAAAI,OAAA,GAAAJ,OAAA;AAIA,IAAAK,OAAA,GAAAL,OAAA;AAIA,IAAAM,OAAA,GAAAN,OAAA;AAEA,IAAAO,OAAA,GAAAP,OAAA;AAGA,IAAAQ,QAAA,GAAAR,OAAA;AAEA,IAAAS,QAAA,GAAAT,OAAA;AACA,IAAAU,aAAA,GAAAV,OAAA;AASA,IAAAW,OAAA,GAAAX,OAAA;AAYA,IAAAY,OAAA,GAAAZ,OAAA;AAIA,IAAAa,SAAA,GAAAb,OAAA;AAEA,IAAAc,MAAA,GAAAd,OAAA;AAEA,IAAAe,OAAA,GAAAf,OAAA;AAGA,IAAAgB,OAAA,GAAAhB,OAAA;AAEA,IAAAiB,MAAA,GAAAjB,OAAA;AAIA,IAAAkB,kBAAA,GAAAlB,OAAA;AACA,IAAAmB,SAAA,GAAAnB,OAAA;AACA,IAAAoB,OAAA,GAAApB,OAAA;AACA,IAAAqB,cAAA,GAAArB,OAAA;AAEA,IAAAsB,MAAA,GAAAtB,OAAA;AACA,IAAAuB,OAAA,GAAAvB,OAAA;AAGA,IAAAwB,MAAA,GAAAxB,OAAA;AAOA,IAAAyB,UAAA,GAAAzB,OAAA;AACA,IAAA0B,OAAA,GAAA1B,OAAA;AAIA,IAAA2B,mBAAA,GAAA3B,OAAA;AACA,IAAA4B,gBAAA,GAAA5B,OAAA;AACA,IAAA6B,cAAA,GAAA7B,OAAA;AAUA,IAAA8B,OAAA,GAAA9B,OAAA","ignoreList":[]}

package/lib/commonjs/initialize.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialize = initialize;
+exports.resolveLookahead = resolveLookahead;
+exports.validateConfig = validateConfig;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _recurrence = require("./contract/recurrence.js");
+var _errors = require("./contract/errors.js");
+var _events = require("./diagnostics/events.js");
+var _cycle = require("./maintenance/cycle.js");
+var _toggle = require("./maintenance/toggle.js");
+var _record = require("./state/record.js");
+var _seriesLedger = require("./state/series-ledger.js");
+var _migrate = require("./channel/migrate.js");
+var _anchor = require("./schedule/anchor.js");
+/**
+ * Package initialization.
+ *
+ * Composes the parts that must be in place before the first schedule call:
+ * validate configuration, load persisted state, apply tone declarations, run
+ * any pending channel migration, and start the maintenance registry.
+ *
+ * Budgeted at 100 ms of app startup, which is why state loading is synchronous
+ * and tone declaration is the only platform round-trip.
+ *
+ * Automatic maintenance is started here too: whatever steps are registered on
+ * `runtime.registry` run when the app returns to the foreground, with the
+ * trigger reported as `timeZoneChange` when the device zone moved meanwhile.
+ * Until 0.4.0 nothing ever called `runAutomatic`, so "automatic" maintenance
+ * only ran when the app invoked it by hand.
+ */
+
+/** The slice of React Native's `AppState` the lifecycle observer uses. */
+
+/** rn-core's shared lifecycle port in the observer's shape: one native subscription for every package (PERF-07). */
+const sharedLifecycle = {
+  addEventListener: (_type, listener) => ({
+    remove: (0, _rnCore.appLifecycle)().subscribe(state => listener(state))
+  })
+};
+
+/** Everything assembled at initialization, shared by the operation modules. */
+
+/**
+ * Clamps the lookahead into its documented bounds.
+ *
+ * Bounded on adjustment because the platform ceiling is not negotiable: a
+ * consumer asking for a five-year window would silently exhaust the 64-entry
+ * iOS ceiling on the first frequent series.
+ */
+function resolveLookahead(partial) {
+  const days = partial?.days ?? _recurrence.DEFAULT_LOOKAHEAD.days;
+  const occurrencesPerSeries = partial?.occurrencesPerSeries ?? _recurrence.DEFAULT_LOOKAHEAD.occurrencesPerSeries;
+  return {
+    days: Math.min(Math.max(days, _recurrence.LOOKAHEAD_BOUNDS.minDays), _recurrence.LOOKAHEAD_BOUNDS.maxDays),
+    occurrencesPerSeries: Math.min(Math.max(occurrencesPerSeries, _recurrence.LOOKAHEAD_BOUNDS.minOccurrences), _recurrence.LOOKAHEAD_BOUNDS.maxOccurrences)
+  };
+}
+
+/** Fails before any platform call, so a bad configuration never half-applies. */
+function validateConfig(config) {
+  if (config.tones.length === 0) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.UNDECLARED_TONE, 'At least one tone must be declared before notifications can be scheduled.');
+  }
+  const seen = new Set();
+  for (const tone of config.tones) {
+    if (seen.has(tone.id)) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.UNDECLARED_TONE, `Tone "${tone.id}" is declared more than once.`, {
+        toneId: tone.id
+      });
+    }
+    seen.add(tone.id);
+    if (!Number.isInteger(tone.version) || tone.version < 1) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.CHANNEL_MIGRATION_REQUIRED, `Tone "${tone.id}" must carry an integer version of 1 or greater, because a channel configuration change is a migration rather than an assignment.`, {
+        toneId: tone.id,
+        version: tone.version
+      });
+    }
+  }
+  const groupIds = new Set((config.channelGroups ?? []).map(group => group.id));
+  for (const tone of config.tones) {
+    if (tone.groupId !== undefined && !groupIds.has(tone.groupId)) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.UNDECLARED_TONE, `Tone "${tone.id}" references undeclared channel group "${tone.groupId}".`, {
+        toneId: tone.id,
+        groupId: tone.groupId
+      });
+    }
+  }
+}
+async function initialize(config, deps) {
+  const now = deps.now ?? (() => Date.now());
+  const startedAt = now();
+  validateConfig(config);
+  const emitter = new _events.DiagnosticEmitter({
+    sink: config.eventSink,
+    verbose: config.verboseDiagnostics,
+    now
+  });
+  const state = new _record.StateManager({
+    store: deps.store,
+    now,
+    emit: event => emitter.emit(event.code, describeStateEvent(event.code), event.context)
+  });
+  const channels = (0, _migrate.createChannels)({
+    engine: deps.engine,
+    state,
+    now,
+    // The channel module emits only DIAGNOSTIC_CODES values; its port types the
+    // code as a string so it stays usable without the emitter.
+    emit: (code, message, context) => emitter.emit(code, message, context)
+  });
+  // Declares groups and tones, and runs any version migration. An unchanged
+  // configuration costs no platform work, so doing this on every launch is free.
+  const applied = await channels.apply(config.tones, config.channelGroups ?? []);
+  const registry = new _cycle.MaintenanceRegistry({
+    clock: now
+  });
+  const maintenance = new _toggle.MaintenanceController({
+    registry,
+    now,
+    // Occurrence identifiers, not series identifiers. Maintenance cancels
+    // occurrences, so a set of series ids made every legitimate cancel look
+    // like a scope violation.
+    ownedIds: async () => (0, _seriesLedger.ownedIdentifiers)(state, (await deps.engine.getPending()).map(entry => entry.id)),
+    enabled: config.automaticMaintenance ?? true
+  });
+  const timeZone = deps.timeZone ?? (0, _anchor.createPlatformTimeZoneReader)();
+  let lastZone = timeZone();
+  let lastAutomatic;
+  const onAppState = next => {
+    if (next !== 'active') return;
+    const zone = timeZone();
+    const trigger = zone !== lastZone ? 'timeZoneChange' : 'foreground';
+    lastZone = zone;
+    maintenance.runAutomatic(trigger).then(result => {
+      if (result !== undefined) lastAutomatic = result;
+    }, error => {
+      // Nothing awaits an automatic cycle, so a failure is reported here or
+      // not at all.
+      emitter.emit(_errors.DIAGNOSTIC_CODES.MAINTENANCE_FAILED, `Automatic maintenance (${trigger}) failed: ${error instanceof Error ? error.name : 'unknown error'}.`, {
+        trigger
+      });
+    });
+  };
+  const subscription = (deps.appState ?? sharedLifecycle).addEventListener('change', onAppState);
+  const runtime = {
+    engine: deps.engine,
+    state,
+    emitter,
+    registry,
+    maintenance,
+    channels,
+    lookahead: resolveLookahead(config.lookahead),
+    config,
+    now,
+    lastAutomaticMaintenance: () => lastAutomatic,
+    dispose: () => subscription.remove()
+  };
+  return {
+    runtime,
+    result: {
+      tonesApplied: config.tones.length,
+      migrationsRun: applied.migrated.length,
+      stateRebuilt: state.health().rebuilt,
+      automaticMaintenance: maintenance.isEnabled,
+      durationMs: now() - startedAt
+    }
+  };
+}
+function describeStateEvent(code) {
+  switch (code) {
+    case _errors.DIAGNOSTIC_CODES.STATE_CORRUPT_REBUILT:
+      return 'Persisted state was unreadable and has been rebuilt. Deduplication history and buffered interactions from before the loss are gone; scheduled notifications are unaffected.';
+    case _errors.DIAGNOSTIC_CODES.STATE_WRITE_FAILED:
+      return 'Persisted state could not be written. The affected guarantee degrades to this session only.';
+    case _errors.DIAGNOSTIC_CODES.STATE_CAP_EVICTED:
+      return 'A persisted collection reached its cap and the oldest entries were evicted.';
+    case _errors.DIAGNOSTIC_CODES.INTERACTION_BUFFER_EVICTED:
+      return 'Buffered interactions were evicted at the cap or retention limit.';
+    default:
+      return 'Persisted state event.';
+  }
+}
+//# sourceMappingURL=initialize.js.map

package/lib/commonjs/initialize.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_recurrence","_errors","_events","_cycle","_toggle","_record","_seriesLedger","_migrate","_anchor","sharedLifecycle","addEventListener","_type","listener","remove","appLifecycle","subscribe","state","resolveLookahead","partial","days","DEFAULT_LOOKAHEAD","occurrencesPerSeries","Math","min","max","LOOKAHEAD_BOUNDS","minDays","maxDays","minOccurrences","maxOccurrences","validateConfig","config","tones","length","NotificationError","DIAGNOSTIC_CODES","UNDECLARED_TONE","seen","Set","tone","has","id","toneId","add","Number","isInteger","version","CHANNEL_MIGRATION_REQUIRED","groupIds","channelGroups","map","group","groupId","undefined","initialize","deps","now","Date","startedAt","emitter","DiagnosticEmitter","sink","eventSink","verbose","verboseDiagnostics","StateManager","store","emit","event","code","describeStateEvent","context","channels","createChannels","engine","message","applied","apply","registry","MaintenanceRegistry","clock","maintenance","MaintenanceController","ownedIds","ownedIdentifiers","getPending","entry","enabled","automaticMaintenance","timeZone","createPlatformTimeZoneReader","lastZone","lastAutomatic","onAppState","next","zone","trigger","runAutomatic","then","result","error","MAINTENANCE_FAILED","Error","name","subscription","appState","runtime","lookahead","lastAutomaticMaintenance","dispose","tonesApplied","migrationsRun","migrated","stateRebuilt","health","rebuilt","isEnabled","durationMs","STATE_CORRUPT_REBUILT","STATE_WRITE_FAILED","STATE_CAP_EVICTED","INTERACTION_BUFFER_EVICTED"],"sourceRoot":"../../src","sources":["initialize.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/interaction/index.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInteractions = createInteractions;
+var _errors = require("../contract/errors.js");
+var _interactionBuffer = require("../state/interaction-buffer.js");
+/**
+ * Interaction routing.
+ *
+ * One handler covers foreground, background, and cold start. The hard case is
+ * the last one: the tap happens before any JavaScript exists to receive it, so
+ * the event has to wait — durably — until a handler registers.
+ *
+ * Events are delivered in occurrence order and never dropped for want of a
+ * listener. After delivery the notification leaves the tray, because a
+ * notification the user has already acted on sitting there is noise.
+ */
+
+function createInteractions(deps) {
+  const emit = deps.emit ?? (() => {});
+  let handlers = [];
+  let engineSubscription;
+  /** Serializes delivery so rapid interactions arrive in order, never interleaved. */
+  let deliveryChain = Promise.resolve();
+  const deliver = event => {
+    deliveryChain = deliveryChain.then(async () => {
+      for (const handler of handlers) {
+        try {
+          await handler(event);
+        } catch {
+          // A consumer's handler failing must not stop the next event, or one
+          // bad tap would silently swallow every tap after it.
+        }
+      }
+
+      // Acted on, so it leaves the tray and stops making noise.
+      if (event.kind !== 'dismiss') {
+        await deps.engine.cancel(event.notificationId).catch(() => undefined);
+      }
+    });
+  };
+  const route = event => {
+    if (handlers.length === 0) {
+      (0, _interactionBuffer.buffer)(deps.state, event);
+      return;
+    }
+    deliver(event);
+  };
+  const ensureSubscribed = () => {
+    engineSubscription ??= deps.engine.subscribeToInteractions(route);
+  };
+
+  // Subscribing immediately rather than on first handler registration: an
+  // interaction arriving in the gap would otherwise be lost entirely, which is
+  // the exact failure the buffer exists to prevent.
+  ensureSubscribed();
+  return {
+    /**
+     * Registers a handler and immediately drains anything that was waiting.
+     *
+     * The drain is what makes a cold-start tap work: the event was persisted
+     * before this handler existed, possibly before this process existed.
+     */
+    onInteraction(handler) {
+      handlers.push(handler);
+      for (const event of (0, _interactionBuffer.drain)(deps.state)) {
+        deliver(event);
+      }
+      return () => {
+        handlers = handlers.filter(h => h !== handler);
+      };
+    },
+    /**
+     * Collects the interaction that launched the app, if any.
+     *
+     * Called once during startup. If no handler exists yet the event is
+     * buffered rather than discarded.
+     */
+    async collectInitial() {
+      const initial = await deps.engine.takeInitialInteraction();
+      if (initial === undefined) return;
+      route(initial);
+    },
+    /**
+     * Signals that a routing target no longer exists.
+     *
+     * The consumer chooses its own fallback screen. No platform error is ever
+     * shown to the user for this — a notification pointing at deleted data is
+     * an ordinary condition, not a crash.
+     */
+    reportTargetMissing(signal) {
+      emit(_errors.DIAGNOSTIC_CODES.TARGET_MISSING, 'The routing target no longer exists. The consumer chooses a fallback; no platform error is shown to the user.', {
+        notificationId: signal.notificationId
+      });
+    },
+    /** Reports that a background action exceeded the platform's execution window. */
+    reportBackgroundTimeout(notificationId, windowMs) {
+      emit(_errors.DIAGNOSTIC_CODES.BACKGROUND_WINDOW_EXCEEDED, `A background action exceeded the platform's ${windowMs} ms execution window and was cut short.`, {
+        notificationId,
+        windowMs
+      });
+    },
+    /** How many interactions are waiting for a handler. */
+    pendingCount() {
+      return (0, _interactionBuffer.bufferedCount)(deps.state);
+    },
+    /** Settles outstanding deliveries. Exists for tests and orderly shutdown. */
+    async flush() {
+      await deliveryChain;
+    },
+    dispose() {
+      engineSubscription?.();
+      engineSubscription = undefined;
+      handlers = [];
+    }
+  };
+}
+//# sourceMappingURL=index.js.map