@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_interactionBuffer","createInteractions","deps","emit","handlers","engineSubscription","deliveryChain","Promise","resolve","deliver","event","then","handler","kind","engine","cancel","notificationId","catch","undefined","route","length","buffer","state","ensureSubscribed","subscribeToInteractions","onInteraction","push","drain","filter","h","collectInitial","initial","takeInitialInteraction","reportTargetMissing","signal","DIAGNOSTIC_CODES","TARGET_MISSING","reportBackgroundTimeout","windowMs","BACKGROUND_WINDOW_EXCEEDED","pendingCount","bufferedCount","flush","dispose"],"sourceRoot":"../../../src","sources":["interaction/index.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/maintenance/cycle.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MaintenanceScopeViolation = exports.MaintenanceRegistry = void 0;
+/**
+ * The automatic maintenance cycle.
+ *
+ * Covers exactly what only the package can know — window refresh, recurrence
+ * expansion, wall-clock re-anchoring, pending-set verification, permission
+ * re-reads. Full desired-set reconciliation is never automatic, because only
+ * the consumer knows what its data implies and a package that guessed would
+ * cancel notifications it does not understand.
+ *
+ * Steps register themselves here rather than being wired in a fixed order. That
+ * is what lets scheduling, reconciliation, recurrence, and permissions each
+ * contribute a step without importing one another.
+ *
+ * The rule that makes automatic work safe: a step may act only on notifications
+ * the package owns, and may never cancel anything else. It is enforced here
+ * rather than trusted to each step.
+ */
+
+class MaintenanceScopeViolation extends Error {
+  constructor(step, offendingIds) {
+    super(`Maintenance step "${step}" attempted to cancel ${offendingIds.length} notification(s) it does not own. ` + 'Automatic maintenance may never cancel a directly-scheduled notification.');
+    this.name = 'MaintenanceScopeViolation';
+    this.step = step;
+    this.offendingIds = offendingIds;
+    Object.setPrototypeOf(this, MaintenanceScopeViolation.prototype);
+  }
+}
+exports.MaintenanceScopeViolation = MaintenanceScopeViolation;
+class MaintenanceRegistry {
+  steps = [];
+  inFlight = null;
+  constructor(options = {}) {
+    this.clock = options.clock ?? (() => Date.now());
+  }
+  register(step) {
+    this.steps.push(step);
+    this.steps.sort((a, b) => a.order - b.order);
+    return () => {
+      this.steps = this.steps.filter(s => s !== step);
+    };
+  }
+  get registered() {
+    return this.steps.map(s => s.name);
+  }
+
+  /**
+   * Runs every registered step in order.
+   *
+   * Overlapping cycles are joined rather than queued or dropped: a second
+   * caller arriving mid-cycle wants the work the running cycle is already
+   * doing, so it waits for that cycle and gets its result. It used to get an
+   * empty result at once. Since `initialize` started running a cycle on every
+   * foreground, an app that ran maintenance and then reconciled on the same
+   * event got that empty result and reconciled while the window refresh was
+   * still writing: a reminder the reconcile cancelled could be scheduled again.
+   */
+  run(context) {
+    if (this.inFlight) {
+      return this.inFlight;
+    }
+    const cycle = this.runSteps(context).finally(() => {
+      if (this.inFlight === cycle) this.inFlight = null;
+    });
+    this.inFlight = cycle;
+    return cycle;
+  }
+  async runSteps(context) {
+    const started = context.now;
+    const clockStart = this.clock();
+    const aggregate = {
+      windowRefreshed: false,
+      occurrencesScheduled: 0,
+      reAnchored: 0,
+      timeZoneChanged: false,
+      permissionChanged: false,
+      operationCount: 0
+    };
+    let discrepancy;
+    for (const step of this.steps) {
+      const outcome = await step.run(context);
+      const offending = (outcome.cancelledIds ?? []).filter(id => !context.ownedIds.has(id));
+      if (offending.length > 0) {
+        throw new MaintenanceScopeViolation(step.name, offending);
+      }
+      aggregate.windowRefreshed ||= outcome.windowRefreshed ?? false;
+      aggregate.occurrencesScheduled += outcome.occurrencesScheduled ?? 0;
+      aggregate.reAnchored += outcome.reAnchored ?? 0;
+      aggregate.timeZoneChanged ||= outcome.timeZoneChanged ?? false;
+      aggregate.permissionChanged ||= outcome.permissionChanged ?? false;
+      aggregate.operationCount += outcome.operationCount ?? 0;
+      discrepancy ??= outcome.discrepancy;
+    }
+    return {
+      ranAt: started,
+      ...aggregate,
+      discrepancy,
+      durationMs: this.clock() - clockStart
+    };
+  }
+}
+exports.MaintenanceRegistry = MaintenanceRegistry;
+//# sourceMappingURL=cycle.js.map

