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

package/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- 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
+- `createTracerRegistry({ enabled })`: tracing is now disabled by default in production builds (`process.env.NODE_ENV === 'production'`); `addListener()` becomes a no-op unless `enabled: true` is passed. `enabled: false` forces it off in any environment. Error reporting through `console.error` is unchanged
 - Added `createTracerRegistry()` to create isolated trace listeners and tracers for each application or Pinia instance
 - Added `createTracerRegistry()` to group matching trace events in the console
 - Added the `Tracer` class and registry methods `addTraceListener()`, `clearTraceListeners()` and `hasTraceListeners()`
@@ -32,9 +36,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Error events are delivered to matching listeners and reported with `console.error` when none match
 - Store trace labels can include the store class name by default, and callers can override the event namespace
 - Excluded `scripts/**` from coverage thresholds, as build tooling is not shipped to consumers
+- `Store` and `PluginSubscription` now share the abstract `TraceEmitter` class for `trace()`, `traceError()` and class-name label formatting, removing duplicated code
+- `Tracer` listener matching no longer allocates intermediate arrays beyond the matched set, and duplicated unhandled-error reporting was factored out
+- The `pluginsubscription` namespace prefix is now a shared constant (`pluginSubscriptionNamespace`) instead of a hard-coded string
+
+### Fixed
+- Trace groups opened by `onAction`, `$subscribe` and `$reset` are now always closed (also when the action fails or a callback throws), so grouped events no longer stay buffered forever
+- Listener definitions passed to `addListener()` are no longer mutated when their `filter` is an array of criteria
+- `TracerHandler` and `TraceRegistry` types now match the implementation (`createTracer(source, options?)`, `void` group callbacks, `addListener()` with options, `tracerHandler`); `createTracerRegistry()` is explicitly typed as `TraceRegistry`
+- `CustomConsole.rebuildArgs()` no longer returns `undefined` for unsupported argument types
+- `clearTraceListeners()` now empties the shared listener list in place, so tracers created before the call stop delivering to cleared listeners and see listeners registered afterwards
 
 ### Removed
-- **Breaking:** removed `debugLog()` and `logError()` from `Store` and `PluginSubscription` — use `trace()` and `traceError()` instead (see the migration snippet in `README.md`)
+- Removed the internal `PluginConsole` singleton and the dead commented code of `system/log.ts`; `CustomConsole` stays exported from `helpers` for plugins not yet migrated to the tracer
+- **Breaking:** removed `debugLog()` and `logError()` from `Store` and `PluginSubscription` — use `trace()` and `traceError()` instead (see the migration snippet in `docs/tracing.md`)
 - **Breaking:** removed the obsolete `debug` and custom-console arguments from `createPlugin()`, `PluginSubscription`, `PluginSubscriber`, `Store`, and `Store.customizeStore()`
 - **Breaking:** removed the `debug` argument from subscriber `invoke()`, `hydrate()`, and `afterHydration()` hooks; tracing is now configured exclusively through listeners
 - **Breaking:** removed the legacy `debug` and `console` accessors from `Store` and `PluginSubscription`

package/README.md

@@ -34,7 +34,8 @@ The package serves two audiences:
 | You want to… | Guide |
 | --- | --- |
 | Use a compatible plugin (e.g. `pinia-plugin-extending-store`, `pinia-plugin-persist-state`) or this package's built-in store features (`defineAStore`, `$reset`, state rollback) in your app | [Using compatible plugins](docs/using-plugins.md) |
-| Build your own pinia plugin on top of `pinia-plugin-subscription` | [Plugin authoring guide](docs/authoring-plugins.md) |
+| Build your own pinia plugin on top of `pinia-plugin-subscription` (API reference, `Store` class, import subpaths, development and testing) | [Plugin authoring guide](docs/authoring-plugins.md) |
+| Debug stores and plugins with structured trace events | [Tracing](docs/tracing.md) |
 
 ## Installation
 
