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

package/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- Added `createTracerRegistry()` to create isolated trace listeners and tracers for each application or Pinia instance
+- Added the `Tracer` class and registry methods `addTraceListener()`, `clearTraceListeners()` and `hasTraceListeners()`
+- Added `createConsoleTraceListener()` as an opt-in console sink for trace events
+- Added `trace()` and `traceError()` to `Store` and `PluginSubscription`
+- Added trace types: `TraceEvent`, `TraceEventMetadata`, `TraceFilter`, `TraceHandler`, `TraceLevel`, `TraceListener`, `TraceListenerRemover`, `TracePayload`, `TracerOptions`
+- Added `check:leaks` script and `scripts/check-dist-leaks.mjs`, guarding published artifacts against non-peer dependency imports in `dist/` (`.js` and `.d.ts`)
+- Added the leak guard to `npm run build` and to the CI workflow
+- Added unit tests covering the tracing system and the leak detection logic
+
+### Changed
+- Clarified that SSR tracing registries and plugin instances must be created per request, and added coverage for listener isolation between registries
+- Replaced the `Debug` abstract class with composition: `Store` and `PluginSubscription` no longer extend it and now own a `Tracer`
+- `createPlugin()` accepts `PluginSubscriptionOptions`, including a `createTracer` factory to connect a tracer registry to plugin and store trace events
+- Trace errors with no matching listener, and failures in listener filters or handlers, are now reported with `console.error` instead of rethrowing the original error
+- Deprecated `createHydrationPlugin()` in favor of `createPlugin()` with hydration options
+- Trace payloads are now lazily resolved, so unobserved tracing no longer builds log arguments
+- Internal log messages became structured namespaces (`plugin:invoke`, `store:mutation`, `subscription:delivery`, …) carrying `store.$id` as `scope`
+- `Tracer` now delegates all output decisions to listeners and no longer owns a console or an enabled state
+- Error events are delivered to matching listeners and reported with `console.error` when none match
+- Excluded `scripts/**` from coverage thresholds, as build tooling is not shipped to consumers
+
+### Removed
+- **Breaking:** removed `debugLog()` and `logError()` from `Store` and `PluginSubscription` — use `trace()` and `traceError()` instead (see the migration snippet in `README.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`
+- Removed the internal `src/system/Debug.ts` abstract class (was never publicly exported)
+- **Breaking:** replaced module-global trace-listener functions with methods on a `createTracerRegistry()` instance
+
 ## [0.2.1]
 
 ### Fixed
@@ -97,7 +129,6 @@ Minor change
 - `getDefineAStoreSetupContext()` now falls back to store ID lookup during plugin execution timing.
 - `defineAStoreSetup()` now stores setup contexts only for stores with `storeOptions.enhancedStore = true`.
 - `defineAStoreSetup()` now removes ID-indexed setup contexts after weak-map registration and on store disposal.
-- `defineAStoreSetup()` now logs setup-context map size transitions when `storeOptions.debug = true`.
 - Public exports now include `defineAStoreCtx`, `getEnhancedStore`, and `setEnhancedStore`.
 - GitHub Actions now publishes GitHub pre-releases to npm with the `beta` dist-tag.
 

package/README.md

@@ -47,15 +47,14 @@ Register the plugin in your `main.ts`:
 ```js
 import { createApp } from 'vue'
 import { createPinia } from 'pinia'
-import { createPlugin, PLUGIN_NAME } from 'pinia-plugin-subscription'
+import { createPlugin } from 'pinia-plugin-subscription'
 import { myStoreSubscriber } from './plugins/my-store'
 import App from './App.vue'
 
 const app = createApp(App)
 const pinia = createPinia()
 
-// Register plugin (subscribers array, plugins to debug)
-pinia.use(createPlugin([myStoreSubscriber], [PLUGIN_NAME]))
+pinia.use(createPlugin([myStoreSubscriber]))
 
 app.use(pinia)
 app.mount('#app')
@@ -63,6 +62,114 @@ app.mount('#app')
 
 ### Import subpaths
 
+## 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).
+- **Reset callbacks:** Define `resetStoreCallback` to run custom logic when a store is reset.
+- **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[]): PiniaPlugin`
+
+Creates and returns a Pinia plugin from the provided `subscribers`. Each subscriber is invoked when a store is registered.
+
+### `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
@@ -77,10 +184,147 @@ 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(namespace, payload?)` — emits a structured trace event scoped to the store.
+  - `traceError(namespace, error, payload?)` — 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 one registry per application or Pinia instance, then pass its `createTracer` factory to `createPlugin()` so plugin and store events share its listeners. 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
+
+```ts
+import { createPlugin, createTracerRegistry } from 'pinia-plugin-subscription'
+
+const traceRegistry = createTracerRegistry()
+const remove = traceRegistry.addTraceListener({
+  filter: (event) => event.scope === 'cart' && event.namespace.startsWith('subscription:'),
+  handler: (event) => console.log(event.namespace, event.scope, event.payload)
+})
+
+pinia.use(createPlugin(subscribers, {
+  createTracer: traceRegistry.createTracer
+}))
+
+remove() // unsubscribe
+```
+
+`filter` is evaluated on every event, so you can narrow tracing to a single store without rebuilding. Registries do not share listeners with one another.
+
+### Event shape
+
+| Field | Description |
+| --- | --- |
+| `namespace` | Structured identifier, e.g. `subscription:delivery` |
+| `source` | Emitting class name, e.g. `PluginSubscription` |
+| `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 |
+
+Namespaces emitted by the plugin: `plugin:invoke`, `store:action`, `store:mutation`, `store:reset`, `subscription:delivery`, `subscriber:execute`, `subscriber:hydrate`, `subscriber:afterHydration`.
+
+### Emitting your own events
+
+```ts
+class CartStore extends Store {
+  hydrate() {
+    this.trace('cart:hydrate', () => ({ items: this.state.items }))
+  }
+}
+```
+
+Always prefer the **function form** for `payload`: it is only invoked once a listener matches, so unobserved tracing costs nothing.
+
+### Console listener
+
+Normal trace events do not write to a console. Console output for those events is an opt-in listener:
+
+```ts
+import {
+  createTracerRegistry,
+  createConsoleTraceListener
+} from 'pinia-plugin-subscription'
+
+const traceRegistry = createTracerRegistry()
+const remove = traceRegistry.addTraceListener(createConsoleTraceListener())
+```
+
+By default, this listener uses the styled plugin console. Pass any object exposing `log` and `error` to use another target:
+
+Any object exposing `log` and `error` satisfies the `Console` interface, so external logging libraries can be connected without this plugin depending on them:
+
+```ts
+const remove = traceRegistry.addTraceListener(createConsoleTraceListener(myLogger))
+```
+
+### 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:
+
+```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. The library build remains `npm run build` and is intentionally kept separate from the demo entry. The demo ships a complete plugin-authoring example in [`src/demo/extending-pinia-store/`](src/demo/extending-pinia-store/).
 - `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
+```
+
+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/`.
+
 ## License
 
 MIT

package/SECURITY.md

@@ -35,7 +35,25 @@ When using pinia-plugin-subscription:
 1. **Keep Dependencies Updated:** Regularly update Pinia, Vue, and other dependencies to the latest versions
 2. **Review Plugin Code:** Always review subscriber code before using in production
 3. **Validate Store Data:** Validate data before storing in Pinia stores
-4. **Debug Mode:** Disable debug mode in production (set `false` when calling `createPlugin`)
+
+### 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.
+
+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.
+
+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.
+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.
 
 ## Dependencies Security
 

package/dist/chunks/constantes-BsD73jkk.js

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