package/lib/commonjs/maintenance/cycle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MaintenanceScopeViolation","Error","constructor","step","offendingIds","length","name","Object","setPrototypeOf","prototype","exports","MaintenanceRegistry","steps","inFlight","options","clock","Date","now","register","push","sort","a","b","order","filter","s","registered","map","run","context","cycle","runSteps","finally","started","clockStart","aggregate","windowRefreshed","occurrencesScheduled","reAnchored","timeZoneChanged","permissionChanged","operationCount","discrepancy","outcome","offending","cancelledIds","id","ownedIds","has","ranAt","durationMs"],"sourceRoot":"../../../src","sources":["maintenance/cycle.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/maintenance/permission-refresh.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PERMISSION_REFRESH_ORDER = void 0;
+exports.createPermissionRefreshStep = createPermissionRefreshStep;
+/**
+ * The permission re-read maintenance step.
+ *
+ * The user can change permission in system settings while the app is
+ * backgrounded, and the platform does not tell anyone. Re-reading on foreground
+ * is the only way a consumer's interface avoids showing a stale answer.
+ *
+ * Runs last (order 30): permission state does not affect what the earlier steps
+ * expand or re-anchor, and reading it after they have run means the report
+ * reflects the device as the cycle leaves it.
+ */
+
+const PERMISSION_REFRESH_ORDER = exports.PERMISSION_REFRESH_ORDER = 30;
+function createPermissionRefreshStep(deps) {
+  return {
+    name: 'permission-refresh',
+    order: PERMISSION_REFRESH_ORDER,
+    async run(_context) {
+      const {
+        changed
+      } = await deps.permissions.refresh();
+      return {
+        // Reading permission is not a platform mutation, so it never counts
+        // toward the zero-operation guarantee.
+        operationCount: 0,
+        permissionChanged: changed,
+        cancelledIds: []
+      };
+    }
+  };
+}
+//# sourceMappingURL=permission-refresh.js.map

package/lib/commonjs/maintenance/permission-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PERMISSION_REFRESH_ORDER","exports","createPermissionRefreshStep","deps","name","order","run","_context","changed","permissions","refresh","operationCount","permissionChanged","cancelledIds"],"sourceRoot":"../../../src","sources":["maintenance/permission-refresh.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKO,MAAMA,wBAAwB,GAAAC,OAAA,CAAAD,wBAAA,GAAG,EAAE;AAMnC,SAASE,2BAA2BA,CAACC,IAAmC,EAAmB;EACjG,OAAO;IACNC,IAAI,EAAE,oBAAoB;IAC1BC,KAAK,EAAEL,wBAAwB;IAE/B,MAAMM,GAAGA,CAACC,QAA4B,EAAwB;MAC7D,MAAM;QAAEC;MAAQ,CAAC,GAAG,MAAML,IAAI,CAACM,WAAW,CAACC,OAAO,CAAC,CAAC;MAEpD,OAAO;QACN;QACA;QACAC,cAAc,EAAE,CAAC;QACjBC,iBAAiB,EAAEJ,OAAO;QAC1BK,YAAY,EAAE;MACf,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/maintenance/reanchor.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RE_ANCHOR_ORDER = void 0;
+exports.createReAnchorStep = createReAnchorStep;
+var _anchor = require("../schedule/anchor.js");
+var _writer = require("../schedule/writer.js");
+/**
+ * The re-anchoring maintenance step.
+ *
+ * Registers itself with the maintenance registry rather than being wired into
+ * a fixed sequence, which is what keeps scheduling independent of
+ * reconciliation, recurrence, and permissions despite all four contributing a
+ * step.
+ *
+ * Runs early (order 10) because verification compares firing instants: if
+ * verification ran first it would compare against instants re-anchoring is
+ * about to rewrite, and report discrepancies that do not exist.
+ */
+
+const RE_ANCHOR_ORDER = exports.RE_ANCHOR_ORDER = 10;
+function createReAnchorStep(deps) {
+  // Through the shared writer so a repeating alert's stop marker moves with it;
+  // written directly, the marker kept the old instant and cut the alert short
+  // or let it run past its bound.
+  const writer = (0, _writer.createScheduleWriter)(deps.engine);
+  return {
+    name: 'reanchor',
+    order: RE_ANCHOR_ORDER,
+    async run(_context) {
+      const zone = deps.timeZone();
+      const pending = await deps.engine.getPending();
+      const plan = (0, _anchor.planReAnchor)(pending, zone);
+
+      // The no-change path costs one comparison per entry and issues zero
+      // platform operations. That is what makes re-anchoring idempotent.
+      if (plan.rewrites.length === 0) {
+        return {
+          operationCount: 0,
+          reAnchored: 0,
+          timeZoneChanged: false
+        };
+      }
+      deps.emit?.('REANCHOR', `Device time zone changed from ${plan.fromZone ?? 'unknown'} to ${plan.toZone}; re-anchoring ${plan.rewrites.length} wall-clock notification(s).`, {
+        from: plan.fromZone,
+        to: plan.toZone,
+        count: plan.rewrites.length
+      });
+      let operationCount = 0;
+      for (const {
+        entry,
+        resolvedAt
+      } of plan.rewrites) {
+        const tone = deps.resolveTone(entry.tone);
+        if (tone === undefined) {
+          // A tone that no longer exists means this entry belongs to a
+          // configuration the app has since dropped. Leaving it alone is
+          // correct: re-anchoring must never repair, only preserve.
+          continue;
+        }
+        await writer.write({
+          request: {
+            id: entry.id,
+            content: entry.content,
+            tone: entry.tone,
+            moment: {
+              at: resolvedAt,
+              anchoring: 'wallClock'
+            },
+            routing: entry.routing,
+            actions: entry.actions,
+            ownerTag: entry.ownerTag,
+            groupTag: entry.groupTag
+          },
+          resolvedAt,
+          tone,
+          // Re-anchored against the zone the device is in now — this is the
+          // value that stops the entry being reported as stale next time.
+          anchoringGeneration: zone,
+          approximate: !deps.canScheduleExactly(),
+          seriesId: entry.seriesId,
+          pushCreated: entry.pushCreated
+        });
+        operationCount += 1;
+      }
+      return {
+        operationCount,
+        reAnchored: operationCount,
+        timeZoneChanged: true,
+        // Re-anchoring replaces in place and cancels nothing, so it can never
+        // touch a notification outside what it was handed.
+        cancelledIds: []
+      };
+    }
+  };
+}
+//# sourceMappingURL=reanchor.js.map