@@ -60,8 +61,6 @@ app.use(pinia)
 app.mount('#app')
 ```
 
-### Import subpaths
-
 ## Usage — Examples
 
 **1) Subscriber using a `Store` subclass:**
@@ -117,238 +116,21 @@ export const myStoreSubscriber: PluginSubscriberInterface = {
 - **SSR and hydration control:** Configure whether each subscribed plugin runs on the server, the client, or only after client hydration.
 - **Lifecycle safety:** Internal hydration ordering is now guarded so `hydrate()` completes before `afterHydration()` and disposed stores do not retain stale subscriber metadata.
 
-## API Reference
-
-### `createPlugin(subscribers: PluginSubscriber[], options?: PluginSubscriptionOptions): PiniaPlugin`
-
-Creates and returns a Pinia plugin from the provided `subscribers`. Each subscriber is invoked when a store is registered. The optional `options` configure execution, hydration and tracing.
-
-### `createHydrationPlugin(subscribers: PluginSubscriber[], options?: PluginSubscriptionOptions): PiniaPlugin`
-
-Deprecated. Use `createPlugin()` with hydration options instead. This helper remains available for compatibility.
-
-```typescript
-import { createPlugin } from 'pinia-plugin-subscription'
-
-pinia.use(createPlugin([
-  persistedStateSubscriber
-], {
-  hydrationScheduler: (run) => {
-    nextTick(() => run())
-  }
-}))
-```
-
-### SSR / Nuxt hydration control
-
-The source of truth for hydration policy stays on the subscriber itself. For example, a client-only plugin should declare its execution directly:
-
-```typescript
-export const persistedStateSubscriber: PluginSubscriberInterface = {
-  name: 'persisted-state',
-  execution: {
-    environment: 'client',
-    hydration: 'defer',
-  },
-  hydrationScheduler: (run) => {
-    nextTick(() => run())
-  },
-  invoke: (context) => {
-    // ...
-    return true
-  }
-}
-```
-
-Available execution options:
-
-- `environment: 'both' | 'client' | 'server'` — controls where the subscriber is allowed to run.
-- `hydration: 'immediate' | 'defer'` — on the client, `defer` schedules execution after hydration.
-- `hydrationScheduler` can be provided on a subscriber or through `createPlugin()` options to override execution timing when needed.
-
-### SSR / Nuxt best practices
-
-`pinia-plugin-subscription` is SSR-safe by design, but the runtime policy still needs to match the actual app lifecycle.
-
-For helper-only imports, the package exposes an additive subpath kept separate from the default library API:
-
-```ts
-import { PluginSubscriber, Store } from 'pinia-plugin-subscription/helpers'
-```
-
-For type-only imports, prefer the dedicated public types entry:
-
-```ts
-import type { PluginSubscriptionOptions } from 'pinia-plugin-subscription/types'
-```
-
-## Development
-
-This example shows the recommended pattern for SSR / Nuxt-safe plugins:
-
-- `execution.environment` restricts the subscriber to `'both'`, `'client'`, or `'server'`
-- `execution.hydration` is `'immediate'` by default and can be set to `'defer'` when the plugin must wait for client hydration
-- `hydrationScheduler` lets you override the runtime scheduling behavior, for example with Nuxt/Vue `nextTick()`
-- `hydrate()` / `afterHydration()` are optional lifecycle hooks for browser-only initialization and post-hydration work; they help keep SSR-sensitive logic out of constructors
-
-## The `Store` Class — Summary
-
-The `Store` class (see [src/core/Store.ts](src/core/Store.ts)) is a wrapper around a `PiniaStore` providing:
-
-- **Properties:** `options`, `state`, `store`.
-- **Useful methods:**
-  - `addToState(name, value?)` — adds a property to store state and exposes it as a `Ref` when appropriate.
-  - `addSubscription(pluginName, subscription)` — registers a plugin-specific subscription function.
-  - `getSubscriptions()` — returns registered subscriptions.
-  - `storeSubscribe` (getter/setter) — factory for `store.$subscribe` ({ store, callback }).
-  - `onAction` (getter/setter) — factory for `onAction` ({ store, callback }).
-  - `static customizeStore(store, options)` — recommended factory for class instantiation.
-  - `trace(label, payload?, scope?, namespace?)` — emits a structured trace event, scoped to the store by default.
-  - `traceError(label, error, payload?, scope?, namespace?)` — emits an error event, or reports it with `console.error` when no listener matches.
-  - Helpers: `stateHas()`, `storeHas()`, `getValue()`.
-
 ## Tracing
 
-Tracing is **opt-in**, scoped to an explicit registry, and **allocation free when unused**. Create a trace-groups registry per application or Pinia instance, add criteria to select the events to group, then pass its `tracerHandler` to `createPlugin()` so plugin and store events share its groups. For SSR, create a fresh registry, Pinia instance, and plugin instance for every request; do not keep them in module-level state or clear a shared registry at request completion, since requests may overlap. See the [SSR guide](./docs/using-plugins.md#ssr--nuxt) for an example.
-
-### Production safety
-
-Tracing is **not automatically blocked in production**. Leave normal tracing disabled by default using your application's environment configuration; enable production diagnostics only deliberately and with limited scope and duration.
-
-Events are **not automatically redacted** and may include sensitive action arguments, store state, plugin options, or error details. Filters select events by metadata; they do not sanitize payloads. Before writing to a console or forwarding to a logging service, select an allowlist of fields and redact sensitive values rather than sending complete events.
-
-**Disabling normal tracing does not disable error reporting.** Errors can still be sent to `console.error` without a tracer or when no listener matches. See [Error reporting](#error-reporting) and the [security guidance](./SECURITY.md#tracing-and-production-logging) for precautions, including log access and retention.
-
-### Consuming events
+A built-in, opt-in debugging solution: plugins and stores emit structured trace events that you select with filters, optionally redact, and group in the console. It is disabled by default in production builds and costs nothing when unused.
 
 ```ts
 import { createPlugin } from 'pinia-plugin-subscription'
 import { createTracerRegistry } from 'pinia-plugin-subscription/helpers'
 
