pinia-plugin-subscription 0.1.6 → 0.1.7-beta.1

package/dist/plugins/createHydrationPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { PiniaPlugin } from 'pinia';
+import type { PluginSubscriber, PluginSubscriptionOptions } from '../types/plugin';
+export declare function createHydrationPlugin(subscribers: PluginSubscriber[], options?: PluginSubscriptionOptions): PiniaPlugin;

package/dist/plugins/createPlugin.d.ts

@@ -0,0 +1,11 @@
+import type { PiniaPlugin } from "pinia";
+import type { PluginSubscriber } from "../types/plugin";
+import type { StoreOptions } from "../types/store";
+export declare function createPlugin(subscribers: PluginSubscriber[], debug?: string[]): PiniaPlugin;
+declare module 'pinia' {
+    interface PiniaCustomProperties {
+    }
+    interface DefineStoreOptionsBase<S, Store> {
+        storeOptions?: StoreOptions;
+    }
+}

package/dist/plugins/pluginSubscriber.d.ts

@@ -0,0 +1,35 @@
+import Store from "../core/Store";
+import type { PiniaPluginContext, Store as PiniaStore } from "pinia";
+import type { AnyObject } from "../types";
+import type { PluginExecutionOptions, PluginHydrationScheduler, PluginSubscriber as PluginSubscriberInterface, PluginSubscriptions, StoreMutationSubscription, StoreOnActionSubscription } from "../types/plugin";
+import type { Console } from "../types/log";
+type CreateInstance<Instance = Store> = (store: PiniaStore, options: AnyObject, debug: boolean, customConsole?: Console) => Instance | undefined;
+export default abstract class PluginSubscriber<Instance extends Store> implements PluginSubscriberInterface {
+    private _console?;
+    private _createInstance;
+    private _name;
+    private _pluginOptions?;
+    private _storeInstance?;
+    protected _resetStoreCallback?: (store?: PiniaStore) => void;
+    private _storeOnActionSubscription?;
+    private _storeMutationSubscription?;
+    private _subscriptions?;
+    protected pluginCreated?: (store: PiniaStore) => void;
+    execution?: PluginExecutionOptions;
+    hydrationScheduler?: PluginHydrationScheduler;
+    get console(): Console;
+    get name(): string;
+    get storeInstance(): Instance | undefined;
+    get pluginOptions(): AnyObject;
+    set pluginOptions(options: AnyObject | undefined);
+    get resetStoreCallback(): ((store?: PiniaStore) => void) | undefined;
+    get storeOnActionSubscription(): StoreOnActionSubscription | undefined;
+    get storeMutationSubscription(): StoreMutationSubscription | undefined;
+    get subscriptions(): PluginSubscriptions | undefined;
+    set subscriptions(subscriptions: PluginSubscriptions);
+    constructor(pluginName: string, createInstanceFunction: CreateInstance, pluginConsole?: Console);
+    hydrate(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
+    afterHydration(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
+    invoke({ store, options }: PiniaPluginContext, debug: boolean): boolean;
+}
+export {};

package/dist/plugins/pluginSubscription.d.ts

@@ -0,0 +1,40 @@
+import Debug from "../system/Debug";
+import type { PiniaPluginContext } from "pinia";
+import type { PluginSubscriber, PluginSubscriptionOptions, PluginSubscriptions } from "../types/plugin";
+export default class PluginSubscription extends Debug {
+    protected _className: string;
+    private _hydrationScheduler;
+    private _options?;
+    private _pluginDebug?;
+    private _resetStoreCallback;
+    private _subscribers;
+    private _subscribersDelivered;
+    private _subscribersScheduled;
+    private _subscriptions;
+    private _subscriptionsDelivered;
+    private _subscriptionsScheduled;
+    set subscribers(subscribers: PluginSubscriber[]);
+    get subscriptions(): PluginSubscriptions[] | undefined;
+    constructor(subscribers: PluginSubscriber[], debugOrOptions?: PluginSubscriptionOptions | string[], pluginOptions?: PluginSubscriptionOptions);
+    private addResetStoreCallback;
+    private defineCurrentEnvironment;
+    private definePluginDebug;
+    private definePluginExecution;
+    private defineHydrationScheduler;
+    private defineSubscriberKey;
+    private defineSubscriptionKey;
+    private executeResetStoreCallbacks;
+    private executeSubscriber;
+    private executeSubscriberSafely;
+    private queueSubscriberExecution;
+    private shouldInvokePlugin;
+    private shouldScheduleAfterHydration;
+    plugin({ store, options }: PiniaPluginContext): void;
+    private rewriteResetStore;
+    private registerStoreCleanup;
+    private clearStoreTracking;
+    private storeOnActionSubscription;
+    private storeMutationSubscription;
+    private subscriptionDelivery;
+    private subscriptionDeliverySafely;
+}

package/dist/system/Debug.d.ts

@@ -0,0 +1,13 @@
+import type { Console } from "../types/log";
+export default abstract class Debug {
+    protected abstract _className: string;
+    private _console?;
+    private _debug;
+    get console(): Console;
+    set console(customConsole: Console);
+    get debug(): boolean;
+    set debug(debug: boolean);
+    constructor(debug: boolean, customConsole?: Console);
+    debugLog(...args: any): void;
+    logError(...args: any): void;
+}

package/dist/system/log.d.ts

@@ -0,0 +1,24 @@
+import type { Console, LogType, StyleDefinition, StyleDefinitions } from '../types/log';
+export declare function log(logStyle: string, args: any): void;
+export declare abstract class CustomConsole implements Console {
+    protected _bgColor: string;
+    protected _color: string;
+    protected _icon: string;
+    protected _errorBgColor: string;
+    protected _errorColor: string;
+    protected _errorIcon: string;
+    protected abstract _pluginName: string;
+    protected _styles: StyleDefinitions;
+    protected formatMessage(message: string, icon: string): string;
+    protected generateStyle(styleDefinition: StyleDefinition): string;
+    protected getStyleDefinition(messageType?: LogType): StyleDefinition;
+    log(...args: any): void;
+    error(...args: any): void;
+    protected rebuildArgs(args: string | any[], icon: string): any[] | undefined;
+    protected useLog(styleDefinition: StyleDefinition, args: any): void;
+}
+declare class PluginConsoleClass extends CustomConsole {
+    protected _pluginName: string;
+}
+export declare const PluginConsole: PluginConsoleClass;
+export {};

package/dist/types/comparison.d.ts

@@ -0,0 +1,3 @@
+export type ComparisonNumber = '>' | '<' | '>=' | '<=';
+export type ComparisonString = 'partial' | 'strict';
+export type Comparison = ComparisonNumber | ComparisonString;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
-import type { DefineStoreOptions, PiniaCustomProperties, PiniaPlugin, PiniaPluginContext, StateTree, Store as PiniaStore, SubscriptionCallbackMutation, StoreDefinition } from "pinia";
-import type { Ref } from "vue";
+import type { PiniaPluginContext, Store as PiniaStore } from 'pinia';
+import type { PluginExecutionOptions, PluginHydrationScheduler, PluginSubscriptions, StoreMutationSubscription, StoreOnActionSubscription } from './plugin';
+import type { StoreOptions } from './store';
 export interface AnyObject {
     [key: number | string | symbol]: any;
 }
@@ -17,51 +18,9 @@ export type StyleDefinitions = Record<LogType, Record<StyleDefinitionKeys, strin
 export type ConsoleStyleDefinition = StyleDefinition;
 export type ConsoleStyleDefinitionKeys = StyleDefinitionKeys;
 export type ConsoleStyleDefinitions = StyleDefinitions;
-type OptionBaseProperty = string | number | boolean | null | undefined | object | Function;
-type ObjectBaseProperty = Record<string, OptionBaseProperty | OptionBaseProperty[]>;
-type StdStatePropertyValue = AnyObject | boolean | null | number | string | undefined;
-export type CustomStore<TStore, TState> = PiniaStore & TStore & TState & PiniaCustomProperties & StoreDefinition;
-export interface PluginStoreOptions {
-    storeOptions: StoreOptions;
-}
-export type EmptyExtensions = Record<never, never>;
-export interface DefineAStoreSetupExtensions<TEnhancedStore> {
-    /**
-     * @deprecated Use enhancedStore instead.
-     */
-    extending?: TEnhancedStore;
-    enhancedStore?: TEnhancedStore;
-}
-export interface DefineAStoreSetupContext<TEnhancedStore, TExtraExtensions extends Record<string, unknown> = EmptyExtensions> {
-    id: string;
-    extensions: DefineAStoreSetupExtensions<TEnhancedStore> & TExtraExtensions;
-}
-export type StatePropertyValue = StdStatePropertyValue | Ref<StdStatePropertyValue> | StdStatePropertyValue[] | Ref<StdStatePropertyValue[]> | Ref<StdStatePropertyValue>[];
-export type StoreOptions = Record<string, StoreOptionsPropertyValue>;
-export type StoreOptionsPropertyValue = OptionBaseProperty | OptionBaseProperty[] | ObjectBaseProperty | ObjectBaseProperty[];
-export type PluginHydrationScheduler = (callback: () => void) => void;
-export type PluginHydrationTiming = 'defer' | 'immediate';
-export type PluginRuntimeEnvironment = 'client' | 'server';
-export type PluginExecutionEnvironment = PluginRuntimeEnvironment | 'both';
-export interface PluginExecutionOptions {
-    environment?: PluginExecutionEnvironment;
-    hydration?: PluginHydrationTiming;
-}
-export interface PluginSubscriptionOptions {
-    execution?: PluginExecutionOptions;
-    hydrationScheduler?: PluginHydrationScheduler;
-    runtimeEnvironment?: PluginRuntimeEnvironment;
-    subscriberExecution?: Record<string, PluginExecutionOptions>;
-}
-export interface NativePiniaSubscriptionReturn<Callback> {
-    store: PiniaStore;
-    callback: Callback;
-}
-export interface StoreOnActionCallbackParameters {
-    after: Function;
-    args: any[] | object;
-    name: string;
-}
+export type { List, ListTypes, ListTypesMap, PartialList } from './list';
+export type { CustomStore, DefineAStoreSetupContext, DefineAStoreSetupExtensions, EmptyExtensions, PluginStoreOptions, StatePropertyValue, StoreOptions, StoreOptionsPropertyValue } from './store';
+export type { NativePiniaSubscription, NativePiniaSubscriptionReturn, PluginExecutionEnvironment, PluginExecutionOptions, PluginHydrationScheduler, PluginHydrationTiming, PluginRuntimeEnvironment, PluginSubscriber, PluginSubscription, PluginSubscriptionOptions, PluginSubscriptions, StoreMutationSubscription, StoreMutationSubscriptionCallback, StoreMutationSubscriptionReturn, StoreOnActionCallbackParameters, StoreOnActionSubscription, StoreOnActionSubscriptionCallback, StoreOnActionSubscriptionReturn, } from './plugin';
 export interface PluginSubscriberInterface {
     console?: Console;
     execution?: PluginExecutionOptions;
@@ -80,99 +39,3 @@ export interface PluginSubscriptionDefinition {
     subscription: PluginSubscriberInterface;
     subscriptionOptions?: StoreOptions;
 }
-export type PluginSubscriptions = Record<string, PluginSubscriptionDefinition>;
-export type NativePiniaSubscription<Callback> = () => NativePiniaSubscriptionReturn<Callback>;
-export type StoreOnActionSubscriptionCallback = (params: StoreOnActionCallbackParameters) => void;
-export type StoreOnActionSubscription = NativePiniaSubscription<StoreOnActionSubscriptionCallback>;
-export type StoreMutationSubscriptionCallback = (mutation: SubscriptionCallbackMutation<StateTree>) => void;
-export type StoreMutationSubscription = NativePiniaSubscription<StoreMutationSubscriptionCallback>;
-export declare const PLUGIN_NAME: string;
-export declare function createPlugin(subscribers: PluginSubscriberInterface[], debug?: string[]): PiniaPlugin;
-export declare function createHydrationPlugin(subscribers: PluginSubscriberInterface[], options?: PluginSubscriptionOptions): PiniaPlugin;
-export declare function defineAStore<Sto, Sta>(id: string, storeDefinition: Omit<DefineStoreOptions<string, StateTree & Sta, AnyObject, Partial<Sto>>, 'id'>, options?: StoreOptions): StoreDefinition & Sta & Sto;
-export declare function defineAStore<Sto, Sta>(id: string, storeDefinition: (ctx?: DefineAStoreSetupContext<AnyObject>) => AnyObject, options?: StoreOptions): StoreDefinition & Sta & Sto;
-export declare function defineAStoreCtx<Sto, Sta>(id: string, storeDefinition: (ctx: DefineAStoreSetupContext<Sto & Sta>) => AnyObject, options?: StoreOptions): StoreDefinition & Sta & Sto;
-export declare function defineAStoreCtx<Sto, Sta, TExtraExtensions extends Record<string, unknown>>(id: string, storeDefinition: (ctx: DefineAStoreSetupContext<Sto & Sta, TExtraExtensions>) => AnyObject, options?: StoreOptions): StoreDefinition & Sta & Sto;
-export declare function getDefineAStoreSetupContext(store: AnyObject): DefineAStoreSetupContext<AnyObject> | undefined;
-export declare function getEnhancedStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>): TEnhancedStore;
-export declare function setEnhancedStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>, store: TEnhancedStore): void;
-/**
- * @deprecated Use getEnhancedStore instead.
- */
-export declare function getExtendingStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>): TEnhancedStore;
-export declare function isEmpty(value: any): boolean;
-export declare abstract class Debug {
-    protected abstract _className: string;
-    console: Console;
-    debug: boolean;
-    constructor(debug: boolean, customConsole?: Console);
-    debugLog(...args: any): void;
-    logError(...args: any): void;
-}
-export declare abstract class CustomConsole implements Console {
-    protected _bgColor: string;
-    protected _color: string;
-    protected _icon: string;
-    protected _errorBgColor: string;
-    protected _errorColor: string;
-    protected _errorIcon: string;
-    protected abstract _pluginName: string;
-    log(...args: any): void;
-    error(...args: any): void;
-}
-export declare abstract class PluginSubscriber<Instance extends Store> implements PluginSubscriberInterface {
-    console: Console;
-    execution?: PluginExecutionOptions;
-    hydrate(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
-    hydrationScheduler?: PluginHydrationScheduler;
-    name: string;
-    pluginOptions: AnyObject;
-    resetStoreCallback?: (store?: PiniaStore) => void;
-    storeOnActionSubscription?: StoreOnActionSubscription;
-    storeMutationSubscription?: StoreMutationSubscription;
-    subscriptions?: PluginSubscriptions;
-    afterHydration(context: PiniaPluginContext, debug: boolean): void | Promise<void>;
-    protected pluginCreated?: (store: PiniaStore) => void;
-    protected _resetStoreCallback?: (store?: PiniaStore) => void;
-    constructor(pluginName: string, createInstanceFunction: (store: PiniaStore, options: AnyObject, debug: boolean, customConsole?: Console) => Instance | undefined, pluginConsole?: Console);
-    invoke(context: PiniaPluginContext, debug: boolean): boolean;
-    get storeInstance(): Instance | undefined;
-}
-export declare class PluginSubscription extends Debug {
-    protected _className: string;
-    constructor(subscribers: PluginSubscriberInterface[], debug?: string[], pluginOptions?: PluginSubscriptionOptions);
-    plugin(context: PiniaPluginContext): void;
-}
-export declare class Store extends Debug {
-    protected static _requiredKeys?: string[];
-    protected _className: string;
-    onAction: StoreOnActionSubscription | undefined;
-    readonly options: StoreOptions;
-    state: StateTree;
-    storeSubscribe: StoreMutationSubscriptionCallback | undefined;
-    readonly store: AnyObject;
-    hydrate(): void | Promise<void>;
-    afterHydration(): void | Promise<void>;
-    constructor(store: PiniaStore, options: AnyObject, debug?: boolean, customConsole?: Console);
-    addSubscription(pluginName: string, subscription: PluginSubscriberInterface, options?: {
-        subscriptionOptions?: StoreOptions;
-        stores?: PiniaStore[];
-    }): void;
-    addToState(name: string, value?: StatePropertyValue): void;
-    static customizeStore<Instance extends Store>(store: PiniaStore, options: AnyObject, debug?: boolean, customConsole?: Console): Instance | undefined;
-    getOption(optionName: keyof StoreOptions): StoreOptionsPropertyValue;
-    getStatePropertyValue(propertyName: string): StatePropertyValue;
-    getSubscriptions(): PluginSubscriptions | undefined;
-    getValue(value: any): any;
-    hasDeniedFirstChar(property: string): boolean;
-    protected static hasRequiredKeys(options: AnyObject): boolean;
-    isOptionApi(): boolean;
-    stateHas(property: string): boolean;
-    storeHas(property: string): boolean;
-}
-declare module 'pinia' {
-    interface DefineStoreOptionsBase<S, Store> {
-        storeOptions?: StoreOptions;
-    }
-}
-export {};

package/dist/types/list.d.ts

@@ -0,0 +1,13 @@
+export type ListTypes = "0" | "1" | "2" | "3" | "4" | "5";
+export interface List {
+    '@id'?: string | number;
+    id?: number;
+    name?: string;
+    type?: ListTypes;
+}
+export type PartialList = Omit<List, '@id' | 'id' | 'name' | 'type'> & {
+    id?: number;
+    name?: string;
+    type?: ListTypes;
+};
+export type ListTypesMap = Record<ListTypes, string>;

package/dist/types/log.d.ts

@@ -0,0 +1,8 @@
+export interface Console {
+    log(...args: any): void;
+    error(...args: any): void;
+}
+export type LogType = 'error' | 'info';
+export type StyleDefinition = Record<StyleDefinitionKeys, string>;
+export type StyleDefinitionKeys = 'bgColor' | 'color' | 'icon';
+export type StyleDefinitions = Record<LogType, Record<StyleDefinitionKeys, string>>;

package/dist/types/plugin.d.ts

@@ -0,0 +1,53 @@
+import type { PiniaPluginContext, StateTree, Store, SubscriptionCallbackMutation } from "pinia";
+import type { StoreOptions } from "./store";
+import type { Console, PluginSubscriberInterface } from ".";
+export type PluginHydrationScheduler = (callback: () => void) => void;
+export type PluginHydrationTiming = 'defer' | 'immediate';
+export type PluginRuntimeEnvironment = 'client' | 'server';
+export type PluginExecutionEnvironment = PluginRuntimeEnvironment | 'both';
+export interface PluginExecutionOptions {
+    environment?: PluginExecutionEnvironment;
+    hydration?: PluginHydrationTiming;
+}
+export interface PluginSubscriptionOptions {
+    debug?: string[];
+    execution?: PluginExecutionOptions;
+    hydrationScheduler?: PluginHydrationScheduler;
+    runtimeEnvironment?: PluginRuntimeEnvironment;
+    subscriberExecution?: Record<string, PluginExecutionOptions>;
+}
+export interface PluginSubscriber {
+    console?: Console;
+    execution?: PluginExecutionOptions;
+    hydrate?: (context: PiniaPluginContext, debug: boolean) => void | Promise<void>;
+    hydrationScheduler?: PluginHydrationScheduler;
+    invoke: (context: PiniaPluginContext, debug: boolean) => boolean;
+    name: string;
+    resetStoreCallback?: (store?: Store) => void;
+    storeOnActionSubscription?: StoreOnActionSubscription;
+    storeMutationSubscription?: StoreMutationSubscription;
+    subscriptions?: PluginSubscriptions;
+    afterHydration?: (context: PiniaPluginContext, debug: boolean) => void | Promise<void>;
+}
+export interface NativePiniaSubscriptionReturn<Callback> {
+    store: Store;
+    callback: Callback;
+}
+export interface StoreOnActionCallbackParameters {
+    after: Function;
+    args: any[] | object;
+    name: string;
+}
+export interface PluginSubscription {
+    stores?: Store[];
+    subscription: PluginSubscriberInterface;
+    subscriptionOptions?: StoreOptions;
+}
+export type PluginSubscriptions = Record<string, PluginSubscription>;
+export type NativePiniaSubscription<Callback> = () => NativePiniaSubscriptionReturn<Callback>;
+export type StoreOnActionSubscriptionCallback = (params: StoreOnActionCallbackParameters) => void;
+export type StoreOnActionSubscriptionReturn = NativePiniaSubscriptionReturn<StoreOnActionSubscriptionCallback>;
+export type StoreOnActionSubscription = NativePiniaSubscription<StoreOnActionSubscriptionCallback>;
+export type StoreMutationSubscriptionCallback = (mutation: SubscriptionCallbackMutation<StateTree>) => void;
+export type StoreMutationSubscriptionReturn = NativePiniaSubscriptionReturn<StoreMutationSubscriptionCallback>;
+export type StoreMutationSubscription = NativePiniaSubscription<StoreMutationSubscriptionCallback>;

package/dist/types/resourceId.d.ts

@@ -0,0 +1,4 @@
+export interface ResourceId {
+    "@id"?: string;
+    id?: number;
+}

package/dist/types/store.d.ts

@@ -0,0 +1,27 @@
+import type { AnyObject } from ".";
+import type { PiniaCustomProperties, Store, StoreDefinition } from "pinia";
+import type { Ref } from "vue";
+export type CustomStore<TStore, TState> = Store & TStore & TState & PiniaCustomProperties & StoreDefinition;
+export type EmptyExtensions = Record<never, never>;
+export interface DefineAStoreSetupExtensions<TEnhancedStore> {
+    /**
+     * @deprecated Use enhancedStore instead.
+     */
+    extending?: TEnhancedStore;
+    enhancedStore?: TEnhancedStore;
+}
+export interface DefineAStoreSetupContext<TEnhancedStore, TExtraExtensions extends Record<string, unknown> = EmptyExtensions> {
+    id: string;
+    extensions: DefineAStoreSetupExtensions<TEnhancedStore> & TExtraExtensions;
+}
+export type DefineAugmentedStore<TStore, TState> = (args?: any) => CustomStore<TStore, TState>;
+export type ObjectBaseProperty = Record<string, OptionBaseProperty | OptionBaseProperty[]>;
+export type OptionBaseProperty = string | number | boolean | null | undefined | object | Function;
+export interface PluginStoreOptions {
+    storeOptions: StoreOptions;
+}
+export type StatePropertyValue = StdStatePropertyValue | Ref<StdStatePropertyValue> | StdStatePropertyValue[] | Ref<StdStatePropertyValue[]> | Ref<StdStatePropertyValue>[];
+type StdStatePropertyValue = AnyObject | boolean | null | number | string | undefined;
+export type StoreOptions = Record<string, StoreOptionsPropertyValue>;
+export type StoreOptionsPropertyValue = OptionBaseProperty | OptionBaseProperty[] | ObjectBaseProperty | ObjectBaseProperty[];
+export {};

package/dist/utils/Performance.d.ts

@@ -0,0 +1,9 @@
+export default class Performance {
+    duration: number;
+    endTime: number;
+    name: string;
+    startTime: number;
+    constructor(name: string);
+    getStyle(): string;
+    stop(): void;
+}

package/dist/utils/constantes.d.ts

@@ -0,0 +1 @@
+export declare const pluginName: string;

package/dist/utils/defineStoreId.d.ts

@@ -0,0 +1 @@
+export declare function defineStoreId(prefix: string, id: string): string;

package/dist/utils/object.d.ts

@@ -0,0 +1,4 @@
+import type { AnyObject } from "../types";
+import type { Comparison } from "../types/comparison";
+export declare function arrayObjectFindAllBy<T extends AnyObject>(arrayOfObject: T[], findBy: Partial<T>, comparison?: Comparison): T[];
+export declare function arrayObjectFindBy<T extends AnyObject>(arrayOfObject: T[], findBy: Partial<T>): T | undefined;

package/dist/utils/store.d.ts

@@ -0,0 +1,31 @@
+import type { DefineStoreOptions, StateTree, StoreDefinition } from "pinia";
+import type { AnyObject } from "../types";
+import type { DefineAStoreSetupContext, EmptyExtensions, PluginStoreOptions, StoreOptions } from "../types/store";
+export declare const itemState: {
+    '@id': undefined;
+    id: undefined;
+};
+type DefineAStoreSetup<TEnhancedStore, TExtraExtensions extends Record<string, unknown> = EmptyExtensions> = (ctx: DefineAStoreSetupContext<TEnhancedStore, TExtraExtensions>) => AnyObject;
+export declare function defineAStore<Sto, Sta>(id: string, storeDefinition: Omit<DefineStoreOptions<string, StateTree & Sta, AnyObject, Partial<Sto>>, 'id'> | ((ctx?: DefineAStoreSetupContext<AnyObject>) => AnyObject), options?: StoreOptions): StoreDefinition & Sta & Sto;
+export declare function defineAStoreCtx<Sto, Sta, TExtraExtensions extends Record<string, unknown> = EmptyExtensions>(id: string, storeDefinition: DefineAStoreSetup<Sto & Sta, TExtraExtensions>, options?: StoreOptions): StoreDefinition & Sta & Sto;
+export declare function defineAStoreSetup(id: string, storeDefinition: DefineAStoreSetup<AnyObject>, options: PluginStoreOptions): StoreDefinition<string, Pick<AnyObject, keyof AnyObject>, Pick<AnyObject, keyof AnyObject>, Pick<AnyObject, keyof AnyObject>>;
+export declare function defineAStoreOptionApi(id: string, storeDefinition: AnyObject, options?: PluginStoreOptions): StoreDefinition<string, {}, {}, {}>;
+export declare function hasDeniedFirstChar(property: string): boolean;
+export declare function getDefineAStoreSetupContext(store: AnyObject): DefineAStoreSetupContext<AnyObject> | undefined;
+/**
+ * Get the enhanced store from the context.
+ * @param ctx The context containing the extensions.
+ * @returns The enhanced store casted to the specified types.
+ */
+export declare function getEnhancedStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>): TEnhancedStore;
+/**
+ * Set the enhanced store in context with deprecated alias support.
+ * @param ctx The context containing the extensions.
+ * @param store The store to expose as enhancement.
+ */
+export declare function setEnhancedStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>, store: TEnhancedStore): void;
+/**
+ * @deprecated Use getEnhancedStore instead.
+ */
+export declare function getExtendingStore<TEnhancedStore>(ctx: DefineAStoreSetupContext<TEnhancedStore>): TEnhancedStore;
+export {};