package/lib/commonjs/maintenance/reanchor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_anchor","require","_writer","RE_ANCHOR_ORDER","exports","createReAnchorStep","deps","writer","createScheduleWriter","engine","name","order","run","_context","zone","timeZone","pending","getPending","plan","planReAnchor","rewrites","length","operationCount","reAnchored","timeZoneChanged","emit","fromZone","toZone","from","to","count","entry","resolvedAt","tone","resolveTone","undefined","write","request","id","content","moment","at","anchoring","routing","actions","ownerTag","groupTag","anchoringGeneration","approximate","canScheduleExactly","seriesId","pushCreated","cancelledIds"],"sourceRoot":"../../../src","sources":["maintenance/reanchor.ts"],"mappings":";;;;;;;AAgBA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBO,MAAME,eAAe,GAAAC,OAAA,CAAAD,eAAA,GAAG,EAAE;AAE1B,SAASE,kBAAkBA,CAACC,IAA8B,EAAmB;EACnF;EACA;EACA;EACA,MAAMC,MAAM,GAAG,IAAAC,4BAAoB,EAACF,IAAI,CAACG,MAAM,CAAC;EAEhD,OAAO;IACNC,IAAI,EAAE,UAAU;IAChBC,KAAK,EAAER,eAAe;IAEtB,MAAMS,GAAGA,CAACC,QAA4B,EAAwB;MAC7D,MAAMC,IAAI,GAAGR,IAAI,CAACS,QAAQ,CAAC,CAAC;MAC5B,MAAMC,OAAO,GAAG,MAAMV,IAAI,CAACG,MAAM,CAACQ,UAAU,CAAC,CAAC;MAC9C,MAAMC,IAAI,GAAG,IAAAC,oBAAY,EAACH,OAAO,EAAEF,IAAI,CAAC;;MAExC;MACA;MACA,IAAII,IAAI,CAACE,QAAQ,CAACC,MAAM,KAAK,CAAC,EAAE;QAC/B,OAAO;UAAEC,cAAc,EAAE,CAAC;UAAEC,UAAU,EAAE,CAAC;UAAEC,eAAe,EAAE;QAAM,CAAC;MACpE;MAEAlB,IAAI,CAACmB,IAAI,GACR,UAAU,EACV,iCAAiCP,IAAI,CAACQ,QAAQ,IAAI,SAAS,OAAOR,IAAI,CAACS,MAAM,kBAAkBT,IAAI,CAACE,QAAQ,CAACC,MAAM,8BAA8B,EACjJ;QAAEO,IAAI,EAAEV,IAAI,CAACQ,QAAQ;QAAEG,EAAE,EAAEX,IAAI,CAACS,MAAM;QAAEG,KAAK,EAAEZ,IAAI,CAACE,QAAQ,CAACC;MAAO,CACrE,CAAC;MAED,IAAIC,cAAc,GAAG,CAAC;MAEtB,KAAK,MAAM;QAAES,KAAK;QAAEC;MAAW,CAAC,IAAId,IAAI,CAACE,QAAQ,EAAE;QAClD,MAAMa,IAAI,GAAG3B,IAAI,CAAC4B,WAAW,CAACH,KAAK,CAACE,IAAI,CAAC;QACzC,IAAIA,IAAI,KAAKE,SAAS,EAAE;UACvB;UACA;UACA;UACA;QACD;QAEA,MAAM5B,MAAM,CAAC6B,KAAK,CAAC;UAClBC,OAAO,EAAE;YACRC,EAAE,EAAEP,KAAK,CAACO,EAAE;YACZC,OAAO,EAAER,KAAK,CAACQ,OAAO;YACtBN,IAAI,EAAEF,KAAK,CAACE,IAAI;YAChBO,MAAM,EAAE;cAAEC,EAAE,EAAET,UAAU;cAAEU,SAAS,EAAE;YAAY,CAAC;YAClDC,OAAO,EAAEZ,KAAK,CAACY,OAAO;YACtBC,OAAO,EAAEb,KAAK,CAACa,OAAO;YACtBC,QAAQ,EAAEd,KAAK,CAACc,QAAQ;YACxBC,QAAQ,EAAEf,KAAK,CAACe;UACjB,CAAC;UACDd,UAAU;UACVC,IAAI;UACJ;UACA;UACAc,mBAAmB,EAAEjC,IAAI;UACzBkC,WAAW,EAAE,CAAC1C,IAAI,CAAC2C,kBAAkB,CAAC,CAAC;UACvCC,QAAQ,EAAEnB,KAAK,CAACmB,QAAQ;UACxBC,WAAW,EAAEpB,KAAK,CAACoB;QACpB,CAAC,CAAC;QACF7B,cAAc,IAAI,CAAC;MACpB;MAEA,OAAO;QACNA,cAAc;QACdC,UAAU,EAAED,cAAc;QAC1BE,eAAe,EAAE,IAAI;QACrB;QACA;QACA4B,YAAY,EAAE;MACf,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/maintenance/toggle.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MaintenanceController = void 0;
+/**
+ * The automatic-maintenance switch.
+ *
+ * A package that acts on its own must offer a way to stop it — and a consumer
+ * that takes control must not lose a feature as the price. Disabling automatic
+ * maintenance leaves every operation explicitly invocable through
+ * `runMaintenance()`, producing identical device state.
+ */
+
+class MaintenanceController {
+  constructor(options) {
+    this.registry = options.registry;
+    this.now = options.now;
+    this.ownedIds = options.ownedIds;
+    this.enabled = options.enabled ?? true;
+  }
+  get isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+
+  /** Called by lifecycle observers. A no-op when automatic maintenance is off. */
+  async runAutomatic(trigger) {
+    if (!this.enabled) return undefined;
+    return this.execute(trigger);
+  }
+
+  /** Always runs, regardless of the switch. This is what preserves capability parity. */
+  async runExplicit() {
+    return this.execute('explicit');
+  }
+  async execute(trigger) {
+    const context = {
+      trigger,
+      now: this.now(),
+      ownedIds: await this.ownedIds()
+    };
+    return this.registry.run(context);
+  }
+}
+exports.MaintenanceController = MaintenanceController;
+//# sourceMappingURL=toggle.js.map