-const traceGroupsRegistry = createTracerRegistry()
-const remove = traceGroupsRegistry.addListener([
-  { target: 'scope', value: 'cart' },
-  { target: 'namespace', comparator: 'startsWith', value: 'pluginsubscription:subscription:' }
-])
-
-pinia.use(createPlugin(subscribers, {
-  tracerHandler: traceGroupsRegistry.tracerHandler
-}))
-
-remove() // unsubscribe
-```
-
-Criteria are evaluated against event metadata, before the payload is resolved.
-By default, all criteria must match and events are grouped by `scope`. Supported
-comparators are `equals` (the default), `contains`, `startsWith` and `endsWith`;
-set `filterMode` to `some` to match any criterion or `groupBy` to group by a
-different event metadata field:
-
-```ts
-traceGroupsRegistry.addListener([
-  { target: 'scope', value: 'cart' },
-  { target: 'namespace', comparator: 'startsWith', value: 'pluginsubscription:subscription:' }
-], { filterMode: 'every', groupBy: 'scope' })
-```
-
-The registry uses the console's grouped output for matching events.
-
-### Event shape
-
-| Field | Description |
-| --- | --- |
-| `namespace` | Structured identifier, derived from the label by default |
-| `label` | Human-readable event label |
-| `source` | Source passed to `createTracer`, usually `pinia-plugin-subscription` |
-| `scope` | Instance identifier, usually `store.$id` |
-| `payload` | Event data, resolved only when consumed |
-| `level` | `debug` or `error` |
-| `timestamp` | `Date.now()` at emission |
-| `error` | Present on `error` events |
-
-By default, `Store` prefixes its class name to labels and derived namespaces.
-Library events use `PluginSubscription` as their prefix (for example,
-`pluginsubscription:store:mutation` and
-`pluginsubscription:subscription:delivery`). Set
-`classNameAddedToTraceNamespace = false` on a `Store` subclass to omit its
-class prefix, or provide an explicit namespace as the fourth argument to
-`trace()` / `traceError()`.
-
-### Emitting your own events
-
-```ts
-class CartStore extends Store {
-  hydrate() {
-    this.trace('cart:hydrate', () => ({ items: this.state.items }))
-  }
-}
-```
-
-`Store.trace(label, payload?, scope?, namespace?)` and
-`Store.traceError(label, error, payload?, scope?, namespace?)` emit the events.
-The store class name is included in the label by default; set
-`classNameAddedToTraceNamespace = false` to omit it. Unless an explicit
-namespace is provided, the normalized label is used as the namespace.
-
-Always prefer the **function form** for `payload`: it is only invoked once a
-listener matches, so unobserved tracing costs nothing.
-
-### Grouped console output
-
-Normal trace events do not write to a console. To opt into console output grouped
-by store, configure the registry and pass its `tracerHandler` to the plugin:
-
-```ts
-import { createTracerRegistry } from 'pinia-plugin-subscription/helpers'
-
-const traceGroupsRegistry = createTracerRegistry()
-traceGroupsRegistry.addListener([{ target: 'scope', value: 'cart' }])
-
-pinia.use(createPlugin(subscribers, {
-  tracerHandler: traceGroupsRegistry.tracerHandler
-}))
-```
-
-Groups are selected by event metadata and default to grouping by `scope`. Use
-`addListener()`'s `groupBy` option to group by another metadata field.
-
-### Error reporting
-
-An error is delivered to every matching listener. If no listener matches — including when listeners exist but all filters reject the event — it is reported with `console.error`; it is not rethrown. Errors thrown by filters or handlers are also reported and isolated so they do not interrupt the traced process or remaining listeners.
-
-### Migrating from `debugLog()` / `logError()`
-
-These methods were removed in favour of structured events:
+const registry = createTracerRegistry({ redact: true })
+registry.addListener([{ target: 'scope', value: 'cart' }])
 
-```ts
-// before
-this.debugLog(`$subscribe ${store.$id}`, { mutation, store })
-this.logError('subscriptionDelivery()', error, store, options)
-
-// after
-this.trace('store:mutation', () => ({ mutation, store }))
-this.traceError('subscription:delivery', error, () => ({ store, options }))
-```
-
-The `namespace` replaces the formatted message, store trace events are scoped to `store.$id`, and the payload becomes a factory so it is only built when a listener consumes the event.
-
-## Testing
-
-- `npm run dev` — runs the dedicated demo app in [`demo/`](demo/). The library build remains `npm run build` and is intentionally kept separate from the demo entry.
-- `npm test` — runs the Vitest suite, including typecheck tests (`*.test-d.ts`) validating type-level contracts such as `StoreOptionsExtensions` merging. Coverage reports are available in `coverage/`.
-- `npm run bundle:check` — measures the emitted bundle size.
-
-### Dependency leak guard
-
-Published artifacts must only reference **peer dependencies** (`pinia`, `vue`) and Node builtins. A `devDependency` referenced from `src/` does not fail the local build, but it breaks consumers: Vite inlines runtime imports, while `tsc` keeps bare `import type` specifiers in the emitted `.d.ts`, which consumers cannot resolve.
-
-`npm run check:leaks` scans every built `.js` and `.d.ts` file and fails the build when a non-peer package appears:
-
-```bash
-npm run check:leaks
+pinia.use(createPlugin(subscribers, { tracerHandler: registry.tracerHandler }))
 ```
 
-It runs automatically as part of `npm run build` and in CI. If it reports a leak, either remove the import from `src/`, or duplicate the required type into `src/types/`.
+See the [Tracing documentation](docs/tracing.md) for filtering, redaction, production safety, event shape and error reporting.
 
 ## License
 

package/SECURITY.md

@@ -38,22 +38,22 @@ When using pinia-plugin-subscription:
 
 ### Tracing and Production Logging
 
-Normal trace events are opt-in: the plugin requires an explicitly configured `createTracer` factory and matching listeners to deliver them. The plugin does not automatically detect production environments or block tracing in production. Production tracing can be useful for incident diagnosis, but should only be enabled deliberately and with controlled access to its output.
+Normal trace events are opt-in: the plugin requires an explicitly configured `tracerHandler` and matching listeners to deliver them. `createTracerRegistry()` ignores `addListener()` in production builds (`process.env.NODE_ENV === 'production'`) unless `createTracerRegistry({ enabled: true })` is passed. This guard relies on the consuming bundler replacing `process.env.NODE_ENV`; without it, tracing is considered enabled. Production tracing can be useful for incident diagnosis, but should only be enabled deliberately and with controlled access to its output.
 
-Trace events are not automatically sanitized or redacted. Depending on the event, they may contain action arguments, store state, mutations, plugin options, subscriptions, or error details. These values can include application secrets or personal data. A listener can expose them through the browser console, server logs, or an external logging service. The absence of a production block is not, by itself, a vulnerability; the disclosure risk depends on the data emitted, the logging destination, and who can access it.
+Trace events are not redacted by default. Depending on the event, they may contain action arguments, store state, mutations, plugin options, subscriptions, or error details. These values can include application secrets or personal data. `createTracerRegistry({ redact: true })` masks values stored under sensitive keys (passwords, tokens, secrets, authorization, API keys, cookies...) before any listener receives them, but it inspects keys only: it does not detect secrets under innocuous keys, and it does not redact `event.error`. A listener can expose them through the browser console, server logs, or an external logging service. The absence of a production block is not, by itself, a vulnerability; the disclosure risk depends on the data emitted, the logging destination, and who can access it.
 
 When configuring tracing:
 
-1. **Disable Normal Tracing in Production by Default:** Use the application's environment configuration to omit `createTracer` or avoid registering normal trace listeners. Enable production diagnostics only when needed and limit their duration and scope.
-2. **Minimize Logged Data:** Select an explicit allowlist of fields and redact sensitive values before writing or forwarding events. Avoid logging complete stores, action arguments, plugin options, or raw error objects.
-3. **Do Not Treat Filters as Redaction:** Filters only select events using metadata; a matching handler receives the full event, including its resolved payload and error. Sanitize data in the handler before passing it to a logging destination.
+1. **Keep Normal Tracing Disabled in Production:** This is the default of `createTracerRegistry()`. Only pass `enabled: true` when diagnostics are needed, and limit their duration and scope.
+2. **Minimize Logged Data:** Enable `createTracerRegistry({ redact: true })` (extend it with your own `keys`) and select an explicit allowlist of fields before writing or forwarding events. Avoid logging complete stores, action arguments, plugin options, or raw error objects.
+3. **Do Not Treat Filters as Redaction:** Filters only select events using metadata; a matching handler receives the full event, including its resolved payload and error. Use the `redact` option, and sanitize `event.error` and any remaining data in the handler before passing it to a logging destination.
 4. **Protect Logging Destinations:** Review external logging services, restrict access to logs, and define appropriate retention periods. Do not assume browser console output or server logs are private.
 
 **Error reporting is separate from normal tracing.** Without a tracer, plugin and store error reporting falls back to `console.error`. With a tracer, error events also fall back to `console.error` when no listener matches, including when all filters reject the event. Exceptions thrown by listener filters or handlers are reported to `console.error` as well. Removing listeners, clearing a registry, or omitting `createTracer` therefore does not guarantee that no errors will be logged.
 
 For production, handle error events with a matching listener that reports only sanitized details, and ensure listener filters and handlers do not throw sensitive errors. Review the application's console and error logging policy as well; do not silently discard operational errors to prevent disclosure.
 
-See [Tracing](./README.md#tracing) for configuration and event details.
+See [Tracing](./docs/tracing.md) for configuration and event details.
 
 ## Dependencies Security
 

package/dist/chunks/constants-CBDmzOr_.js

@@ -0,0 +1,274 @@
+var S = Object.defineProperty;
+var f = (s, e, t) => e in s ? S(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var n = (s, e, t) => f(s, typeof e != "symbol" ? e + "" : e, t);
+import { isRef as g, ref as b, toRef as l } from "vue";
+import { defineStore as d } from "pinia";
+class P {
+  constructor(e, t) {
+    n(this, "_createInstance");
+    n(this, "_name");
+    n(this, "_pluginOptions");
+    n(this, "_storeInstance");
+    n(this, "_resetStoreCallback");
+    n(this, "_storeOnActionSubscription");
+    n(this, "_storeMutationSubscription");
+    n(this, "_subscriptions");
+    n(this, "pluginCreated");
+    n(this, "execution");
+    n(this, "hydrationScheduler");
+    this._name = e, this._createInstance = t;
+  }
+  get name() {
+    return this._name;
+  }
+  get storeInstance() {
+    return this._storeInstance;
+  }
+  get pluginOptions() {
+    return this._pluginOptions;
+  }
+  set pluginOptions(e) {
+    this._pluginOptions = e;
+  }
+  get resetStoreCallback() {
+    return this._resetStoreCallback;
+  }
+  get storeOnActionSubscription() {
+    return this._storeOnActionSubscription;
+  }
+  get storeMutationSubscription() {
+    return this._storeMutationSubscription;
+  }
+  get subscriptions() {
+    return this._subscriptions;
+  }
+  set subscriptions(e) {
+    this._subscriptions = e;
+  }
+  afterHydration(e) {
+  }
+  hydrate(e) {
+  }
+  invoke({ store: e, options: t }, r) {
+    return this._storeInstance = this._createInstance(e, {
+      ...t,
+      ...this.pluginOptions,
+      createTracer: r ? () => r?.(this.name) : void 0
+    }), this._storeInstance ? (this._subscriptions = this._storeInstance.getSubscriptions(), this._storeMutationSubscription = this._storeInstance.storeSubscribe, this._storeOnActionSubscription = this._storeInstance.onAction, this.pluginCreated && this.pluginCreated(e), !0) : !1;
+  }
+}
+class O {
+  constructor() {
+    n(this, "_tracer");
+    n(this, "_traceOptions", {
+      addClassNameToLabel: !0
+    });
+  }
+  get classNameAddedToTraceNamespace() {
+    return this._traceOptions.addClassNameToLabel === !0;
+  }
+  set classNameAddedToTraceNamespace(e) {
+    this._traceOptions.addClassNameToLabel = e;
+  }
+  get tracer() {
+    return this._tracer;
+  }
+  trace(e, t, r, i) {
+    const o = this.tracer;
+    o && (e = this.traceLabelFormatter(e), o.debug(e, i ?? e.toLowerCase(), r, t));
+  }
+  traceError(e, t, r, i, o) {
+    const a = this.tracer;
+    a ? (e = this.traceLabelFormatter(e), a.error(e, o ?? e.toLowerCase(), t, i, r)) : console.error(t);
+  }
+  traceLabelFormatter(e) {
+    return this.classNameAddedToTraceNamespace ? `${this._className}:${e}` : e;
+  }
+}
+const h = /* @__PURE__ */ new WeakMap(), c = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new WeakSet();
+function y(s, e) {
+  if (p.has(s) || typeof s.$dispose != "function")
+    return;
+  const t = s.$dispose;
+  s.$dispose = (...r) => (h.delete(s), c.delete(e), t.apply(s, r)), p.add(s);
+}
+function j(s, e, t) {
+  const r = t ? { storeOptions: t } : {};
+  return typeof e == "function" ? _(
+    s,
+    e,
+    r
+  ) : m(
+    s,
+    e,
+    r
+  );
+}
+function q(s, e, t) {
+  const r = t ? { storeOptions: { ...t, enhancedStore: !0 } } : { storeOptions: { enhancedStore: !0 } };
+  return _(
+    s,
+    e,
+    r
+  );
+}
+function _(s, e, t) {
+  const r = {
+    id: s,
+    extensions: {}
+  }, i = t?.storeOptions?.enhancedStore === !0, o = d(
+    s,
+    () => e(r),
+    t
+  );
+  return Object.assign(((...a) => {
+    i && c.set(s, r);
+    const u = o(...a);
+    return i && (h.set(u, r), c.delete(s), y(u, s)), u;
+  }), o);
+}
+function m(s, e, t) {
+  return t && (e = { ...e, ...t ?? {} }), d(s, e);
+}
+const A = /* @__PURE__ */ new Set(["_", "$"]);
+function C(s) {
+  return A.has(s[0]);
+}
+function x(s) {
+  const e = s;
+  return h.get(s) ?? (typeof e?.$id == "string" ? c.get(e.$id) : void 0);
+}
+function T(s) {
+  const e = s.extensions.enhancedStore ?? s.extensions.extending;
+  if (!e)
+    throw new Error(`${s.id}Store - getEnhancedStore - Error: enhanced store is required`);
+  return e;
+}
+function $(s, e) {
+  s.extensions.enhancedStore = e, s.extensions.extending = e;
+}
+function F(s) {
+  return console.warn(`${s.id}Store - getExtendingStore is deprecated. Use getEnhancedStore instead.`), T(s);
+}
+function K(s, e) {
+  return `${s}-${e.$id}`;
+}
+function N(s) {
+  return s ? Array.isArray(s) ? s.length === 0 : typeof s == "object" ? Object.keys(s).length === 0 : typeof s == "string" ? s.trim() === "" : !1 : !(typeof s == "boolean" || typeof s == "number");
+}
+class w extends O {
+  constructor(t, r) {
+    super();
+    n(this, "_className", "Store");
+    n(this, "_createTracer");
+    n(this, "_onAction");
+    n(this, "_options");
+    n(this, "_store");
+    n(this, "_storeSubscribe");
+    n(this, "_subscriptions", {});
+    if (this._options = r.storeOptions, this._store = t, this.initializeTracer(r), this.trace("instance:created", t.$id), this._options?.enhancedStore) {
+      const i = x(this.store);
+      i && ($(i, this.store), this.trace("setup:enhancedStore:success", this.store.$id));
+    }
+  }
+  get onAction() {
+    if (this._onAction)
+      return () => ({
+        store: this.store,
+        callback: this._onAction
+      });
+  }
+  set onAction(t) {
+    this._onAction = t;
+  }
+  get options() {
+    return this._options;
+  }
+  get state() {
+    return this._store.$state;
+  }
+  set state(t) {
+    this._store.$state = t;
+  }
+  get store() {
+    return this._store;
+  }
+  get storeSubscribe() {
+    if (this._storeSubscribe)
+      return () => ({
+        store: this.store,
+        callback: this._storeSubscribe
+      });
+  }
+  set storeSubscribe(t) {
+    this._storeSubscribe = t;
+  }
+  get tracer() {
+    return !this._tracer && this._createTracer && (this._tracer = this._createTracer(), this._tracer.scope = this.store.$id), this._tracer;
+  }
+  addToState(t, r) {
+    this.isOptionApi() || g(r) || (r = b(r)), this.state[t] = r, this.store[t] = l(this.state, t);
+  }
+  addSubscription(t, r, i) {
+    this._subscriptions[t] = { subscription: r, ...i ?? {} };
+  }
+  afterHydration() {
+  }
+  static customizeStore(t, r) {
+    if (r.storeOptions && this.hasRequiredKeys(r.storeOptions))
+      return new this(t, r);
+  }
+  getOption(t) {
+    return this.options && this.options[t];
+  }
+  getStatePropertyValue(t) {
+    return this.getValue(this.state[t]);
+  }
+  getSubscriptions() {
+    if (!N(this._subscriptions))
+      return this._subscriptions;
+  }
+  getValue(t) {
+    return t?.__v_isRef ? t.value : t;
+  }
+  hasDeniedFirstChar(t) {
+    return C(t);
+  }
+  static hasRequiredKeys(t) {
+    return this._requiredKeys !== void 0 && this._requiredKeys?.every((r) => !!t[r]);
+  }
+  hydrate() {
+  }
+  initializeTracer(t) {
+    this._createTracer = t?.createTracer;
+  }
+  isOptionApi() {
+    return this.store._isOptionsAPI;
+  }
+  stateHas(t) {
+    return Object.prototype.hasOwnProperty.call(this.state, t);
+  }
+  storeHas(t) {
+    return Object.prototype.hasOwnProperty.call(this.store, t);
+  }
+}
+n(w, "_requiredKeys");
+const M = "pinia-plugin-subscription", I = "PluginSubscription", R = I.toLowerCase();
+export {
+  P,
+  w as S,
+  O as T,
+  R as a,
+  I as b,
+  q as c,
+  j as d,
+  x as e,
+  T as f,
+  K as g,
+  C as h,
+  N as i,
+  F as j,
+  M as p,
+  $ as s
+};
+//# sourceMappingURL=constants-CBDmzOr_.js.map