pinia-plugin-subscription 0.2.0 → 1.0.0-beta.0

package/dist/pinia-plugin-subscription.js

@@ -1,179 +1,177 @@
-var g = Object.defineProperty;
-var E = (n, s, t) => s in n ? g(n, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[s] = t;
-var a = (n, s, t) => E(n, typeof s != "symbol" ? s + "" : s, t);
-import { h as O, g as f, D as m, i as y, P as C } from "./chunks/index-VL_PgzVK.js";
-import { C as T, p as W, a as L, S as I, d as q, b as G, c as U, e as z, f as B, s as J } from "./chunks/index-VL_PgzVK.js";
-import { toRaw as _ } from "vue";
-function u(n) {
+var k = Object.defineProperty;
+var E = (r, t, e) => t in r ? k(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var c = (r, t, e) => E(r, typeof t != "symbol" ? t + "" : t, e);
+import { h as O, g as b, i as _ } from "./chunks/constantes-BsD73jkk.js";
+import { p as K, P as M, S as x, d as F, a as W, b as I, c as q, e as z, s as G } from "./chunks/constantes-BsD73jkk.js";
+import { toRaw as y } from "vue";
+function h(r) {
   if (typeof structuredClone == "function")
     try {
-      return structuredClone(n);
+      return structuredClone(r);
     } catch {
     }
-  if (n === null || typeof n != "object")
-    return n;
-  if (n instanceof Map)
+  if (r === null || typeof r != "object")
+    return r;
+  if (r instanceof Map)
     return new Map(
-      Array.from(n.entries(), ([t, e]) => [u(t), u(e)])
+      Array.from(r.entries(), ([e, i]) => [h(e), h(i)])
     );
-  if (n instanceof Set)
-    return new Set(Array.from(n.values(), (t) => u(t)));
-  if (Array.isArray(n))
-    return n.map((t) => u(t));
-  if (Object.getPrototypeOf(n) === Object.prototype || Object.getPrototypeOf(n) === null)
+  if (r instanceof Set)
+    return new Set(Array.from(r.values(), (e) => h(e)));
+  if (Array.isArray(r))
+    return r.map((e) => h(e));
+  if (Object.getPrototypeOf(r) === Object.prototype || Object.getPrototypeOf(r) === null)
     return Object.fromEntries(
-      Object.entries(n).map(([t, e]) => [t, u(e)])
+      Object.entries(r).map(([e, i]) => [e, h(i)])
     );
-  const s = Object.create(Object.getPrototypeOf(n));
-  for (const [t, e] of Object.entries(n))
-    s[t] = u(e);
-  return s;
+  const t = Object.create(Object.getPrototypeOf(r));
+  for (const [e, i] of Object.entries(r))
+    t[e] = h(i);
+  return t;
 }
-function $(n, s = "all") {
-  if (Array.isArray(s)) {
-    const t = {};
-    for (const e of s)
-      e in n && (t[e] = u(_(n[e])));
-    return t;
-  }
-  if (s !== "all")
-    throw new Error(`Invalid keys parameter: ${s}`);
-  return u(_(n));
+function g(r, t = "all") {
+  if (Array.isArray(t)) {
+    const e = {};
+    for (const i of t)
+      i in r && (e[i] = h(y(r[i])));
+    return e;
+  }
+  if (t !== "all")
+    throw new Error(`Invalid keys parameter: ${t}`);
+  return h(y(r));
 }
-class v {
+class $ {
   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 }, i = []) => {
-      const r = s[t];
-      if (typeof r != "function" || O(t))
+    c(this, "_stateSnapshots", /* @__PURE__ */ new Map());
+    c(this, "_storeHasRollbackSnapshots", /* @__PURE__ */ new Set());
+    c(this, "_storeRollbackSnapshotsParams", /* @__PURE__ */ new Map());
+  }
+  addRollbackAction(t) {
+    typeof t.$rollbackAfterFailure != "function" && (t.$rollbackAfterFailure = async ({ action: e, stateKeys: i }, s = []) => {
+      const n = t[e];
+      if (typeof n != "function" || O(e))
         return;
-      const o = !e || e.length === 0 ? "all" : e, h = this.saveStateSnapshot(s, t, o);
+      const o = !i || i.length === 0 ? "all" : i, a = this.saveStateSnapshot(t, e, o);
       try {
-        await r.apply(s, i);
-      } catch (c) {
-        throw this.patchStore(h, s), c;
+        await n.apply(t, s);
+      } catch (l) {
+        throw this.patchStore(a, t), l;
       } finally {
-        this.removeStateSnapshot(h);
+        this.removeStateSnapshot(a);
       }
     });
   }
-  createOnActionCallbacks(s, t) {
-    const e = this._storeRollbackSnapshotsParams.get(
-      f(s, t)
+  createOnActionCallbacks(t, e) {
+    const i = this._storeRollbackSnapshotsParams.get(
+      b(t, e)
     );
-    if (!e || e.length === 0)
+    if (!i)
       return;
-    const i = this.saveStateSnapshot(t, s, e);
+    const s = i.length === 0 ? "all" : i, n = this.saveStateSnapshot(e, t, s);
     return {
       after: () => {
-        this.removeStateSnapshot(i);
+        this.removeStateSnapshot(n);
       },
       onError: () => {
-        this.patchStore(i, t), this.removeStateSnapshot(i);
+        this.patchStore(n, e), this.removeStateSnapshot(n);
       }
     };
   }
-  initFromPluginContext({ options: s, store: t }) {
-    const e = s?.storeOptions?.rollbackAfterFailure;
-    e && !this._storeHasRollbackSnapshots.has(t.$id) && (Object.keys(e).forEach((i) => {
+  initFromPluginContext({ options: t, store: e }) {
+    const i = t?.storeOptions?.rollbackAfterFailure;
+    i && !this._storeHasRollbackSnapshots.has(e.$id) && (Object.keys(i).forEach((s) => {
       this._storeRollbackSnapshotsParams.set(
-        f(i, t),
-        e[i]
+        b(s, e),
+        i[s]
       );
-    }), 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)
+    }), this._storeHasRollbackSnapshots.add(e.$id)), this.addRollbackAction(e);
+  }
+  clearStoreTracking(t) {
+    const e = `-${t.$id}`;
+    for (const i of Array.from(this._storeRollbackSnapshotsParams.keys()))
+      i.endsWith(e) && this._storeRollbackSnapshotsParams.delete(i);
+    this._storeHasRollbackSnapshots.delete(t.$id);
+    for (const i of Array.from(this._stateSnapshots.keys()))
+      i.description?.startsWith(`${t.$id}:`) && this._stateSnapshots.delete(i);
+  }
+  patchStore(t, e) {
+    const i = this._stateSnapshots.get(t);
+    if (i)
       try {
-        t.$patch(e);
-      } catch (i) {
-        console.error(`Failed to patch store with snapshot ${String(s)}`, i);
+        e.$patch(i);
+      } catch (s) {
+        console.error(`Failed to patch store with snapshot ${String(t)}`, s);
       }
   }
-  removeStateSnapshot(s) {
-    s && this._stateSnapshots.delete(s);
+  removeStateSnapshot(t) {
+    t && this._stateSnapshots.delete(t);
   }
-  saveStateSnapshot(s, t, e) {
-    const i = $(
-      s.$state,
-      e
-    ), r = /* @__PURE__ */ Symbol(`${s.$id}:${t}`);
-    return this._stateSnapshots.set(r, i), r;
+  saveStateSnapshot(t, e, i) {
+    const s = g(
+      t.$state,
+      i
+    ), n = /* @__PURE__ */ Symbol(`${t.$id}:${e}`);
+    return this._stateSnapshots.set(n, s), n;
   }
-  storeHasRollbackSnapshots(s) {
-    return this._storeHasRollbackSnapshots.has(s.$id);
+  storeHasRollbackSnapshots(t) {
+    return this._storeHasRollbackSnapshots.has(t.$id);
   }
 }
-const A = "PluginSubscription", P = {
+const m = "PluginSubscription", C = {
   environment: "both",
   hydration: "immediate"
 };
-function R(n) {
+function w(r) {
   if (typeof window < "u" && typeof window.requestAnimationFrame == "function") {
-    window.requestAnimationFrame(() => globalThis.setTimeout(n, 0));
+    window.requestAnimationFrame(() => globalThis.setTimeout(r, 0));
     return;
   }
-  globalThis.setTimeout(n, 0);
+  globalThis.setTimeout(r, 0);
 }
-function D(n) {
-  return n !== void 0 && !Array.isArray(n);
-}
-class k extends m {
-  constructor(t, e, i) {
-    const r = Array.isArray(e) ? e : void 0, o = D(e) ? e : i;
-    super(Array.isArray(r) && !!r?.includes(A), C);
-    a(this, "_className", A);
-    a(this, "_hydrationScheduler");
-    a(this, "_onActionSubscriptions", []);
-    a(this, "_onActionAfterSubscriptions", {});
-    a(this, "_onActionOnErrorSubscriptions", {});
-    a(this, "_options");
-    a(this, "_pluginDebug");
-    a(this, "_resetStoreCallback", []);
-    a(this, "_storeRollbackSnapshotsHandler", new v());
-    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 = o?.hydrationScheduler ?? R, this._options = o, this._pluginDebug = Array.isArray(r) ? r : void 0, this._subscribers = t;
+class A {
+  constructor(t, e) {
+    c(this, "_className", m);
+    c(this, "_hydrationScheduler");
+    c(this, "_onActionSubscriptions", /* @__PURE__ */ new Map());
+    c(this, "_onActionStores", /* @__PURE__ */ new Set());
+    c(this, "_onActionAfterSubscriptions", {});
+    c(this, "_onActionOnErrorSubscriptions", {});
+    c(this, "_options");
+    c(this, "_resetStoreCallback", /* @__PURE__ */ new Map());
+    c(this, "_disposedStores", /* @__PURE__ */ new WeakSet());
+    c(this, "_storeRollbackSnapshotsHandler", new $());
+    c(this, "_subscribers", []);
+    c(this, "_subscribersDelivered", /* @__PURE__ */ new Set());
+    c(this, "_subscribersScheduled", /* @__PURE__ */ new Set());
+    c(this, "_subscriptions", []);
+    c(this, "_subscriptionsDelivered", /* @__PURE__ */ new Set());
+    c(this, "_subscriptionsScheduled", /* @__PURE__ */ new Set());
+    c(this, "_tracer");
+    this._hydrationScheduler = e?.hydrationScheduler ?? w, this._options = e, this._subscribers = t, this.initializeTracer();
   }
   set subscribers(t) {
     this._subscribers = t;
   }
   get subscriptions() {
-    if (!y(this._subscriptions))
+    if (!_(this._subscriptions))
       return this._subscriptions;
   }
   addOnActionAfterCallback(t, e, i) {
-    const r = f(t, e);
-    this._onActionAfterSubscriptions[r] || (this._onActionAfterSubscriptions[r] = []), this._onActionAfterSubscriptions[r]?.push(i);
+    const s = b(t, e);
+    this._onActionAfterSubscriptions[s] || (this._onActionAfterSubscriptions[s] = []), this._onActionAfterSubscriptions[s]?.push(i);
   }
   addOnActionOnErrorCallback(t, e, i) {
-    const r = f(t, e);
-    this._onActionOnErrorSubscriptions[r] || (this._onActionOnErrorSubscriptions[r] = []), this._onActionOnErrorSubscriptions[r]?.push(i);
+    const s = b(t, e);
+    this._onActionOnErrorSubscriptions[s] || (this._onActionOnErrorSubscriptions[s] = []), this._onActionOnErrorSubscriptions[s]?.push(i);
   }
-  addResetStoreCallback(t) {
-    this._resetStoreCallback.push(t);
+  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 i of Array.from(this._subscribersDelivered))
       i.endsWith(e) && this._subscribersDelivered.delete(i);
@@ -201,22 +199,19 @@ class k extends m {
   createRollbackSnapshot(t, e) {
     const {
       after: i,
-      onError: r
+      onError: s
     } = this._storeRollbackSnapshotsHandler.createOnActionCallbacks(
       t,
       e
     ) ?? {};
-    !i || !r || (this.addOnActionAfterCallback(t, e, i), this.addOnActionOnErrorCallback(t, e, r));
+    !i || !s || (this.addOnActionAfterCallback(t, e, i), this.addOnActionOnErrorCallback(t, e, s));
   }
   defineCurrentEnvironment() {
     return this._options?.runtimeEnvironment ?? (typeof window > "u" ? "server" : "client");
   }
-  definePluginDebug(t) {
-    return !!this._pluginDebug?.includes(t.name);
-  }
   definePluginExecution(t) {
     return {
-      ...P,
+      ...C,
       ...this._options?.execution ?? {},
       ...t.execution ?? {},
       ...this._options?.subscriberExecution?.[t.name] ?? {}
@@ -232,75 +227,80 @@ class k extends m {
     return `${t}-${e.$id}`;
   }
   executeResetStoreCallbacks(t) {
-    this._resetStoreCallback.forEach((e) => e(t));
+    this._resetStoreCallback.get(t)?.forEach((e) => e(t));
   }
   executeStoreOnActionSubscription(t) {
-    const e = this._onActionSubscriptions, i = this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t);
-    !e?.length && !i || t.$onAction(({ after: r, args: o, name: h, onError: c }) => {
-      const l = f(h, t);
-      this.debugLog(`storeOnActionSubscription ${l}`, { args: o, name: h, store: t }), i && this.createRollbackSnapshot(h, t), e?.length && e.forEach((b) => b({
-        after: this.createOnActionAfterCallbackCollector(h, t),
-        args: o,
-        name: h,
-        onError: this.createOnActionOnErrorCallbackCollector(h, t)
+    if (this._onActionStores.has(t) || typeof t.$onAction != "function")
+      return;
+    const e = this._onActionSubscriptions.get(t), i = this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t);
+    !e?.size && !i || (this._onActionStores.add(t), t.$onAction(({ after: s, args: n, name: o, onError: a }) => {
+      const l = b(o, t);
+      this.trace("plugin:onAction", () => ({
+        args: n,
+        name: o,
+        store: t
+      }), t.$id), this._storeRollbackSnapshotsHandler.storeHasRollbackSnapshots(t) && this.createRollbackSnapshot(o, t);
+      const u = this._onActionSubscriptions.get(t);
+      u?.size && u.forEach((d) => d({
+        after: this.createOnActionAfterCallbackCollector(o, t),
+        args: n,
+        name: o,
+        onError: this.createOnActionOnErrorCallbackCollector(o, t)
       }));
-      const d = this._onActionAfterSubscriptions[l], S = this._onActionOnErrorSubscriptions[l];
-      this.clearOnActionCallbacksSubscriptions(l), d?.length && r((b) => {
-        d.forEach((p) => p(b));
-      }), S?.length && c((b) => {
-        S.forEach((p) => p(b));
+      const f = this._onActionAfterSubscriptions[l], p = this._onActionOnErrorSubscriptions[l];
+      this.clearOnActionCallbacksSubscriptions(l), f?.length && s((d) => {
+        f.forEach((S) => S(d));
+      }), p?.length && a((d) => {
+        p.forEach((S) => S(d));
       });
-    });
+    }));
   }
   executeSubscriber(t, e) {
-    const i = this.defineSubscriberKey(e, t.store), r = this.definePluginDebug(e);
-    if (this._subscribersDelivered.has(i) || !e.invoke(
-      t,
-      r
-    ))
+    const i = this.defineSubscriberKey(e, t.store);
+    if (this._subscribersDelivered.has(i) || !e.invoke(t, this._options?.createTracer))
       return;
     this._subscribersDelivered.add(i);
-    let o;
+    let s;
     try {
-      o = e.hydrate?.(t, r);
-    } catch (c) {
-      this.logError(c, t.store, t.options);
+      s = e.hydrate?.(t);
+    } catch (o) {
+      this.traceError("subscriber:hydrate", o, () => ({ store: t.store, options: t.options }), t.store.$id);
       return;
     }
-    const h = () => {
+    const n = () => {
       try {
-        const c = e.afterHydration?.(t, r);
-        c && typeof c.then == "function" && c.catch((l) => this.logError(l, t.store, t.options));
-      } catch (c) {
-        this.logError(c, t.store, t.options);
+        const o = e.afterHydration?.(t);
+        o && typeof o.then == "function" && o.catch((a) => this.traceError("subscriber:afterHydration", a, () => ({ store: t.store, options: t.options }), t.store.$id));
+      } catch (o) {
+        this.traceError("subscriber:afterHydration", o, () => ({ store: t.store, options: t.options }), t.store.$id);
       }
     };
-    o && typeof o.then == "function" ? o.then(() => h()).catch((c) => this.logError(c, t.store, t.options)) : h(), e.subscriptions && this.subscriptionDelivery(t, e.subscriptions), e.storeMutationSubscription && this.storeMutationSubscription(e.storeMutationSubscription), this.storeOnActionSubscription(e), e.resetStoreCallback && this.addResetStoreCallback(e.resetStoreCallback);
+    s && typeof s.then == "function" ? s.then(() => n()).catch((o) => this.traceError("subscriber:hydrate", o, () => ({ store: t.store, options: t.options }), t.store.$id)) : n(), 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 (i) {
-      this.logError(i, t.store, t.options);
+      this.traceError("subscriber:execute", i, () => ({ store: t.store, options: t.options }), t.store.$id);
     }
   }
+  initializeTracer() {
+    this._options?.createTracer && (this._tracer = this._options.createTracer("PluginSubscription"));
+  }
   plugin({ store: t, options: e }) {
     if (this._subscribers.length) {
-      this.debugLog(`plugin() - ${t.$id}`, [
-        "subscriber:",
-        this._subscribers,
-        "store:",
-        t,
-        "options:",
-        e
-      ]);
+      this.trace("plugin:invoke", () => ({
+        subscribers: this._subscribers,
+        store: t,
+        options: e
+      }), t.$id);
       try {
         this._subscribers.forEach(
           (i) => {
-            const r = this.defineSubscriberKey(i, t), o = this.definePluginExecution(i);
-            if (!(this._subscribersDelivered.has(r) || this._subscribersScheduled.has(r)) && this.shouldInvokePlugin(o)) {
-              if (this.shouldScheduleAfterHydration(o)) {
-                this.queueSubscriberExecution({ store: t, options: e }, i, r);
+            const s = this.defineSubscriberKey(i, t), n = this.definePluginExecution(i);
+            if (!(this._subscribersDelivered.has(s) || this._subscribersScheduled.has(s)) && this.shouldInvokePlugin(n)) {
+              if (this.shouldScheduleAfterHydration(n)) {
+                this.queueSubscriberExecution({ store: t, options: e }, i, s);
                 return;
               }
               this.executeSubscriber({ store: t, options: e }, i);
@@ -308,26 +308,29 @@ class k extends m {
           }
         ), this.rewriteResetStore({ store: t }, t.$state), this._storeRollbackSnapshotsHandler.initFromPluginContext({ store: t, options: e }), this.executeStoreOnActionSubscription(t), this.registerStoreCleanup(t);
       } catch (i) {
-        this.logError(i, t, e);
+        this.traceError("plugin:invoke", i, () => ({ store: t, options: e }), t.$id);
       }
     }
   }
   queueSubscriberExecution(t, e, i) {
-    const r = this.defineHydrationScheduler(e);
-    this._subscribersScheduled.add(i), r(() => {
-      this._subscribersScheduled.delete(i), this.executeSubscriberSafely(t, e);
+    const s = this.defineHydrationScheduler(e);
+    this._subscribersScheduled.add(i), s(() => {
+      this._disposedStores.has(t.store) || (this._subscribersScheduled.delete(i), this.executeSubscriberSafely(t, e));
     });
   }
   registerStoreCleanup(t) {
-    if (this._onActionSubscriptions = [], typeof t.$dispose != "function")
+    if (typeof t.$dispose != "function")
       return;
     const e = t.$dispose.bind(t), i = t;
-    i.__piniaPluginSubscriptionDisposed || (i.__piniaPluginSubscriptionDisposed = !0, t.$dispose = () => (this.clearStoreTracking(t), this._storeRollbackSnapshotsHandler.clearStoreTracking(t), e()));
+    i.__piniaPluginSubscriptionDisposed || (i.__piniaPluginSubscriptionDisposed = !0, t.$dispose = () => (this._disposedStores.add(t), this.clearStoreTracking(t), this._storeRollbackSnapshotsHandler.clearStoreTracking(t), e()));
   }
   rewriteResetStore({ store: t }, e) {
-    const i = u(e);
+    const i = h(e);
     t.$reset = () => {
-      this.debugLog("rewriteResetStore()", { initState: i, store: t }), this.executeResetStoreCallbacks(t), t.$patch(u(i));
+      this.trace("plugin:reset", () => ({
+        initState: i,
+        store: t
+      }), t.$id), this.executeResetStoreCallbacks(t), t.$patch(h(i));
     };
   }
   shouldInvokePlugin(t) {
@@ -339,95 +342,91 @@ class k extends m {
   }
   storeOnActionSubscription(t) {
     const { store: e, callback: i } = t?.storeOnActionSubscription?.() ?? {};
-    !e || !i || this._onActionSubscriptions.push(i);
+    !e || !i || (this._onActionSubscriptions.has(e) || this._onActionSubscriptions.set(e, /* @__PURE__ */ new Set()), this._onActionSubscriptions.get(e).add(i), this.executeStoreOnActionSubscription(e));
   }
   storeMutationSubscription(t) {
     const { store: e, callback: i } = t();
-    e.$subscribe((r) => {
-      this.debugLog(`$subscribe ${e.$id}`, { mutation: r, store: e }), i(r);
+    e.$subscribe((s) => {
+      this.trace("store:mutation", () => ({ mutation: s, store: e }), e.$id), i(s);
     });
   }
   subscriptionDelivery(t, e) {
-    Object.entries(e).forEach(([i, r]) => {
-      const o = this.defineSubscriptionKey(i, t.store), h = this.definePluginExecution(r.subscription);
-      if (!(this._subscriptionsDelivered.has(o) || this._subscriptionsScheduled.has(o)) && this.shouldInvokePlugin(h)) {
-        if (this.shouldScheduleAfterHydration(h)) {
-          const c = this.defineHydrationScheduler(r.subscription);
-          this._subscriptionsScheduled.add(o), c(() => {
-            this._subscriptionsScheduled.delete(o), this.subscriptionDeliverySafely(t, i, r);
+    Object.entries(e).forEach(([i, s]) => {
+      const n = this.defineSubscriptionKey(i, t.store), o = this.definePluginExecution(s.subscription);
+      if (!(this._subscriptionsDelivered.has(n) || this._subscriptionsScheduled.has(n)) && this.shouldInvokePlugin(o)) {
+        if (this.shouldScheduleAfterHydration(o)) {
+          const a = this.defineHydrationScheduler(s.subscription);
+          this._subscriptionsScheduled.add(n), a(() => {
+            this._disposedStores.has(t.store) || (this._subscriptionsScheduled.delete(n), this.subscriptionDeliverySafely(t, i, s));
           });
           return;
         }
-        this.subscriptionDeliverySafely(t, i, r);
+        this.subscriptionDeliverySafely(t, i, s);
       }
     });
   }
-  subscriptionDeliverySafely({ store: t, options: e }, i, r) {
+  subscriptionDeliverySafely({ store: t, options: e }, i, s) {
     try {
       if (this._subscriptionsDelivered.has(this.defineSubscriptionKey(i, t)))
         return;
-      const { subscription: o, subscriptionOptions: h, stores: c } = r;
-      this.debugLog(`subscriptionDelivery() - store: ${t.$id}`, [
-        "pluginName:",
-        i,
-        "subscription:",
-        o,
-        "options:",
-        r,
-        "stores:",
-        c
-      ]);
+      const { subscription: n, subscriptionOptions: o, stores: a } = s;
+      this.trace("subscription:delivery", () => ({
+        pluginName: i,
+        subscription: n,
+        options: s,
+        stores: a
+      }), t.$id);
       const l = {
-        storeOptions: { ...e?.storeOptions ?? {}, ...h }
+        storeOptions: { ...e?.storeOptions ?? {}, ...o }
       };
-      o.invoke(
-        { store: t, options: { ...e, ...l } },
-        this.debug
-      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(i, t)), y(c) || c?.forEach(
-        (d) => o.invoke(
-          {
-            store: d,
-            options: {
-              ...e,
-              ...l,
-              ...d?.storeOptions ?? {}
-            }
-          },
-          this.debug
-        )
+      n.invoke(
+        { store: t, options: { ...e, ...l } }
+      ), this._subscriptionsDelivered.add(this.defineSubscriptionKey(i, t)), _(a) || a?.forEach(
+        (u) => n.invoke({
+          store: u,
+          options: {
+            ...e,
+            ...l,
+            ...u?.storeOptions ?? {}
+          }
+        })
       );
-    } catch (o) {
-      this.logError("subscriptionDelivery()", o, t, e);
+    } catch (n) {
+      this.traceError("subscription:delivery", n, () => ({ store: t, options: e }), t.$id);
     }
   }
+  trace(t, e, i) {
+    this._tracer && this._tracer.debug(t, e, i);
+  }
+  traceError(t, e, i, s) {
+    this._tracer ? this._tracer.error(t, e, i, s) : console.error(e);
+  }
 }
-function j(n, s) {
-  const t = new k(n, s);
-  return t.plugin.bind(t);
+function H(r, t) {
+  const e = new A(r, t);
+  return e.plugin.bind(e);
 }
-function K(n, s) {
-  const t = new k(n, s?.debug, {
-    execution: s?.execution,
-    hydrationScheduler: s?.hydrationScheduler,
-    runtimeEnvironment: s?.runtimeEnvironment,
-    subscriberExecution: s?.subscriberExecution
+function D(r, t) {
+  const e = new A(r, {
+    execution: t?.execution,
+    hydrationScheduler: t?.hydrationScheduler,
+    runtimeEnvironment: t?.runtimeEnvironment,
+    subscriberExecution: t?.subscriberExecution
   });
-  return t.plugin.bind(t);
+  return e.plugin.bind(e);
 }
 export {
-  T as CustomConsole,
-  W as PLUGIN_NAME,
-  L as PluginSubscriber,
-  k as PluginSubscription,
-  I as Store,
-  K as createHydrationPlugin,
-  j as createPlugin,
-  q as defineAStore,
-  G as defineAStoreCtx,
-  U as getDefineAStoreSetupContext,
-  z as getEnhancedStore,
-  B as getExtendingStore,
-  y as isEmpty,
-  J as setEnhancedStore
+  K as PLUGIN_NAME,
+  M as PluginSubscriber,
+  A as PluginSubscription,
+  x as Store,
+  D as createHydrationPlugin,
+  H as createPlugin,
+  F as defineAStore,
+  W as defineAStoreCtx,
+  I as getDefineAStoreSetupContext,
+  q as getEnhancedStore,
+  z as getExtendingStore,
+  G as setEnhancedStore
 };
 //# sourceMappingURL=pinia-plugin-subscription.js.map