package/lib/commonjs/maintenance/toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MaintenanceController","constructor","options","registry","now","ownedIds","enabled","isEnabled","setEnabled","runAutomatic","trigger","undefined","execute","runExplicit","context","run","exports"],"sourceRoot":"../../../src","sources":["maintenance/toggle.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBO,MAAMA,qBAAqB,CAAC;EAMlCC,WAAWA,CAACC,OAAqC,EAAE;IAClD,IAAI,CAACC,QAAQ,GAAGD,OAAO,CAACC,QAAQ;IAChC,IAAI,CAACC,GAAG,GAAGF,OAAO,CAACE,GAAG;IACtB,IAAI,CAACC,QAAQ,GAAGH,OAAO,CAACG,QAAQ;IAChC,IAAI,CAACC,OAAO,GAAGJ,OAAO,CAACI,OAAO,IAAI,IAAI;EACvC;EAEA,IAAIC,SAASA,CAAA,EAAY;IACxB,OAAO,IAAI,CAACD,OAAO;EACpB;EAEAE,UAAUA,CAACF,OAAgB,EAAQ;IAClC,IAAI,CAACA,OAAO,GAAGA,OAAO;EACvB;;EAEA;EACA,MAAMG,YAAYA,CACjBC,OAAgD,EACP;IACzC,IAAI,CAAC,IAAI,CAACJ,OAAO,EAAE,OAAOK,SAAS;IACnC,OAAO,IAAI,CAACC,OAAO,CAACF,OAAO,CAAC;EAC7B;;EAEA;EACA,MAAMG,WAAWA,CAAA,EAA+B;IAC/C,OAAO,IAAI,CAACD,OAAO,CAAC,UAAU,CAAC;EAChC;EAEA,MAAcA,OAAOA,CAACF,OAA2B,EAA8B;IAC9E,MAAMI,OAA2B,GAAG;MACnCJ,OAAO;MACPN,GAAG,EAAE,IAAI,CAACA,GAAG,CAAC,CAAC;MACfC,QAAQ,EAAE,MAAM,IAAI,CAACA,QAAQ,CAAC;IAC/B,CAAC;IACD,OAAO,IAAI,CAACF,QAAQ,CAACY,GAAG,CAACD,OAAO,CAAC;EAClC;AACD;AAACE,OAAA,CAAAhB,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/lib/commonjs/maintenance/verify.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERIFY_ORDER = void 0;
+exports.createVerifyStep = createVerifyStep;
+var _errors = require("../contract/errors.js");
+/**
+ * Pending-set verification.
+ *
+ * Engine boot restoration coverage varies by manufacturer, so after a restart
+ * the device may hold fewer notifications than the package expects. This step
+ * notices that.
+ *
+ * It **detects and reports only**. It never re-registers, cancels, or repairs
+ * anything — the package deliberately does not persist a desired set, so it
+ * cannot tell a restoration gap from an intentional consumer change. Guessing
+ * would mean either resurrecting notifications the user cancelled or deleting
+ * ones they still want. Repair is consumer-invoked reconciliation.
+ *
+ * Runs at order 20, after re-anchoring (order 10): re-anchoring rewrites firing
+ * instants, and verifying first would compare against instants that are about
+ * to change.
+ */
+
+const VERIFY_ORDER = exports.VERIFY_ORDER = 20;
+function createVerifyStep(deps) {
+  return {
+    name: 'verify',
+    order: VERIFY_ORDER,
+    async run(context) {
+      const expected = deps.expectedIds();
+
+      // No recorded expectation is not the same as expecting an empty device.
+      // Reporting every pending entry as "unrecognized" on a fresh install
+      // would be noise, not a finding.
+      if (expected === undefined) {
+        return {
+          operationCount: 0
+        };
+      }
+      const pending = await deps.engine.getPending();
+      const actual = new Set(pending.map(entry => entry.id));
+      const missing = [...expected].filter(id => !actual.has(id)).sort();
+      const unrecognized = [...actual].filter(id => !expected.has(id)).sort();
+      if (missing.length === 0 && unrecognized.length === 0) {
+        return {
+          operationCount: 0
+        };
+      }
+      const discrepancy = {
+        missing,
+        unrecognized,
+        detectedAt: context.now
+      };
+      deps.emit?.(_errors.DIAGNOSTIC_CODES.PENDING_SET_DISCREPANCY, `Pending set differs from expectation: ${missing.length} expected but absent, ${unrecognized.length} present but unrecognized. ` + 'Reported only — run reconciliation to repair, since the package cannot distinguish a restoration gap from an intentional change.', {
+        missing: missing.length,
+        unrecognized: unrecognized.length
+      });
+      return {
+        operationCount: 0,
+        discrepancy,
+        // Verification repairs nothing, so it cancels nothing.
+        cancelledIds: []
+      };
+    }
+  };
+}
+//# sourceMappingURL=verify.js.map

