pinia-plugin-subscription 0.1.8 → 0.2.0

package/dist/pinia-plugin-subscription.js

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