package/dist/utils/validation/index.d.ts

@@ -0,0 +1 @@
+export declare function isEmpty(value: any): boolean;

package/dist/utils/validation/object.d.ts

@@ -0,0 +1,9 @@
+import type { AnyObject } from "../../types";
+/**
+ * Compares objects to determine if they are identical
+ * @param {object} object1
+ * @param {object} object2
+ * @param {array} excludedKeys - name of properties not to be compared
+ * @returns {boolean} areIdentical
+ */
+export declare const areIdentical: (object1: AnyObject, object2: AnyObject, excludedKeys?: Set<string>) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinia-plugin-subscription",
-  "version": "0.1.6",
+  "version": "0.1.7-beta.1",
   "description": "Pinia plugin for Vue.js that helps building Pinia plugins by centralizing subscriber registration and providing a Store base class for store helpers.",
   "type": "module",
   "sideEffects": false,
@@ -26,13 +26,29 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/pinia-plugin-subscription.js",
-      "require": "./dist/pinia-plugin-subscription.umd.cjs"
+      "types": "./dist/lib/main.d.ts",
+      "import": "./dist/pinia-plugin-subscription.js"
+    },
+    "./helpers": {
+      "types": "./dist/helpers/index.d.ts",
+      "import": "./dist/helpers.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "main": "./dist/pinia-plugin-subscription.js",
+  "types": "./dist/lib/main.d.ts",
+  "typesVersions": {
+    "*": {
+      "helpers": [
+        "./dist/helpers/index.d.ts"
+      ],
+      "types": [
+        "./dist/types/index.d.ts"
+      ]
     }
   },
-  "main": "./dist/pinia-plugin-subscription.umd.cjs",
-  "types": "./dist/types/index.d.ts",
   "files": [
     "dist",
     "CHANGELOG.md",
@@ -48,16 +64,27 @@
   },
   "scripts": {
     "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "dev": "vite",
+    "dev": "vite --config vite.demo.config.ts",
+    "dev:library": "vite",
     "test": "vitest",
     "coverage": "vitest run --coverage",
-    "build": "vitest && vite build && tsc --emitDeclarationOnly --outDir dist",
-    "preview": "vite preview"
+    "build": "vitest && vite build && tsc --emitDeclarationOnly --outDir dist && node scripts/measure-bundle.mjs",
+    "bundle:check": "vite build --config vite.config.ts && node scripts/measure-bundle.mjs",
+    "build:demo": "vite --config vite.demo.config.ts build",
+    "preview": "vite preview --config vite.demo.config.ts"
   },
   "peerDependencies": {
     "pinia": "^2.0.0 || ^3.0.0",
     "vue": "^3.0.0"
   },
+  "peerDependenciesMeta": {
+    "pinia": {
+      "optional": false
+    },
+    "vue": {
+      "optional": false
+    }
+  },
   "devDependencies": {
     "@types/node": "^24.10.1",
     "@vitejs/plugin-vue": "^6.0.1",