package/lib/commonjs/maintenance/verify.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","VERIFY_ORDER","exports","createVerifyStep","deps","name","order","run","context","expected","expectedIds","undefined","operationCount","pending","engine","getPending","actual","Set","map","entry","id","missing","filter","has","sort","unrecognized","length","discrepancy","detectedAt","now","emit","DIAGNOSTIC_CODES","PENDING_SET_DISCREPANCY","cancelledIds"],"sourceRoot":"../../../src","sources":["maintenance/verify.ts"],"mappings":";;;;;;;AAqBA,IAAAA,OAAA,GAAAC,OAAA;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOO,MAAMC,YAAY,GAAAC,OAAA,CAAAD,YAAA,GAAG,EAAE;AAavB,SAASE,gBAAgBA,CAACC,IAA4B,EAAmB;EAC/E,OAAO;IACNC,IAAI,EAAE,QAAQ;IACdC,KAAK,EAAEL,YAAY;IAEnB,MAAMM,GAAGA,CAACC,OAA2B,EAAwB;MAC5D,MAAMC,QAAQ,GAAGL,IAAI,CAACM,WAAW,CAAC,CAAC;;MAEnC;MACA;MACA;MACA,IAAID,QAAQ,KAAKE,SAAS,EAAE;QAC3B,OAAO;UAAEC,cAAc,EAAE;QAAE,CAAC;MAC7B;MAEA,MAAMC,OAAO,GAAG,MAAMT,IAAI,CAACU,MAAM,CAACC,UAAU,CAAC,CAAC;MAC9C,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAACJ,OAAO,CAACK,GAAG,CAACC,KAAK,IAAIA,KAAK,CAACC,EAAE,CAAC,CAAC;MAEtD,MAAMC,OAAO,GAAG,CAAC,GAAGZ,QAAQ,CAAC,CAACa,MAAM,CAACF,EAAE,IAAI,CAACJ,MAAM,CAACO,GAAG,CAACH,EAAE,CAAC,CAAC,CAACI,IAAI,CAAC,CAAC;MAClE,MAAMC,YAAY,GAAG,CAAC,GAAGT,MAAM,CAAC,CAACM,MAAM,CAACF,EAAE,IAAI,CAACX,QAAQ,CAACc,GAAG,CAACH,EAAE,CAAC,CAAC,CAACI,IAAI,CAAC,CAAC;MAEvE,IAAIH,OAAO,CAACK,MAAM,KAAK,CAAC,IAAID,YAAY,CAACC,MAAM,KAAK,CAAC,EAAE;QACtD,OAAO;UAAEd,cAAc,EAAE;QAAE,CAAC;MAC7B;MAEA,MAAMe,WAA+B,GAAG;QACvCN,OAAO;QACPI,YAAY;QACZG,UAAU,EAAEpB,OAAO,CAACqB;MACrB,CAAC;MAEDzB,IAAI,CAAC0B,IAAI,GACRC,wBAAgB,CAACC,uBAAuB,EACxC,yCAAyCX,OAAO,CAACK,MAAM,yBAAyBD,YAAY,CAACC,MAAM,6BAA6B,GAC/H,kIAAkI,EACnI;QAAEL,OAAO,EAAEA,OAAO,CAACK,MAAM;QAAED,YAAY,EAAEA,YAAY,CAACC;MAAO,CAC9D,CAAC;MAED,OAAO;QACNd,cAAc,EAAE,CAAC;QACjBe,WAAW;QACX;QACAM,YAAY,EAAE;MACf,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/maintenance/window-refresh.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WINDOW_REFRESH_ORDER = void 0;
+exports.createWindowRefreshStep = createWindowRefreshStep;
+/**
+ * The window-refresh maintenance step.
+ *
+ * Runs at order 15 — after re-anchoring (10) so it expands against corrected
+ * instants, before verification (20) so verification sees the refreshed set
+ * rather than reporting occurrences the refresh was about to add.
+ *
+ * This step is the reason automatic maintenance exists at all: only the package
+ * knows when a series' horizon has moved, and it can act on that without ever
+ * needing a desired set from the consumer.
+ */
+
+const WINDOW_REFRESH_ORDER = exports.WINDOW_REFRESH_ORDER = 15;
+function createWindowRefreshStep(deps) {
+  return {
+    name: 'window-refresh',
+    order: WINDOW_REFRESH_ORDER,
+    async run(_context) {
+      const rules = deps.registeredRules();
+      if (rules.length === 0) {
+        return {
+          operationCount: 0,
+          windowRefreshed: false
+        };
+      }
+      let scheduled = 0;
+      const cancelled = [];
+      for (const rule of rules) {
+        const result = await deps.recurrence.refreshSeries(rule);
+        scheduled += result.scheduled;
+        cancelled.push(...(result.cancelled ?? []));
+      }
+      return {
+        operationCount: scheduled + cancelled.length,
+        occurrencesScheduled: scheduled,
+        // A refresh that found nothing to add still ran; reporting it as
+        // refreshed distinguishes "nothing due" from "step never executed".
+        windowRefreshed: true,
+        // Only stale occurrences of series the package owns; reported so the
+        // registry's scope guard checks them rather than taking it on trust.
+        cancelledIds: cancelled
+      };
+    }
+  };
+}
+//# sourceMappingURL=window-refresh.js.map

