pinia-plugin-subscription 1.0.0-beta.6 → 1.0.0-beta.8

package/CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- `traceGroups` glossary, exported from `pinia-plugin-subscription/helpers`, building the `groupId` emitted by `PluginSubscription` (`onActionAfter`, `onActionError`, `onMutation`, `reset`); documented in `docs/tracing.md`
+- `createPluginSubscriber(name, invoke, optionalProps?)` factory, exported from `pinia-plugin-subscription/helpers`, to build plain-object subscribers; documented in `docs/authoring-plugins.md` and used by the demo plugin
 - Added a dedicated tracing guide, `docs/tracing.md`; the README now only presents tracing and links to it
 - Moved the API reference, import subpaths, development, `Store` summary and testing sections from `README.md` to `docs/authoring-plugins.md`
 - `createTracerRegistry({ redact })`: opt-in redaction of event payloads before they reach listeners. `true` masks a default list of sensitive keys (`password`, `token`, `secret`, `authorization`, API/private keys, `credential`, `cookie`, `cipher`...); an object adds custom `keys`, a `replacement`, or drops the defaults with `includeDefaults: false`. It works on a copy, covers arrays/`Map`/`Set`, handles circular references, and replaces the payload by `__traceRedactionError` if redaction fails. `defaultRedactedKeys` and `TraceRedactOptions` are exported

package/README.md

