@authup/client-web-kit 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/index.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var coreKit = require('@authup/core-kit');
 var vue = require('vue');
 var coreHttpKit = require('@authup/core-http-kit');
+var pinia = require('pinia');
 var kit = require('@authup/kit');
 var smob = require('smob');
 var listControls = require('@vuecs/list-controls');
@@ -57,644 +58,6 @@ function injectHTTPClient(app) {
     return instance;
 }
 
-var isVue2 = false;
-function set(target, key, val) {
-    if (Array.isArray(target)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    target[key] = val;
-    return val;
-}
-function del(target, key) {
-    if (Array.isArray(target)) {
-        target.splice(key, 1);
-        return;
-    }
-    delete target[key];
-}
-
-/**
- * setActivePinia must be called to handle SSR at the top of functions like
- * `fetch`, `setup`, `serverPrefetch` and others
- */ let activePinia;
-/**
- * Sets or unsets the active pinia. Used in SSR and internally when calling
- * actions and getters
- *
- * @param pinia - Pinia instance
- */ // @ts-expect-error: cannot constrain the type of the return
-const setActivePinia = (pinia)=>activePinia = pinia;
-const piniaSymbol = process.env.NODE_ENV !== 'production' ? Symbol('pinia') : /* istanbul ignore next */ Symbol();
-function isPlainObject(// eslint-disable-next-line @typescript-eslint/no-explicit-any
-o) {
-    return o && typeof o === 'object' && Object.prototype.toString.call(o) === '[object Object]' && typeof o.toJSON !== 'function';
-}
-// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> }
-// TODO: can we change these to numbers?
-/**
- * Possible types for SubscriptionCallback
- */ var MutationType;
-(function(MutationType) {
-    /**
-     * Direct mutation of the state:
-     *
-     * - `store.name = 'new name'`
-     * - `store.$state.name = 'new name'`
-     * - `store.list.push('new item')`
-     */ MutationType["direct"] = "direct";
-    /**
-     * Mutated the state with `$patch` and an object
-     *
-     * - `store.$patch({ name: 'newName' })`
-     */ MutationType["patchObject"] = "patch object";
-    /**
-     * Mutated the state with `$patch` and a function
-     *
-     * - `store.$patch(state => state.name = 'newName')`
-     */ MutationType["patchFunction"] = "patch function";
-// maybe reset? for $state = {} and $reset
-})(MutationType || (MutationType = {}));
-const IS_CLIENT = typeof window !== 'undefined';
-/**
- * Should we add the devtools plugins.
- * - only if dev mode or forced through the prod devtools flag
- * - not in test
- * - only if window exists (could change in the future)
- */ const USE_DEVTOOLS = (process.env.NODE_ENV !== 'production' || typeof __VUE_PROD_DEVTOOLS__ !== 'undefined' && __VUE_PROD_DEVTOOLS__) && !(process.env.NODE_ENV === 'test') && IS_CLIENT;
-/**
- * Mutates in place `newState` with `oldState` to _hot update_ it. It will
- * remove any key not existing in `newState` and recursively merge plain
- * objects.
- *
- * @param newState - new state object to be patched
- * @param oldState - old state that should be used to patch newState
- * @returns - newState
- */ function patchObject(newState, oldState) {
-    // no need to go through symbols because they cannot be serialized anyway
-    for(const key in oldState){
-        const subPatch = oldState[key];
-        // skip the whole sub tree
-        if (!(key in newState)) {
-            continue;
-        }
-        const targetValue = newState[key];
-        if (isPlainObject(targetValue) && isPlainObject(subPatch) && !vue.isRef(subPatch) && !vue.isReactive(subPatch)) {
-            newState[key] = patchObject(targetValue, subPatch);
-        } else {
-            // objects are either a bit more complex (e.g. refs) or primitives, so we
-            // just set the whole thing
-            {
-                newState[key] = subPatch;
-            }
-        }
-    }
-    return newState;
-}
-const noop$1 = ()=>{};
-function addSubscription(subscriptions, callback, detached, onCleanup = noop$1) {
-    subscriptions.push(callback);
-    const removeSubscription = ()=>{
-        const idx = subscriptions.indexOf(callback);
-        if (idx > -1) {
-            subscriptions.splice(idx, 1);
-            onCleanup();
-        }
-    };
-    if (!detached && vue.getCurrentScope()) {
-        vue.onScopeDispose(removeSubscription);
-    }
-    return removeSubscription;
-}
-function triggerSubscriptions(subscriptions, ...args) {
-    subscriptions.slice().forEach((callback)=>{
-        callback(...args);
-    });
-}
-const fallbackRunWithContext = (fn)=>fn();
-function mergeReactiveObjects(target, patchToApply) {
-    // Handle Map instances
-    if (target instanceof Map && patchToApply instanceof Map) {
-        patchToApply.forEach((value, key)=>target.set(key, value));
-    }
-    // Handle Set instances
-    if (target instanceof Set && patchToApply instanceof Set) {
-        patchToApply.forEach(target.add, target);
-    }
-    // no need to go through symbols because they cannot be serialized anyway
-    for(const key in patchToApply){
-        if (!patchToApply.hasOwnProperty(key)) continue;
-        const subPatch = patchToApply[key];
-        const targetValue = target[key];
-        if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !vue.isRef(subPatch) && !vue.isReactive(subPatch)) {
-            // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might
-            // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that
-            // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.
-            target[key] = mergeReactiveObjects(targetValue, subPatch);
-        } else {
-            // @ts-expect-error: subPatch is a valid value
-            target[key] = subPatch;
-        }
-    }
-    return target;
-}
-const skipHydrateSymbol = process.env.NODE_ENV !== 'production' ? Symbol('pinia:skipHydration') : /* istanbul ignore next */ Symbol();
-/**
- * Returns whether a value should be hydrated
- *
- * @param obj - target variable
- * @returns true if `obj` should be hydrated
- */ function shouldHydrate(obj) {
-    return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
-}
-const { assign } = Object;
-function isComputed(o) {
-    return !!(vue.isRef(o) && o.effect);
-}
-function createOptionsStore(id, options, pinia, hot) {
-    const { state, actions, getters } = options;
-    const initialState = pinia.state.value[id];
-    let store;
-    function setup() {
-        if (!initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
-            /* istanbul ignore if */ {
-                pinia.state.value[id] = state ? state() : {};
-            }
-        }
-        // avoid creating a state in pinia.state.value
-        const localState = process.env.NODE_ENV !== 'production' && hot ? vue.toRefs(vue.ref(state ? state() : {}).value) : vue.toRefs(pinia.state.value[id]);
-        return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name)=>{
-            if (process.env.NODE_ENV !== 'production' && name in localState) {
-                console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
-            }
-            computedGetters[name] = vue.markRaw(vue.computed(()=>{
-                setActivePinia(pinia);
-                // it was created just before
-                const store = pinia._s.get(id);
-                // @ts-expect-error
-                // return getters![name].call(context, context)
-                // TODO: avoid reading the getter while assigning with a global variable
-                return getters[name].call(store, store);
-            }));
-            return computedGetters;
-        }, {}));
-    }
-    store = createSetupStore(id, setup, options, pinia, hot, true);
-    return store;
-}
-function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
-    let scope;
-    const optionsForPlugin = assign({
-        actions: {}
-    }, options);
-    /* istanbul ignore if */ if (process.env.NODE_ENV !== 'production' && !pinia._e.active) {
-        throw new Error('Pinia destroyed');
-    }
-    // watcher options for $subscribe
-    const $subscribeOptions = {
-        deep: true
-    };
-    /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production' && !isVue2) {
-        $subscribeOptions.onTrigger = (event)=>{
-            /* istanbul ignore else */ if (isListening) {
-                debuggerEvents = event;
-            // avoid triggering this while the store is being built and the state is being set in pinia
-            } else if (isListening == false && !store._hotUpdating) {
-                // let patch send all the events together later
-                /* istanbul ignore else */ if (Array.isArray(debuggerEvents)) {
-                    debuggerEvents.push(event);
-                } else {
-                    console.error('🍍 debuggerEvents should be an array. This is most likely an internal Pinia bug.');
-                }
-            }
-        };
-    }
-    // internal state
-    let isListening; // set to true at the end
-    let isSyncListening; // set to true at the end
-    let subscriptions = [];
-    let actionSubscriptions = [];
-    let debuggerEvents;
-    const initialState = pinia.state.value[$id];
-    // avoid setting the state for option stores if it is set
-    // by the setup
-    if (!isOptionsStore && !initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
-        /* istanbul ignore if */ {
-            pinia.state.value[$id] = {};
-        }
-    }
-    const hotState = vue.ref({});
-    // avoid triggering too many listeners
-    // https://github.com/vuejs/pinia/issues/1129
-    let activeListener;
-    function $patch(partialStateOrMutator) {
-        let subscriptionMutation;
-        isListening = isSyncListening = false;
-        // reset the debugger events since patches are sync
-        /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
-            debuggerEvents = [];
-        }
-        if (typeof partialStateOrMutator === 'function') {
-            partialStateOrMutator(pinia.state.value[$id]);
-            subscriptionMutation = {
-                type: MutationType.patchFunction,
-                storeId: $id,
-                events: debuggerEvents
-            };
-        } else {
-            mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
-            subscriptionMutation = {
-                type: MutationType.patchObject,
-                payload: partialStateOrMutator,
-                storeId: $id,
-                events: debuggerEvents
-            };
-        }
-        const myListenerId = activeListener = Symbol();
-        vue.nextTick().then(()=>{
-            if (activeListener === myListenerId) {
-                isListening = true;
-            }
-        });
-        isSyncListening = true;
-        // because we paused the watcher, we need to manually call the subscriptions
-        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
-    }
-    const $reset = isOptionsStore ? function $reset() {
-        const { state } = options;
-        const newState = state ? state() : {};
-        // we use a patch to group all changes into one single subscription
-        this.$patch(($state)=>{
-            assign($state, newState);
-        });
-    } : /* istanbul ignore next */ process.env.NODE_ENV !== 'production' ? ()=>{
-        throw new Error(`🍍: Store "${$id}" is built using the setup syntax and does not implement $reset().`);
-    } : noop$1;
-    function $dispose() {
-        scope.stop();
-        subscriptions = [];
-        actionSubscriptions = [];
-        pinia._s.delete($id);
-    }
-    /**
-     * Wraps an action to handle subscriptions.
-     *
-     * @param name - name of the action
-     * @param action - action to wrap
-     * @returns a wrapped action to handle subscriptions
-     */ function wrapAction(name, action) {
-        return function() {
-            setActivePinia(pinia);
-            const args = Array.from(arguments);
-            const afterCallbackList = [];
-            const onErrorCallbackList = [];
-            function after(callback) {
-                afterCallbackList.push(callback);
-            }
-            function onError(callback) {
-                onErrorCallbackList.push(callback);
-            }
-            // @ts-expect-error
-            triggerSubscriptions(actionSubscriptions, {
-                args,
-                name,
-                store,
-                after,
-                onError
-            });
-            let ret;
-            try {
-                ret = action.apply(this && this.$id === $id ? this : store, args);
-            // handle sync errors
-            } catch (error) {
-                triggerSubscriptions(onErrorCallbackList, error);
-                throw error;
-            }
-            if (ret instanceof Promise) {
-                return ret.then((value)=>{
-                    triggerSubscriptions(afterCallbackList, value);
-                    return value;
-                }).catch((error)=>{
-                    triggerSubscriptions(onErrorCallbackList, error);
-                    return Promise.reject(error);
-                });
-            }
-            // trigger after callbacks
-            triggerSubscriptions(afterCallbackList, ret);
-            return ret;
-        };
-    }
-    const _hmrPayload = /*#__PURE__*/ vue.markRaw({
-        actions: {},
-        getters: {},
-        state: [],
-        hotState
-    });
-    const partialStore = {
-        _p: pinia,
-        // _s: scope,
-        $id,
-        $onAction: addSubscription.bind(null, actionSubscriptions),
-        $patch,
-        $reset,
-        $subscribe (callback, options = {}) {
-            const removeSubscription = addSubscription(subscriptions, callback, options.detached, ()=>stopWatcher());
-            const stopWatcher = scope.run(()=>vue.watch(()=>pinia.state.value[$id], (state)=>{
-                    if (options.flush === 'sync' ? isSyncListening : isListening) {
-                        callback({
-                            storeId: $id,
-                            type: MutationType.direct,
-                            events: debuggerEvents
-                        }, state);
-                    }
-                }, assign({}, $subscribeOptions, options)));
-            return removeSubscription;
-        },
-        $dispose
-    };
-    const store = vue.reactive(process.env.NODE_ENV !== 'production' || USE_DEVTOOLS ? assign({
-        _hmrPayload,
-        _customProperties: vue.markRaw(new Set())
-    }, partialStore) : partialStore);
-    // store the partial store now so the setup of stores can instantiate each other before they are finished without
-    // creating infinite loops.
-    pinia._s.set($id, store);
-    const runWithContext = pinia._a && pinia._a.runWithContext || fallbackRunWithContext;
-    // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
-    const setupStore = runWithContext(()=>pinia._e.run(()=>(scope = vue.effectScope()).run(setup)));
-    // overwrite existing actions to support $onAction
-    for(const key in setupStore){
-        const prop = setupStore[key];
-        if (vue.isRef(prop) && !isComputed(prop) || vue.isReactive(prop)) {
-            // mark it as a piece of state to be serialized
-            if (process.env.NODE_ENV !== 'production' && hot) {
-                set(hotState.value, key, vue.toRef(setupStore, key));
-            // createOptionStore directly sets the state in pinia.state.value so we
-            // can just skip that
-            } else if (!isOptionsStore) {
-                // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created
-                if (initialState && shouldHydrate(prop)) {
-                    if (vue.isRef(prop)) {
-                        prop.value = initialState[key];
-                    } else {
-                        // probably a reactive object, lets recursively assign
-                        // @ts-expect-error: prop is unknown
-                        mergeReactiveObjects(prop, initialState[key]);
-                    }
-                }
-                // transfer the ref to the pinia state to keep everything in sync
-                /* istanbul ignore if */ {
-                    pinia.state.value[$id][key] = prop;
-                }
-            }
-            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
-                _hmrPayload.state.push(key);
-            }
-        // action
-        } else if (typeof prop === 'function') {
-            // @ts-expect-error: we are overriding the function we avoid wrapping if
-            const actionValue = process.env.NODE_ENV !== 'production' && hot ? prop : wrapAction(key, prop);
-            // this a hot module replacement store because the hotUpdate method needs
-            // to do it with the right context
-            /* istanbul ignore if */ {
-                // @ts-expect-error
-                setupStore[key] = actionValue;
-            }
-            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
-                _hmrPayload.actions[key] = prop;
-            }
-            // list actions so they can be used in plugins
-            // @ts-expect-error
-            optionsForPlugin.actions[key] = prop;
-        } else if (process.env.NODE_ENV !== 'production') {
-            // add getters for devtools
-            if (isComputed(prop)) {
-                _hmrPayload.getters[key] = isOptionsStore ? options.getters[key] : prop;
-                if (IS_CLIENT) {
-                    const getters = setupStore._getters || // @ts-expect-error: same
-                    (setupStore._getters = vue.markRaw([]));
-                    getters.push(key);
-                }
-            }
-        }
-    }
-    // add the state, getters, and action properties
-    /* istanbul ignore if */ {
-        assign(store, setupStore);
-        // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.
-        // Make `storeToRefs()` work with `reactive()` #799
-        assign(vue.toRaw(store), setupStore);
-    }
-    // use this instead of a computed with setter to be able to create it anywhere
-    // without linking the computed lifespan to wherever the store is first
-    // created.
-    Object.defineProperty(store, '$state', {
-        get: ()=>process.env.NODE_ENV !== 'production' && hot ? hotState.value : pinia.state.value[$id],
-        set: (state)=>{
-            /* istanbul ignore if */ if (process.env.NODE_ENV !== 'production' && hot) {
-                throw new Error('cannot set hotState');
-            }
-            $patch(($state)=>{
-                assign($state, state);
-            });
-        }
-    });
-    // add the hotUpdate before plugins to allow them to override it
-    /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
-        store._hotUpdate = vue.markRaw((newStore)=>{
-            store._hotUpdating = true;
-            newStore._hmrPayload.state.forEach((stateKey)=>{
-                if (stateKey in store.$state) {
-                    const newStateTarget = newStore.$state[stateKey];
-                    const oldStateSource = store.$state[stateKey];
-                    if (typeof newStateTarget === 'object' && isPlainObject(newStateTarget) && isPlainObject(oldStateSource)) {
-                        patchObject(newStateTarget, oldStateSource);
-                    } else {
-                        // transfer the ref
-                        newStore.$state[stateKey] = oldStateSource;
-                    }
-                }
-                // patch direct access properties to allow store.stateProperty to work as
-                // store.$state.stateProperty
-                set(store, stateKey, vue.toRef(newStore.$state, stateKey));
-            });
-            // remove deleted state properties
-            Object.keys(store.$state).forEach((stateKey)=>{
-                if (!(stateKey in newStore.$state)) {
-                    del(store, stateKey);
-                }
-            });
-            // avoid devtools logging this as a mutation
-            isListening = false;
-            isSyncListening = false;
-            pinia.state.value[$id] = vue.toRef(newStore._hmrPayload, 'hotState');
-            isSyncListening = true;
-            vue.nextTick().then(()=>{
-                isListening = true;
-            });
-            for(const actionName in newStore._hmrPayload.actions){
-                const action = newStore[actionName];
-                set(store, actionName, wrapAction(actionName, action));
-            }
-            // TODO: does this work in both setup and option store?
-            for(const getterName in newStore._hmrPayload.getters){
-                const getter = newStore._hmrPayload.getters[getterName];
-                const getterValue = isOptionsStore ? vue.computed(()=>{
-                    setActivePinia(pinia);
-                    return getter.call(store, store);
-                }) : getter;
-                set(store, getterName, getterValue);
-            }
-            // remove deleted getters
-            Object.keys(store._hmrPayload.getters).forEach((key)=>{
-                if (!(key in newStore._hmrPayload.getters)) {
-                    del(store, key);
-                }
-            });
-            // remove old actions
-            Object.keys(store._hmrPayload.actions).forEach((key)=>{
-                if (!(key in newStore._hmrPayload.actions)) {
-                    del(store, key);
-                }
-            });
-            // update the values used in devtools and to allow deleting new properties later on
-            store._hmrPayload = newStore._hmrPayload;
-            store._getters = newStore._getters;
-            store._hotUpdating = false;
-        });
-    }
-    if (USE_DEVTOOLS) {
-        const nonEnumerable = {
-            writable: true,
-            configurable: true,
-            // avoid warning on devtools trying to display this property
-            enumerable: false
-        };
-        [
-            '_p',
-            '_hmrPayload',
-            '_getters',
-            '_customProperties'
-        ].forEach((p)=>{
-            Object.defineProperty(store, p, assign({
-                value: store[p]
-            }, nonEnumerable));
-        });
-    }
-    // apply all plugins
-    pinia._p.forEach((extender)=>{
-        /* istanbul ignore else */ if (USE_DEVTOOLS) {
-            const extensions = scope.run(()=>extender({
-                    store,
-                    app: pinia._a,
-                    pinia,
-                    options: optionsForPlugin
-                }));
-            Object.keys(extensions || {}).forEach((key)=>store._customProperties.add(key));
-            assign(store, extensions);
-        } else {
-            assign(store, scope.run(()=>extender({
-                    store,
-                    app: pinia._a,
-                    pinia,
-                    options: optionsForPlugin
-                })));
-        }
-    });
-    if (process.env.NODE_ENV !== 'production' && store.$state && typeof store.$state === 'object' && typeof store.$state.constructor === 'function' && !store.$state.constructor.toString().includes('[native code]')) {
-        console.warn(`[🍍]: The "state" must be a plain object. It cannot be\n` + `\tstate: () => new MyClass()\n` + `Found in store "${store.$id}".`);
-    }
-    // only apply hydrate to option stores with an initial state in pinia
-    if (initialState && isOptionsStore && options.hydrate) {
-        options.hydrate(store.$state, initialState);
-    }
-    isListening = true;
-    isSyncListening = true;
-    return store;
-}
-function defineStore(// TODO: add proper types from above
-idOrOptions, setup, setupOptions) {
-    let id;
-    let options;
-    const isSetupStore = typeof setup === 'function';
-    {
-        id = idOrOptions;
-        // the option store setup will contain the actual options in this case
-        options = isSetupStore ? setupOptions : setup;
-    }
-    function useStore(pinia, hot) {
-        const hasContext = vue.hasInjectionContext();
-        pinia = // in test mode, ignore the argument provided as we can always retrieve a
-        // pinia instance with getActivePinia()
-        (process.env.NODE_ENV === 'test' && activePinia && activePinia._testing ? null : pinia) || (hasContext ? vue.inject(piniaSymbol, null) : null);
-        if (pinia) setActivePinia(pinia);
-        if (process.env.NODE_ENV !== 'production' && !activePinia) {
-            throw new Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "app.use(pinia)"?\n` + `See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.\n` + `This will fail in production.`);
-        }
-        pinia = activePinia;
-        if (!pinia._s.has(id)) {
-            // creating the store registers it in `pinia._s`
-            if (isSetupStore) {
-                createSetupStore(id, setup, options, pinia);
-            } else {
-                createOptionsStore(id, options, pinia);
-            }
-            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
-                // @ts-expect-error: not the right inferred type
-                useStore._pinia = pinia;
-            }
-        }
-        const store = pinia._s.get(id);
-        if (process.env.NODE_ENV !== 'production' && hot) {
-            const hotId = '__hot:' + id;
-            const newStore = isSetupStore ? createSetupStore(hotId, setup, options, pinia, true) : createOptionsStore(hotId, assign({}, options), pinia, true);
-            hot._hotUpdate(newStore);
-            // cleanup the state properties and the store from the cache
-            delete pinia.state.value[hotId];
-            pinia._s.delete(hotId);
-        }
-        if (process.env.NODE_ENV !== 'production' && IS_CLIENT) {
-            const currentInstance = vue.getCurrentInstance();
-            // save stores in instances to access them devtools
-            if (currentInstance && currentInstance.proxy && // avoid adding stores that are just built for hot module replacement
-            !hot) {
-                const vm = currentInstance.proxy;
-                const cache = '_pStores' in vm ? vm._pStores : vm._pStores = {};
-                cache[id] = store;
-            }
-        }
-        // StoreGeneric cannot be casted towards Store
-        return store;
-    }
-    useStore.$id = id;
-    return useStore;
-}
-/**
- * Creates an object of references with all the state, getters, and plugin-added
- * state properties of the store. Similar to `toRefs()` but specifically
- * designed for Pinia stores so methods and non reactive properties are
- * completely ignored.
- *
- * @param store - store to extract the refs from
- */ function storeToRefs$1(store) {
-    // See https://github.com/vuejs/pinia/issues/852
-    // It's easier to just use toRefs() even if it includes more stuff
-    {
-        store = vue.toRaw(store);
-        const refs = {};
-        for(const key in store){
-            const value = store[key];
-            if (vue.isRef(value) || vue.isReactive(value)) {
-                // @ts-expect-error: the key is state or getter
-                refs[key] = // ---
-                vue.toRef(store, key);
-            }
-        }
-        return refs;
-    }
-}
-
 /*
  * Copyright (c) 2024.
  * Author Peter Placzek (tada5hi)
@@ -989,10 +352,10 @@ function installStore(app, options = {}) {
     if (hasStore(app)) {
         return;
     }
-    const storeCreator = defineStore(STORE_ID, ()=>createStore({
+    const storeCreator = pinia.defineStore(STORE_ID, ()=>createStore({
             baseURL: options.baseURL
         }));
-    const store = storeCreator();
+    const store = storeCreator(options.pinia);
     const cookies = useCookies();
     let cookieGet;
     if (options.cookieGet) {
@@ -1123,8 +486,8 @@ function installHTTPClient(app, options = {}) {
         baseURL: options.baseURL
     });
     const storeCreator = injectStore(app);
-    const store = storeCreator();
-    const { refreshToken } = storeToRefs$1(store);
+    const store = storeCreator(options.pinia);
+    const { refreshToken } = pinia.storeToRefs(store);
     const tokenHook = new coreHttpKit.ClientResponseErrorTokenHook(client, {
         baseURL: options.baseURL,
         tokenCreator: ()=>{
@@ -2644,7 +2007,7 @@ function useAbilityCheck(name) {
 
 function useRealmResourceWritableCheck(realmId) {
     const store = useStore();
-    const { realm } = storeToRefs$1(store);
+    const { realm } = pinia.storeToRefs(store);
     return vue.computed(()=>{
         const realmIdRaw = vue.unref(realmId);
         return coreKit.isRealmResourceWritable(realm.value, realmIdRaw);
@@ -7336,10 +6699,12 @@ function install(app1, options) {
         baseURL: options.baseURL,
         cookieSet: options.cookieSet,
         cookieGet: options.cookieGet,
-        cookieUnset: options.cookieUnset
+        cookieUnset: options.cookieUnset,
+        pinia: options.pinia
     });
     installHTTPClient(app1, {
-        baseURL: options.baseURL
+        baseURL: options.baseURL,
+        pinia: options.pinia
     });
     installTranslator(app1, {
         locale: options.translatorLocale