package/lib/commonjs/maintenance/window-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WINDOW_REFRESH_ORDER","exports","createWindowRefreshStep","deps","name","order","run","_context","rules","registeredRules","length","operationCount","windowRefreshed","scheduled","cancelled","rule","result","recurrence","refreshSeries","push","occurrencesScheduled","cancelledIds"],"sourceRoot":"../../../src","sources":["maintenance/window-refresh.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,MAAMA,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA,GAAG,EAAE;AAe/B,SAASE,uBAAuBA,CAACC,IAA+B,EAAmB;EACzF,OAAO;IACNC,IAAI,EAAE,gBAAgB;IACtBC,KAAK,EAAEL,oBAAoB;IAE3B,MAAMM,GAAGA,CAACC,QAA4B,EAAwB;MAC7D,MAAMC,KAAK,GAAGL,IAAI,CAACM,eAAe,CAAC,CAAC;MACpC,IAAID,KAAK,CAACE,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO;UAAEC,cAAc,EAAE,CAAC;UAAEC,eAAe,EAAE;QAAM,CAAC;MACrD;MAEA,IAAIC,SAAS,GAAG,CAAC;MACjB,MAAMC,SAAmB,GAAG,EAAE;MAE9B,KAAK,MAAMC,IAAI,IAAIP,KAAK,EAAE;QACzB,MAAMQ,MAAM,GAAG,MAAMb,IAAI,CAACc,UAAU,CAACC,aAAa,CAACH,IAAI,CAAC;QACxDF,SAAS,IAAIG,MAAM,CAACH,SAAS;QAC7BC,SAAS,CAACK,IAAI,CAAC,IAAIH,MAAM,CAACF,SAAS,IAAI,EAAE,CAAC,CAAC;MAC5C;MAEA,OAAO;QACNH,cAAc,EAAEE,SAAS,GAAGC,SAAS,CAACJ,MAAM;QAC5CU,oBAAoB,EAAEP,SAAS;QAC/B;QACA;QACAD,eAAe,EAAE,IAAI;QACrB;QACA;QACAS,YAAY,EAAEP;MACf,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/notifications.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNotifications = createNotifications;
+var _toneMap = require("./channel/tone-map.js");
+var _snapshot = require("./diagnostics/snapshot.js");
+var _notifyKitEngine = require("./engine/notify-kit-engine.js");
+var _index = require("./engine/notify-kit/platform/index.js");
+var _initialize = require("./initialize.js");
+var _index2 = require("./interaction/index.js");
+var _permissionRefresh = require("./maintenance/permission-refresh.js");
+var _reanchor = require("./maintenance/reanchor.js");
+var _windowRefresh = require("./maintenance/window-refresh.js");
+var _index3 = require("./permission/index.js");
+var _index4 = require("./reconcile/index.js");
+var _index5 = require("./recurrence/index.js");
+var _index6 = require("./schedule/index.js");
+var _anchor = require("./schedule/anchor.js");
+var _mmkvStore = require("./state/mmkv-store.js");
+/**
+ * One call that assembles the whole package (NOT-07).
+ *
+ * Until 0.5.0 an app wired a dozen factories itself — scheduler, reconciler,
+ * recurrence, permissions, channels, interactions, snapshot, maintenance steps
+ * — repeating the engine, tone resolver, clock and time-zone reader for each,
+ * and usually hard-coding `canScheduleExactly: () => true`. `createNotifications`
+ * does that wiring once, the way the package means it:
+ *
+ * - every part reports through the one redacting diagnostic emitter;
+ * - `canScheduleExactly` follows the exact-alarm permission the package last
+ *   read, instead of a guess;
+ * - automatic maintenance has the standard steps registered (re-anchoring after
+ *   a time-zone change, refreshing permissions, and refreshing recurrence
+ *   windows when the app supplies its rules), so it does something on every
+ *   return to the foreground.
+ *
+ * The individual factories stay exported for an app that needs a different
+ * wiring; they are also available from `@chipmobilesdk/rn-notification/advanced`.
+ */
+
+/** Exact scheduling only on a positive answer; unknown degrades to approximate, never fails. */
+function allowsExact(state) {
+  return state === 'granted' || state === 'notRequired';
+}
+async function createNotifications(config, deps = {}) {
+  const engine = deps.engine ?? (0, _notifyKitEngine.createNotifyKitEngine)();
+  const now = deps.now ?? (() => Date.now());
+  const timeZone = deps.timeZone ?? (0, _anchor.createPlatformTimeZoneReader)();
+  const {
+    runtime,
+    result
+  } = await (0, _initialize.initialize)(config, {
+    engine,
+    store: deps.store ?? (0, _mmkvStore.createMmkvStore)(),
+    now,
+    timeZone
+  });
+  const {
+    state
+  } = runtime;
+  const emit = (code, message, context) => runtime.emitter.emit(code, message, context);
+  const resolveTone = (0, _toneMap.createToneResolver)(config.tones);
+  const permissions = (0, _index3.createPermissions)({
+    engine,
+    state,
+    platform: deps.platform ?? (0, _index.detectPlatform)(),
+    now,
+    emit
+  });
+  let exactAlarm;
+  const stopWatchingPermissions = permissions.onPermissionChange(report => {
+    exactAlarm = report.exactAlarm;
+  });
+  // Seeds the answer before anything is scheduled. A failed read leaves it
+  // unknown, which schedules in approximate mode rather than failing.
+  await permissions.getPermissions().catch(() => undefined);
+  const canScheduleExactly = () => allowsExact(exactAlarm);
+  const scheduling = {
+    engine,
+    resolveTone,
+    timeZone,
+    now,
+    canScheduleExactly,
+    emit
+  };
+  const scheduler = (0, _index6.createScheduler)(scheduling);
+  const reconcilerCore = (0, _index4.createReconciler)(scheduling);
+  let lastReconcile;
+  const reconciler = {
+    ...reconcilerCore,
+    async reconcile(input) {
+      lastReconcile = await reconcilerCore.reconcile(input);
+      return lastReconcile;
+    }
+  };
+  const recurrence = (0, _index5.createRecurrence)({
+    ...scheduling,
+    state,
+    lookahead: runtime.lookahead
+  });
+  const interactions = (0, _index2.createInteractions)({
+    engine,
+    state,
+    now,
+    emit
+  });
+  let lastExplicit;
+  const snapshot = (0, _snapshot.createSnapshot)({
+    engine,
+    state,
+    now,
+    permissions: () => permissions.getPermissions(),
+    restrictions: () => permissions.getBackgroundRestrictions(),
+    appliedTones: () => runtime.channels.appliedVersions(),
+    lastReconcile: () => lastReconcile,
+    lastMaintenance: () => runtime.lastAutomaticMaintenance() ?? lastExplicit,
+    hasPushToken: deps.hasPushToken ?? (() => false)
+  });
+  const unregister = [runtime.registry.register((0, _reanchor.createReAnchorStep)({
+    engine,
+    timeZone,
+    resolveTone,
+    canScheduleExactly,
+    emit
+  })), runtime.registry.register((0, _permissionRefresh.createPermissionRefreshStep)({
+    permissions
+  })), ...(deps.recurrenceRules ? [runtime.registry.register((0, _windowRefresh.createWindowRefreshStep)({
+    recurrence,
+    registeredRules: deps.recurrenceRules,
+    emit
+  }))] : [])];
+  return {
+    scheduler,
+    reconciler,
+    recurrence,
+    permissions,
+    channels: runtime.channels,
+    interactions,
+    snapshot,
+    runtime,
+    initialization: result,
+    timeZone,
+    onInteraction: handler => interactions.onInteraction(handler),
+    async runMaintenance() {
+      lastExplicit = await runtime.maintenance.runExplicit();
+      return lastExplicit;
+    },
+    canScheduleExactly,
+    dispose() {
+      stopWatchingPermissions();
+      for (const remove of unregister) {
+        remove();
+      }
+      interactions.dispose();
+      runtime.dispose();
+    }
+  };
+}
+//# sourceMappingURL=notifications.js.map