@@ -61,54 +61,6 @@ app.use(pinia)
 app.mount('#app')
 ```
 
-## Usage — Examples
-
-**1) Subscriber using a `Store` subclass:**
-
-```typescript
-import PluginSubscriber from 'pinia-plugin-subscription'
-import { Store } from 'pinia-plugin-subscription'
-
-class MyPlugin extends Store {
-  protected override _className: string = 'MyPlugin'
-  protected static override _requiredKeys?: string[] | undefined = ['my-plugin-option']
-
-  constructor(store, options) {
-    super(store, options)
-    this.doSomething()
-  }
-}
-
-class MyPluginSubscriber extends PluginSubscriber<MyPlugin> {
-  constructor() {
-    super('my-plugin', MyPlugin.customizeStore.bind(MyPlugin))
-  }
-}
-
-export const myStoreSubscriber = new MyPluginSubscriber()
-```
-
-**2) Simple subscriber implementing `PluginSubscriberInterface`:**
-
-```typescript
-import type { PluginSubscriberInterface } from 'pinia-plugin-subscription'
-
-export const myStoreSubscriber: PluginSubscriberInterface = {
-  name: 'my-plugin',
-
-  invoke: (context) => {
-    // context contains `store`, `options`, `pinia`
-    console.log('store registered', context.store.$id)
-
-    return true
-  },
-
-  resetStoreCallback: (store) => {
-    console.log('store reset:', store.$id)
-  }
-}
-```
-
 ## Advanced Features
 
 - **Structured tracing:** Subscribe to typed trace events and filter them at runtime, per store or per namespace — see [Tracing](#tracing).

package/dist/chunks/PluginSubscription-C_a6v8oi.js

@@ -0,0 +1,576 @@
+var w = Object.defineProperty;
+var H = (i, s, t) => s in i ? w(i, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[s] = t;
+var a = (i, s, t) => H(i, typeof s != "symbol" ? s + "" : s, t);
+import { toRaw as k } from "vue";
+import { defineStore as E } from "pinia";
+function u(i) {
+  if (typeof structuredClone == "function")
+    try {
+      return structuredClone(i);
+    } catch {
+    }
+  if (i === null || typeof i != "object")
+    return i;
+  if (i instanceof Map)
+    return new Map(
+      Array.from(i.entries(), ([t, e]) => [u(t), u(e)])
+    );
+  if (i instanceof Set)
+    return new Set(Array.from(i.values(), (t) => u(t)));
+  if (Array.isArray(i))
+    return i.map((t) => u(t));
+  if (Object.getPrototypeOf(i) === Object.prototype || Object.getPrototypeOf(i) === null)
+    return Object.fromEntries(
+      Object.entries(i).map(([t, e]) => [t, u(e)])
+    );
+  const s = Object.create(Object.getPrototypeOf(i));
+  for (const [t, e] of Object.entries(i))
+    s[t] = u(e);
+  return s;
+}
+function R(i, s = "all") {
+  if (Array.isArray(s)) {
+    const t = {};
+    for (const e of s)
+      e in i && (t[e] = u(k(i[e])));
+    return t;
+  }
+  if (s !== "all")
+    throw new Error(`Invalid keys parameter: ${s}`);
+  return u(k(i));
+}
+const A = /* @__PURE__ */ new WeakMap(), b = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new WeakSet();
+function x(i, s) {
+  if ($.has(i) || typeof i.$dispose != "function")
+    return;
+  const t = i.$dispose;
+  i.$dispose = (...e) => (A.delete(i), b.delete(s), t.apply(i, e)), $.add(i);
+}
+function N(i, s, t) {
+  const e = t ? { storeOptions: t } : {};
+  return typeof s == "function" ? g(
+    i,
+    s,
+    e
+  ) : v(
+    i,
+    s,
+    e
+  );
+}
+function q(i, s, t) {
+  const e = t ? { storeOptions: { ...t, enhancedStore: !0 } } : { storeOptions: { enhancedStore: !0 } };
+  return g(
+    i,
+    s,
+    e
+  );
+}
+function g(i, s, t) {
+  const e = {
+    id: i,
+    extensions: {}
+  }, r = t?.storeOptions?.enhancedStore === !0, n = E(
+    i,
+    () => s(e),
+    t
+  );
+  return Object.assign(((...c) => {
+    r && b.set(i, e);
+    const o = n(...c);
+    return r && (A.set(o, e), b.delete(i), x(o, i)), o;
+  }), n);
+}
+function v(i, s, t) {
+  return t && (s = { ...s, ...t ?? {} }), E(i, s);
+}
+const P = /* @__PURE__ */ new Set(["_", "$"]);
+function T(i) {
+  return P.has(i[0]);
+}
+function z(i) {
+  const s = i;
+  return A.get(i) ?? (typeof s?.$id == "string" ? b.get(s.$id) : void 0);
+}
+function B(i) {
+  const s = i.extensions.enhancedStore ?? i.extensions.extending;
+  if (!s)
+    throw new Error(`${i.id}Store - getEnhancedStore - Error: enhanced store is required`);
+  return s;
+}
+function J(i, s) {
+  i.extensions.enhancedStore = s, i.extensions.extending = s;
+}
+function S(i, s) {
+  return `${i}-${s.$id}`;
+}
+class D {
+  constructor() {
+    a(this, "_stateSnapshots", /* @__PURE__ */ new Map());
+    a(this, "_storeHasRollbackSnapshots", /* @__PURE__ */ new Set());
+    a(this, "_storeRollbackSnapshotsParams", /* @__PURE__ */ new Map());
+  }
+  addRollbackAction(s) {
+    typeof s.$rollbackAfterFailure != "function" && (s.$rollbackAfterFailure = async ({ action: t, stateKeys: e }, r = []) => {
+      const n = s[t];
+      if (typeof n != "function" || T(t))
+        return;
+      const c = !e || e.length === 0 ? "all" : e, o = this.saveStateSnapshot(s, t, c);
+      try {
+        await n.apply(s, r);
+      } catch (h) {
+        throw this.patchStore(o, s), h;
+      } finally {
+        this.removeStateSnapshot(o);
+      }
+    });
+  }
+  createOnActionCallbacks(s, t) {
+    const e = this._storeRollbackSnapshotsParams.get(
+      S(s, t)
+    );
+    if (!e)
+      return;
+    const r = e.length === 0 ? "all" : e, n = this.saveStateSnapshot(t, s, r);
+    return {
+      after: () => {
+        this.removeStateSnapshot(n);
+      },
+      onError: () => {
+        this.patchStore(n, t), this.removeStateSnapshot(n);
+      }
+    };
+  }
+  initFromPluginContext({ options: s, store: t }) {
+    const e = s?.storeOptions?.rollbackAfterFailure;
+    e && !this._storeHasRollbackSnapshots.has(t.$id) && (Object.keys(e).forEach((r) => {
+      const n = e[r];
+      n && this._storeRollbackSnapshotsParams.set(
+        S(r, t),
+        n
+      );
+    }), this._storeHasRollbackSnapshots.add(t.$id)), this.addRollbackAction(t);
+  }
+  clearStoreTracking(s) {
+    const t = `-${s.$id}`;
+    for (const e of Array.from(this._storeRollbackSnapshotsParams.keys()))
+      e.endsWith(t) && this._storeRollbackSnapshotsParams.delete(e);
+    this._storeHasRollbackSnapshots.delete(s.$id);
+    for (const e of Array.from(this._stateSnapshots.keys()))
+      e.description?.startsWith(`${s.$id}:`) && this._stateSnapshots.delete(e);
+  }
+  patchStore(s, t) {
+    const e = this._stateSnapshots.get(s);
+    if (e)
+      try {
+        t.$patch(e);
+      } catch (r) {
+        console.error(`Failed to patch store with snapshot ${String(s)}`, r);
+      }
+  }
+  removeStateSnapshot(s) {
+    s && this._stateSnapshots.delete(s);
+  }
+  saveStateSnapshot(s, t, e) {
+    const r = R(
+      s.$state,
+      e
+    ), n = /* @__PURE__ */ Symbol(`${s.$id}:${t}`);
+    return this._stateSnapshots.set(n, r), n;
+  }
+  storeHasRollbackSnapshots(s) {
+    return this._storeHasRollbackSnapshots.has(s.$id);
+  }
+}
+class G {
+  constructor() {
+    a(this, "_tracer");
+    a(this, "_traceOptions", {
+      addClassNameToLabel: !0
+    });
+  }
+  get classNameAddedToTraceNamespace() {
+    return this._traceOptions.addClassNameToLabel === !0;
+  }
+  set classNameAddedToTraceNamespace(s) {
+    this._traceOptions.addClassNameToLabel = s;
+  }
+  get tracer() {
+    return this._tracer;
+  }
+  trace(s, t, e, r) {
+    const n = this.tracer;
+    n && (s = this.traceLabelFormatter(s), n.debug(s, r ?? s.toLowerCase(), e, t));
+  }
+  traceError(s, t, e, r, n) {
+    const c = this.tracer;
+    c ? (s = this.traceLabelFormatter(s), c.error(s, n ?? s.toLowerCase(), t, r, e)) : console.error(t);
+  }
+  traceLabelFormatter(s) {
+    return this.classNameAddedToTraceNamespace ? `${this._className}:${s}` : s;
+  }
+}
+function O(i) {
+  return i ? Array.isArray(i) ? i.length === 0 : typeof i == "object" ? Object.keys(i).length === 0 : typeof i == "string" ? i.trim() === "" : !1 : !(typeof i == "boolean" || typeof i == "number");
+}
+const j = "pinia-plugin-subscription", C = "PluginSubscription", Q = C.toLowerCase(), d = {
+  onActionAfter: (i) => `store:onAction:after:${i}`,
+  onActionError: (i) => `store:onAction:onError:${i}`,
+  onMutation: (i) => `store:onMutation:${i}`,
+  reset: (i) => `store:reset:${i}`
+}, M = C, F = {
+  environment: "both",
+  hydration: "immediate"
+};
+function I(i) {
+  if (typeof window < "u" && typeof window.requestAnimationFrame == "function") {
+    window.requestAnimationFrame(() => globalThis.setTimeout(i, 0));
+    return;
+  }
+  globalThis.setTimeout(i, 0);
+}
+class U extends G {
+  constructor(t, e) {
+    super();
+    a(this, "_className", M);
+    a(this, "_hydrationScheduler");
+    a(this, "_onActionSubscriptions", /* @__PURE__ */ new Map());
+    a(this, "_onActionStores", /* @__PURE__ */ new Set());
+    a(this, "_onActionAfterSubscriptions", {});
+    a(this, "_onActionOnErrorSubscriptions", {});
+    a(this, "_options");
+    a(this, "_resetStoreCallback", /* @__PURE__ */ new Map());
+    a(this, "_disposedStores", /* @__PURE__ */ new WeakSet());
+    a(this, "_storeRollbackSnapshotsHandler", new D());
+    a(this, "_subscribers", []);
+    a(this, "_subscribersDelivered", /* @__PURE__ */ new Set());
+    a(this, "_subscribersScheduled", /* @__PURE__ */ new Set());
+    a(this, "_subscriptions", []);
+    a(this, "_subscriptionsDelivered", /* @__PURE__ */ new Set());
+    a(this, "_subscriptionsScheduled", /* @__PURE__ */ new Set());
+    this._hydrationScheduler = e?.hydrationScheduler ?? I, this._options = e, this._subscribers = t, this.initializeTracer();
+  }
+  set subscribers(t) {
+    this._subscribers = t;
+  }
+  get subscriptions() {
+    if (!O(this._subscriptions))
+      return this._subscriptions;
+  }
+  addOnActionAfterCallback(t, e, r) {
+    const n = S(t, e);
+    this._onActionAfterSubscriptions[n] || (this._onActionAfterSubscriptions[n] = []), this._onActionAfterSubscriptions[n]?.push(r);
+  }
+  addOnActionOnErrorCallback(t, e, r) {
+    const n = S(t, e);
+    this._onActionOnErrorSubscriptions[n] || (this._onActionOnErrorSubscriptions[n] = []), this._onActionOnErrorSubscriptions[n]?.push(r);
+  }
+  addResetStoreCallback(t, e) {
+    this._resetStoreCallback.has(t) || this._resetStoreCallback.set(t, /* @__PURE__ */ new Set()), this._resetStoreCallback.get(t).add(e);
+  }
+  clearOnActionCallbacksSubscriptions(t) {
+    delete this._onActionAfterSubscriptions[t], delete this._onActionOnErrorSubscriptions[t];
+  }
+  clearStoreTracking(t) {
+    this._onActionSubscriptions.delete(t), this._onActionStores.delete(t), this._resetStoreCallback.delete(t);
+    const e = `-${t.$id}`;
+    for (const r of Array.from(this._subscribersDelivered))
+      r.endsWith(e) && this._subscribersDelivered.delete(r);
+    for (const r of Array.from(this._subscribersScheduled))
+      r.endsWith(e) && this._subscribersScheduled.delete(r);
+    for (const r of Array.from(this._subscriptionsDelivered))
+      r.endsWith(e) && this._subscriptionsDelivered.delete(r);
+    for (const r of Array.from(this._subscriptionsScheduled))
+      r.endsWith(e) && this._subscriptionsScheduled.delete(r);
+    for (const r of Object.keys(this._onActionAfterSubscriptions))
+      r.endsWith(e) && delete this._onActionAfterSubscriptions[r];
+    for (const r of Object.keys(this._onActionOnErrorSubscriptions))
+      r.endsWith(e) && delete this._onActionOnErrorSubscriptions[r];
+  }
+  createOnActionAfterCallbackCollector(t, e) {
+    return (r) => {
+      this.addOnActionAfterCallback(t, e, r);
+    };
+  }
+  createOnActionOnErrorCallbackCollector(t, e) {
+    return (r) => {
+      this.addOnActionOnErrorCallback(t, e, r);
+    };
+  }
+  createRollbackSnapshot(t, e) {
+    const {
+      after: r,
+      onError: n
+    } = this._storeRollbackSnapshotsHandler.createOnActionCallbacks(
+      t,
+      e
+    ) ?? {};
+    !r || !n || (this.addOnActionAfterCallback(t, e, r), this.addOnActionOnErrorCallback(t, e, n), this.trace("store:onAction:rollbackSnapshot:created", e.$id));
+  }
+  defineCurrentEnvironment() {
+    return this._options?.runtimeEnvironment ?? (typeof window > "u" ? "server" : "client");
+  }
+  definePluginExecution(t) {
+    return {
+      ...F,
+      ...this._options?.execution ?? {},
+      ...t.execution ?? {},
+      ...this._options?.subscriberExecution?.[t.name] ?? {}
+    };
+  }
+  defineHydrationScheduler(t) {
+    return t.hydrationScheduler ?? this._hydrationScheduler;
+  }
+  defineSubscriberKey(t, e) {
+    return `${t.name}-${e.$id}`;
+  }
+  defineSubscriptionKey(t, e) {
+    return `${t}-${e.$id}`;
+  }
+  executeResetStoreCallbacks(t) {
+    this._resetStoreCallback.get(t)?.forEach((e) => e(t));
+  }
+  executeStoreOnActionSubscription(t) {
+    if (this._onActionStores.has(t) || typeof t.$onAction != "function")
+      return;
+    const e = this._onActionSubscriptions.get(t), r = this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t);
+    !e?.size && !r || (this._onActionStores.add(t), t.$onAction(({ after: n, args: c, name: o, onError: h }) => {
+      const l = this._onActionSubscriptions.get(t), p = l?.size;
+      if (!p)
+        return;
+      this.traceGroupStart(() => ({ args: c, callbacks: p, name: o }), t.$id, "onAction");
+      let _ = !1;
+      const y = () => {
+        _ || (_ = !0, this.traceGroupEnd({}, t.$id));
+      };
+      try {
+        const f = S(o, t);
+        this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t) && this.createRollbackSnapshot(o, t), l.forEach((m) => m({
+          after: this.createOnActionAfterCallbackCollector(o, t),
+          args: c,
+          name: o,
+          onError: this.createOnActionOnErrorCallbackCollector(o, t)
+        })), y(), this.executeStoreOnActionAfterCallbacks(n, f, t), this.executeStoreOnActionOnErrorCallbacks(h, f, t), this.clearOnActionCallbacksSubscriptions(f);
+      } catch (f) {
+        throw y(), f;
+      }
+    }));
+  }
+  executeStoreOnActionAfterCallbacks(t, e, r) {
+    const n = this._onActionAfterSubscriptions[e], c = n?.length;
+    c && t((o) => {
+      this.traceGroupStart(
+        () => ({
+          callbacks: c,
+          groupId: d.onActionAfter(r.$id),
+          result: o
+        }),
+        r.$id,
+        "store:onAction:after"
+      ), n.forEach((h) => {
+        try {
+          h(o);
+        } catch (l) {
+          this.traceError("storeOnActionAfterCallbacks", l, r.$id);
+        }
+      }), this.traceGroupEnd(() => ({ groupId: d.onActionAfter(r.$id) }), r.$id);
+    });
+  }
+  executeStoreOnActionOnErrorCallbacks(t, e, r) {
+    const n = this._onActionOnErrorSubscriptions[e];
+    n?.length && t((c) => {
+      this.traceGroupStart(
+        () => ({
+          callbacks: n.length,
+          error: c,
+          groupId: d.onActionError(r.$id)
+        }),
+        r.$id,
+        "store:onAction:onError"
+      ), n.forEach((o) => {
+        try {
+          o(c);
+        } catch (h) {
+          this.traceError("store:onAction:onError:error", h, r.$id);
+        }
+      }), this.traceGroupEnd(() => ({ groupId: d.onActionError(r.$id) }), r.$id);
+    });
+  }
+  executeSubscriber(t, e) {
+    const r = this.defineSubscriberKey(e, t.store);
+    if (this._subscribersDelivered.has(r) || !e.invoke(t, this._options?.tracerHandler?.createTracer))
+      return;
+    this._subscribersDelivered.add(r);
+    let n;
+    try {
+      n = e.hydrate?.(t);
+    } catch (o) {
+      this.traceError("subscriber:hydrate", o, t.store.$id);
+      return;
+    }
+    const c = () => {
+      try {
+        const o = e.afterHydration?.(t);
+        o && typeof o.then == "function" && o.catch(
+          (h) => this.traceError("subscriber:afterHydration", h, t.store.$id)
+        );
+      } catch (o) {
+        this.traceError("subscriber:afterHydration", o, t.store.$id);
+      }
+    };
+    n && typeof n.then == "function" ? n.then(() => c()).catch((o) => this.traceError("subscriber:hydrate", o, t.store.$id)) : c(), e.subscriptions && this.subscriptionDelivery(t, e.subscriptions), e.storeMutationSubscription && this.storeMutationSubscription(e.storeMutationSubscription), this.storeOnActionSubscription(e), e.resetStoreCallback && this.addResetStoreCallback(t.store, e.resetStoreCallback);
+  }
+  executeSubscriberSafely(t, e) {
+    try {
+      this.executeSubscriber(t, e);
+    } catch (r) {
+      this.traceError("subscriber:execute", r, t.store.$id);
+    }
+  }
+  initializeTracer() {
+    this._options?.tracerHandler && (this._tracer = this._options.tracerHandler.createTracer(j));
+  }
+  plugin({ store: t, options: e }) {
+    if (this._subscribers.length) {
+      this.traceGroupStart(() => ({
+        environment: this.defineCurrentEnvironment(),
+        subscribers: this._subscribers,
+        store: t,
+        options: e
+      }), t.$id);
+      try {
+        this._subscribers.forEach(
+          (r) => {
+            const n = this.defineSubscriberKey(r, t), c = this.definePluginExecution(r);
+            if (!(this._subscribersDelivered.has(n) || this._subscribersScheduled.has(n)) && this.shouldInvokePlugin(c)) {
+              if (this.shouldScheduleAfterHydration(c)) {
+                this.queueSubscriberExecution({ store: t, options: e }, r, n);
+                return;
+              }
+              this.executeSubscriber({ store: t, options: e }, r);
+            }
+          }
+        ), this.rewriteResetStore({ store: t }, t.$state), this._storeRollbackSnapshotsHandler.initFromPluginContext({ store: t, options: e }), this.executeStoreOnActionSubscription(t), this.registerStoreCleanup(t);
+      } catch (r) {
+        this.traceError("plugin:invoke", r, t.$id);
+      }
+      this.traceGroupEnd(() => ({}), t.$id);
+    }
+  }
+  queueSubscriberExecution(t, e, r) {
+    const n = this.defineHydrationScheduler(e);
+    this._subscribersScheduled.add(r), n(() => {
+      this._disposedStores.has(t.store) || (this._subscribersScheduled.delete(r), this.executeSubscriberSafely(t, e));
+    });
+  }
+  registerStoreCleanup(t) {
+    if (typeof t.$dispose != "function")
+      return;
+    const e = t.$dispose.bind(t), r = t;
+    r.__piniaPluginSubscriptionDisposed || (r.__piniaPluginSubscriptionDisposed = !0, t.$dispose = () => (this._disposedStores.add(t), this.clearStoreTracking(t), this._storeRollbackSnapshotsHandler.clearStoreTracking(t), e()));
+  }
+  rewriteResetStore({ store: t }, e) {
+    const r = u(e);
+    t.$reset = () => {
+      this.traceGroupStart(() => ({ initialState: r, groupId: d.reset(t.$id) }), t.$id, "store:reset");
+      try {
+        this.executeResetStoreCallbacks(t), t.$patch(u(r));
+      } finally {
+        this.traceGroupEnd(() => ({ initialState: r, groupId: d.reset(t.$id) }), t.$id);
+      }
+    };
+  }
+  shouldInvokePlugin(t) {
+    const e = this.defineCurrentEnvironment();
+    return t.environment === "both" || t.environment === e;
+  }
+  shouldScheduleAfterHydration(t) {
+    return this.defineCurrentEnvironment() === "client" && t.hydration === "defer";
+  }
+  storeOnActionSubscription(t) {
+    const { store: e, callback: r } = t?.storeOnActionSubscription?.() ?? {};
+    !e || !r || (this._onActionSubscriptions.has(e) || this._onActionSubscriptions.set(e, /* @__PURE__ */ new Set()), this._onActionSubscriptions.get(e).add(r), this.executeStoreOnActionSubscription(e));
+  }
+  storeMutationSubscription(t) {
+    const { store: e, callback: r } = t();
+    e.$subscribe((n) => {
+      this.traceGroupStart(() => ({ mutation: n, groupId: d.onMutation(e.$id) }), e.$id, "store:onMutation");
+      try {
+        r(n);
+      } finally {
+        this.traceGroupEnd(() => ({ mutation: n, groupId: d.onMutation(e.$id) }), e.$id);
+      }
+    });
+  }
+  subscriptionDelivery(t, e) {
+    Object.entries(e).forEach(([r, n]) => {
+      const c = this.defineSubscriptionKey(r, t.store), o = this.definePluginExecution(n.subscription);
+      if (!(this._subscriptionsDelivered.has(c) || this._subscriptionsScheduled.has(c)) && this.shouldInvokePlugin(o)) {
+        if (this.shouldScheduleAfterHydration(o)) {
+          const h = this.defineHydrationScheduler(n.subscription);
+          this._subscriptionsScheduled.add(c), h(() => {
+            this._disposedStores.has(t.store) || (this._subscriptionsScheduled.delete(c), this.subscriptionDeliverySafely(t, r, n));
+          });
+          return;
+        }
+        this.subscriptionDeliverySafely(t, r, n);
+      }
+    });
+  }
+  subscriptionDeliverySafely({ store: t, options: e }, r, n) {
+    try {
+      if (this._subscriptionsDelivered.has(this.defineSubscriptionKey(r, t)))
+        return;
+      const { subscription: c, subscriptionOptions: o, stores: h } = n;
+      this.trace("Subscription:delivery", t.$id, () => ({
+        pluginName: r,
+        subscription: c,
+        subscriptionOptions: o
+      }));
+      const l = {
+        storeOptions: { ...e?.storeOptions ?? {}, ...o }
+      };
+      c.invoke(
+        { store: t, options: { ...e, ...l } }
+      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(r, t)), O(h) || h?.forEach(
+        (p) => c.invoke({
+          store: p,
+          options: {
+            ...e,
+            ...l,
+            ...p?.storeOptions ?? {}
+          }
+        })
+      );
+    } catch (c) {
+      this.traceError("subscription:delivery", c, t.$id);
+    }
+  }
+  traceGroupEnd(t, e) {
+    this._options?.tracerHandler && this._options.tracerHandler.closeGroup({
+      ...typeof t == "function" ? t() : t ?? {},
+      scope: e
+    });
+  }
+  traceGroupStart(t, e, r) {
+    this._options?.tracerHandler && (t = typeof t == "function" ? t() : t ?? {}, this._options.tracerHandler.startGroup({
+      ...t,
+      scope: e
+    }), this.trace(r ?? "context", e, t));
+  }
+}
+export {
+  U as P,
+  G as T,
+  Q as a,
+  q as b,
+  B as c,
+  N as d,
+  z as g,
+  T as h,
+  O as i,
+  j as p,
+  J as s,
+  d as t
+};
+//# sourceMappingURL=PluginSubscription-C_a6v8oi.js.map