package/lib/commonjs/notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_toneMap","require","_snapshot","_notifyKitEngine","_index","_initialize","_index2","_permissionRefresh","_reanchor","_windowRefresh","_index3","_index4","_index5","_index6","_anchor","_mmkvStore","allowsExact","state","createNotifications","config","deps","engine","createNotifyKitEngine","now","Date","timeZone","createPlatformTimeZoneReader","runtime","result","initialize","store","createMmkvStore","emit","code","message","context","emitter","resolveTone","createToneResolver","tones","permissions","createPermissions","platform","detectPlatform","exactAlarm","stopWatchingPermissions","onPermissionChange","report","getPermissions","catch","undefined","canScheduleExactly","scheduling","scheduler","createScheduler","reconcilerCore","createReconciler","lastReconcile","reconciler","reconcile","input","recurrence","createRecurrence","lookahead","interactions","createInteractions","lastExplicit","snapshot","createSnapshot","restrictions","getBackgroundRestrictions","appliedTones","channels","appliedVersions","lastMaintenance","lastAutomaticMaintenance","hasPushToken","unregister","registry","register","createReAnchorStep","createPermissionRefreshStep","recurrenceRules","createWindowRefreshStep","registeredRules","initialization","onInteraction","handler","runMaintenance","maintenance","runExplicit","dispose","remove"],"sourceRoot":"../../src","sources":["notifications.ts"],"mappings":";;;;;;AAqBA,IAAAA,QAAA,GAAAC,OAAA;AAMA,IAAAC,SAAA,GAAAD,OAAA;AAEA,IAAAE,gBAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,WAAA,GAAAJ,OAAA;AACA,IAAAK,OAAA,GAAAL,OAAA;AACA,IAAAM,kBAAA,GAAAN,OAAA;AACA,IAAAO,SAAA,GAAAP,OAAA;AACA,IAAAQ,cAAA,GAAAR,OAAA;AACA,IAAAS,OAAA,GAAAT,OAAA;AAEA,IAAAU,OAAA,GAAAV,OAAA;AACA,IAAAW,OAAA,GAAAX,OAAA;AACA,IAAAY,OAAA,GAAAZ,OAAA;AACA,IAAAa,OAAA,GAAAb,OAAA;AACA,IAAAc,UAAA,GAAAd,OAAA;AA1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAqEA;AACA,SAASe,WAAWA,CAACC,KAAkC,EAAW;EACjE,OAAOA,KAAK,KAAK,SAAS,IAAIA,KAAK,KAAK,aAAa;AACtD;AAEO,eAAeC,mBAAmBA,CACxCC,MAA0B,EAC1BC,IAA+B,GAAG,CAAC,CAAC,EACX;EACzB,MAAMC,MAAM,GAAGD,IAAI,CAACC,MAAM,IAAI,IAAAC,sCAAqB,EAAC,CAAC;EACrD,MAAMC,GAAG,GAAGH,IAAI,CAACG,GAAG,KAAK,MAAMC,IAAI,CAACD,GAAG,CAAC,CAAC,CAAC;EAC1C,MAAME,QAAQ,GAAGL,IAAI,CAACK,QAAQ,IAAI,IAAAC,oCAA4B,EAAC,CAAC;EAChE,MAAM;IAAEC,OAAO;IAAEC;EAAO,CAAC,GAAG,MAAM,IAAAC,sBAAU,EAACV,MAAM,EAAE;IACpDE,MAAM;IACNS,KAAK,EAAEV,IAAI,CAACU,KAAK,IAAI,IAAAC,0BAAe,EAAC,CAAC;IACtCR,GAAG;IACHE;EACD,CAAC,CAAC;EACF,MAAM;IAAER;EAAM,CAAC,GAAGU,OAAO;EACzB,MAAMK,IAAI,GAAGA,CAACC,IAAY,EAAEC,OAAe,EAAEC,OAAiC,KAC7ER,OAAO,CAACS,OAAO,CAACJ,IAAI,CAACC,IAAI,EAAoBC,OAAO,EAAEC,OAAO,CAAC;EAC/D,MAAME,WAAW,GAAG,IAAAC,2BAAkB,EAACnB,MAAM,CAACoB,KAAK,CAAC;EAEpD,MAAMC,WAAW,GAAG,IAAAC,yBAAiB,EAAC;IACrCpB,MAAM;IACNJ,KAAK;IACLyB,QAAQ,EAAEtB,IAAI,CAACsB,QAAQ,IAAI,IAAAC,qBAAc,EAAC,CAAC;IAC3CpB,GAAG;IACHS;EACD,CAAC,CAAC;EACF,IAAIY,UAAuC;EAC3C,MAAMC,uBAAuB,GAAGL,WAAW,CAACM,kBAAkB,CAACC,MAAM,IAAI;IACxEH,UAAU,GAAGG,MAAM,CAACH,UAAU;EAC/B,CAAC,CAAC;EACF;EACA;EACA,MAAMJ,WAAW,CAACQ,cAAc,CAAC,CAAC,CAACC,KAAK,CAAC,MAAMC,SAAS,CAAC;EACzD,MAAMC,kBAAkB,GAAGA,CAAA,KAAMnC,WAAW,CAAC4B,UAAU,CAAC;EAExD,MAAMQ,UAAU,GAAG;IAAE/B,MAAM;IAAEgB,WAAW;IAAEZ,QAAQ;IAAEF,GAAG;IAAE4B,kBAAkB;IAAEnB;EAAK,CAAC;EACnF,MAAMqB,SAAS,GAAG,IAAAC,uBAAe,EAACF,UAAU,CAAC;EAC7C,MAAMG,cAAc,GAAG,IAAAC,wBAAgB,EAACJ,UAAU,CAAC;EACnD,IAAIK,aAA0C;EAC9C,MAAMC,UAAsB,GAAG;IAC9B,GAAGH,cAAc;IACjB,MAAMI,SAASA,CAACC,KAAK,EAAE;MACtBH,aAAa,GAAG,MAAMF,cAAc,CAACI,SAAS,CAACC,KAAK,CAAC;MACrD,OAAOH,aAAa;IACrB;EACD,CAAC;EACD,MAAMI,UAAU,GAAG,IAAAC,wBAAgB,EAAC;IAAE,GAAGV,UAAU;IAAEnC,KAAK;IAAE8C,SAAS,EAAEpC,OAAO,CAACoC;EAAU,CAAC,CAAC;EAC3F,MAAMC,YAAY,GAAG,IAAAC,0BAAkB,EAAC;IAAE5C,MAAM;IAAEJ,KAAK;IAAEM,GAAG;IAAES;EAAK,CAAC,CAAC;EAErE,IAAIkC,YAA2C;EAC/C,MAAMC,QAAQ,GAAG,IAAAC,wBAAc,EAAC;IAC/B/C,MAAM;IACNJ,KAAK;IACLM,GAAG;IACHiB,WAAW,EAAEA,CAAA,KAAMA,WAAW,CAACQ,cAAc,CAAC,CAAC;IAC/CqB,YAAY,EAAEA,CAAA,KAAM7B,WAAW,CAAC8B,yBAAyB,CAAC,CAAC;IAC3DC,YAAY,EAAEA,CAAA,KAAM5C,OAAO,CAAC6C,QAAQ,CAACC,eAAe,CAAC,CAAC;IACtDhB,aAAa,EAAEA,CAAA,KAAMA,aAAa;IAClCiB,eAAe,EAAEA,CAAA,KAAM/C,OAAO,CAACgD,wBAAwB,CAAC,CAAC,IAAIT,YAAY;IACzEU,YAAY,EAAExD,IAAI,CAACwD,YAAY,KAAK,MAAM,KAAK;EAChD,CAAC,CAAC;EAEF,MAAMC,UAAU,GAAG,CAClBlD,OAAO,CAACmD,QAAQ,CAACC,QAAQ,CACxB,IAAAC,4BAAkB,EAAC;IAAE3D,MAAM;IAAEI,QAAQ;IAAEY,WAAW;IAAEc,kBAAkB;IAAEnB;EAAK,CAAC,CAC/E,CAAC,EACDL,OAAO,CAACmD,QAAQ,CAACC,QAAQ,CAAC,IAAAE,8CAA2B,EAAC;IAAEzC;EAAY,CAAC,CAAC,CAAC,EACvE,IAAIpB,IAAI,CAAC8D,eAAe,GACrB,CACAvD,OAAO,CAACmD,QAAQ,CAACC,QAAQ,CACxB,IAAAI,sCAAuB,EAAC;IAAEtB,UAAU;IAAEuB,eAAe,EAAEhE,IAAI,CAAC8D,eAAe;IAAElD;EAAK,CAAC,CACpF,CAAC,CACD,GACA,EAAE,CAAC,CACN;EAED,OAAO;IACNqB,SAAS;IACTK,UAAU;IACVG,UAAU;IACVrB,WAAW;IACXgC,QAAQ,EAAE7C,OAAO,CAAC6C,QAAQ;IAC1BR,YAAY;IACZG,QAAQ;IACRxC,OAAO;IACP0D,cAAc,EAAEzD,MAAM;IACtBH,QAAQ;IACR6D,aAAa,EAAEC,OAAO,IAAIvB,YAAY,CAACsB,aAAa,CAACC,OAAO,CAAC;IAC7D,MAAMC,cAAcA,CAAA,EAAG;MACtBtB,YAAY,GAAG,MAAMvC,OAAO,CAAC8D,WAAW,CAACC,WAAW,CAAC,CAAC;MACtD,OAAOxB,YAAY;IACpB,CAAC;IACDf,kBAAkB;IAClBwC,OAAOA,CAAA,EAAG;MACT9C,uBAAuB,CAAC,CAAC;MACzB,KAAK,MAAM+C,MAAM,IAAIf,UAAU,EAAE;QAChCe,MAAM,CAAC,CAAC;MACT;MACA5B,YAAY,CAAC2B,OAAO,CAAC,CAAC;MACtBhE,OAAO,CAACgE,OAAO,CAAC,CAAC;IAClB;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}