Your IP : 3.142.42.247
/* eslint-disable */
;(function() {
if (
typeof this.BX !== 'undefined'
&& typeof this.BX.Vue3 !== 'undefined'
&& typeof this.BX.Vue3.Pinia !== 'undefined'
)
{
var currentVersion = '2.0.22';
if (this.BX.Vue3.Pinia.version !== currentVersion)
{
console.warn('BX.Vue3.Pinia already loaded. Loaded: ' + this.BX.Vue3.Pinia.version + ', Skipped: ' + currentVersion + '. Version differences may cause errors!');
}
return;
}
this.BX = this.BX || {};
this.BX.Vue3 = this.BX.Vue3 || {};
(function (exports,ui_vue3) {
'use strict';
/**
* pinia v2.0.22
* (c) 2022 Eduardo San Martin Morote
* @license MIT
*
* @source: https://unpkg.com/pinia@2.0.11/dist/pinia.esm-browser.js
* @source: https://github.com/vueuse/vue-demi/blob/master/lib/v3/index.cjs
*/
const isVue2 = false;
function set(object, key, value) {
if (Array.isArray(object)) {
object.length = Math.max(object.length, key);
object.splice(key, 1, value);
} else if (typeof object === 'object') {
object[key] = value;
}
return value;
}
function del(object, key) {
if (Array.isArray(object)) {
object.splice(key, 1);
} else if (typeof object === 'object') {
delete object[key];
}
}
function getDevtoolsGlobalHook() {
return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
}
function getTarget() {
// @ts-ignore
return typeof navigator !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};
}
const HOOK_SETUP = 'devtools-plugin:setup';
function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
const hook = getDevtoolsGlobalHook();
if (hook) {
hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
} else {
const target = getTarget();
const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
list.push({
pluginDescriptor,
setupFn
});
}
}
// origin-start
/**
* 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
*/
const setActivePinia = pinia => activePinia = pinia;
/**
* Get the currently active pinia if there is any.
*/
const getActivePinia = () => ui_vue3.getCurrentInstance() && ui_vue3.inject(piniaSymbol) || activePinia;
const piniaSymbol = Symbol('pinia');
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
*/
(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
})(exports.MutationType || (exports.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 = IS_CLIENT;
/*
* FileSaver.js A saveAs() FileSaver implementation.
*
* Originally by Eli Grey, adapted as an ESM module by Eduardo San Martin
* Morote.
*
* License : MIT
*/
// The one and only way of getting global scope in all environments
// https://stackoverflow.com/q/3277182/1008999
const _global = /*#__PURE__*/(() => typeof window === 'object' && window.window === window ? window : typeof self === 'object' && self.self === self ? self : typeof global === 'object' && global.global === global ? global : typeof globalThis === 'object' ? globalThis : {
HTMLElement: null
})();
function bom(blob, {
autoBom = false
} = {}) {
// prepend BOM for UTF-8 XML and text/* types (including HTML)
// note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
if (autoBom && /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
return new Blob([String.fromCharCode(0xfeff), blob], {
type: blob.type
});
}
return blob;
}
function download(url, name, opts) {
const xhr = new XMLHttpRequest();
xhr.open('GET', url);
xhr.responseType = 'blob';
xhr.onload = function () {
saveAs(xhr.response, name, opts);
};
xhr.onerror = function () {
console.error('could not download file');
};
xhr.send();
}
function corsEnabled(url) {
const xhr = new XMLHttpRequest();
// use sync to avoid popup blocker
xhr.open('HEAD', url, false);
try {
xhr.send();
} catch (e) {}
return xhr.status >= 200 && xhr.status <= 299;
}
// `a.click()` doesn't work for all browsers (#465)
function click(node) {
try {
node.dispatchEvent(new MouseEvent('click'));
} catch (e) {
const evt = document.createEvent('MouseEvents');
evt.initMouseEvent('click', true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null);
node.dispatchEvent(evt);
}
}
const _navigator = typeof navigator === 'object' ? navigator : {
userAgent: ''
};
// Detect WebView inside a native macOS app by ruling out all browsers
// We just need to check for 'Safari' because all other browsers (besides Firefox) include that too
// https://www.whatismybrowser.com/guides/the-latest-user-agent/macos
const isMacOSWebView = /*#__PURE__*/(() => /Macintosh/.test(_navigator.userAgent) && /AppleWebKit/.test(_navigator.userAgent) && !/Safari/.test(_navigator.userAgent))();
const saveAs = !IS_CLIENT ? () => {} // noop
:
// Use download attribute first if possible (#193 Lumia mobile) unless this is a macOS WebView or mini program
typeof HTMLAnchorElement !== 'undefined' && 'download' in HTMLAnchorElement.prototype && !isMacOSWebView ? downloadSaveAs :
// Use msSaveOrOpenBlob as a second approach
'msSaveOrOpenBlob' in _navigator ? msSaveAs :
// Fallback to using FileReader and a popup
fileSaverSaveAs;
function downloadSaveAs(blob, name = 'download', opts) {
const a = document.createElement('a');
a.download = name;
a.rel = 'noopener'; // tabnabbing
// TODO: detect chrome extensions & packaged apps
// a.target = '_blank'
if (typeof blob === 'string') {
// Support regular links
a.href = blob;
if (a.origin !== location.origin) {
if (corsEnabled(a.href)) {
download(blob, name, opts);
} else {
a.target = '_blank';
click(a);
}
} else {
click(a);
}
} else {
// Support blobs
a.href = URL.createObjectURL(blob);
setTimeout(function () {
URL.revokeObjectURL(a.href);
}, 4e4); // 40s
setTimeout(function () {
click(a);
}, 0);
}
}
function msSaveAs(blob, name = 'download', opts) {
if (typeof blob === 'string') {
if (corsEnabled(blob)) {
download(blob, name, opts);
} else {
const a = document.createElement('a');
a.href = blob;
a.target = '_blank';
setTimeout(function () {
click(a);
});
}
} else {
// @ts-ignore: works on windows
navigator.msSaveOrOpenBlob(bom(blob, opts), name);
}
}
function fileSaverSaveAs(blob, name, opts, popup) {
// Open a popup immediately do go around popup blocker
// Mostly only available on user interaction and the fileReader is async so...
popup = popup || open('', '_blank');
if (popup) {
popup.document.title = popup.document.body.innerText = 'downloading...';
}
if (typeof blob === 'string') return download(blob, name, opts);
const force = blob.type === 'application/octet-stream';
const isSafari = /constructor/i.test(String(_global.HTMLElement)) || 'safari' in _global;
const isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent);
if ((isChromeIOS || force && isSafari || isMacOSWebView) && typeof FileReader !== 'undefined') {
// Safari doesn't allow downloading of blob URLs
const reader = new FileReader();
reader.onloadend = function () {
let url = reader.result;
if (typeof url !== 'string') {
popup = null;
throw new Error('Wrong reader.result type');
}
url = isChromeIOS ? url : url.replace(/^data:[^;]*;/, 'data:attachment/file;');
if (popup) {
popup.location.href = url;
} else {
location.assign(url);
}
popup = null; // reverse-tabnabbing #460
};
reader.readAsDataURL(blob);
} else {
const url = URL.createObjectURL(blob);
if (popup) popup.location.assign(url);else location.href = url;
popup = null; // reverse-tabnabbing #460
setTimeout(function () {
URL.revokeObjectURL(url);
}, 4e4); // 40s
}
}
/**
* Shows a toast or console.log
*
* @param message - message to log
* @param type - different color of the tooltip
*/
function toastMessage(message, type) {
const piniaMessage = 'Pinia: ' + message;
if (typeof __VUE_DEVTOOLS_TOAST__ === 'function') {
__VUE_DEVTOOLS_TOAST__(piniaMessage, type);
} else if (type === 'error') {
console.error(piniaMessage);
} else if (type === 'warn') {
console.warn(piniaMessage);
} else {
console.log(piniaMessage);
}
}
function isPinia(o) {
return '_a' in o && 'install' in o;
}
function checkClipboardAccess() {
if (!('clipboard' in navigator)) {
toastMessage(`Your browser doesn't support the Clipboard API`, 'error');
return true;
}
}
function checkNotFocusedError(error) {
if (error instanceof Error && error.message.toLowerCase().includes('document is not focused')) {
toastMessage('You need to activate the "Emulate a focused page" setting in the "Rendering" panel of devtools.', 'warn');
return true;
}
return false;
}
async function actionGlobalCopyState(pinia) {
if (checkClipboardAccess()) return;
try {
await navigator.clipboard.writeText(JSON.stringify(pinia.state.value));
toastMessage('Global state copied to clipboard.');
} catch (error) {
if (checkNotFocusedError(error)) return;
toastMessage(`Failed to serialize the state. Check the console for more details.`, 'error');
console.error(error);
}
}
async function actionGlobalPasteState(pinia) {
if (checkClipboardAccess()) return;
try {
pinia.state.value = JSON.parse(await navigator.clipboard.readText());
toastMessage('Global state pasted from clipboard.');
} catch (error) {
if (checkNotFocusedError(error)) return;
toastMessage(`Failed to deserialize the state from clipboard. Check the console for more details.`, 'error');
console.error(error);
}
}
async function actionGlobalSaveState(pinia) {
try {
saveAs(new Blob([JSON.stringify(pinia.state.value)], {
type: 'text/plain;charset=utf-8'
}), 'pinia-state.json');
} catch (error) {
toastMessage(`Failed to export the state as JSON. Check the console for more details.`, 'error');
console.error(error);
}
}
let fileInput;
function getFileOpener() {
if (!fileInput) {
fileInput = document.createElement('input');
fileInput.type = 'file';
fileInput.accept = '.json';
}
function openFile() {
return new Promise((resolve, reject) => {
fileInput.onchange = async () => {
const files = fileInput.files;
if (!files) return resolve(null);
const file = files.item(0);
if (!file) return resolve(null);
return resolve({
text: await file.text(),
file
});
};
// @ts-ignore: TODO: changed from 4.3 to 4.4
fileInput.oncancel = () => resolve(null);
fileInput.onerror = reject;
fileInput.click();
});
}
return openFile;
}
async function actionGlobalOpenStateFile(pinia) {
try {
const open = await getFileOpener();
const result = await open();
if (!result) return;
const {
text,
file
} = result;
pinia.state.value = JSON.parse(text);
toastMessage(`Global state imported from "${file.name}".`);
} catch (error) {
toastMessage(`Failed to export the state as JSON. Check the console for more details.`, 'error');
console.error(error);
}
}
function formatDisplay(display) {
return {
_custom: {
display
}
};
}
const PINIA_ROOT_LABEL = 'Pinia (root)';
const PINIA_ROOT_ID = '_root';
function formatStoreForInspectorTree(store) {
return isPinia(store) ? {
id: PINIA_ROOT_ID,
label: PINIA_ROOT_LABEL
} : {
id: store.$id,
label: store.$id
};
}
function formatStoreForInspectorState(store) {
if (isPinia(store)) {
const storeNames = Array.from(store._s.keys());
const storeMap = store._s;
const state = {
state: storeNames.map(storeId => ({
editable: true,
key: storeId,
value: store.state.value[storeId]
})),
getters: storeNames.filter(id => storeMap.get(id)._getters).map(id => {
const store = storeMap.get(id);
return {
editable: false,
key: id,
value: store._getters.reduce((getters, key) => {
getters[key] = store[key];
return getters;
}, {})
};
})
};
return state;
}
const state = {
state: Object.keys(store.$state).map(key => ({
editable: true,
key,
value: store.$state[key]
}))
};
// avoid adding empty getters
if (store._getters && store._getters.length) {
state.getters = store._getters.map(getterName => ({
editable: false,
key: getterName,
value: store[getterName]
}));
}
if (store._customProperties.size) {
state.customProperties = Array.from(store._customProperties).map(key => ({
editable: true,
key,
value: store[key]
}));
}
return state;
}
function formatEventData(events) {
if (!events) return {};
if (Array.isArray(events)) {
// TODO: handle add and delete for arrays and objects
return events.reduce((data, event) => {
data.keys.push(event.key);
data.operations.push(event.type);
data.oldValue[event.key] = event.oldValue;
data.newValue[event.key] = event.newValue;
return data;
}, {
oldValue: {},
keys: [],
operations: [],
newValue: {}
});
} else {
return {
operation: formatDisplay(events.type),
key: formatDisplay(events.key),
oldValue: events.oldValue,
newValue: events.newValue
};
}
}
function formatMutationType(type) {
switch (type) {
case exports.MutationType.direct:
return 'mutation';
case exports.MutationType.patchFunction:
return '$patch';
case exports.MutationType.patchObject:
return '$patch';
default:
return 'unknown';
}
}
// timeline can be paused when directly changing the state
let isTimelineActive = true;
const componentStateTypes = [];
const MUTATIONS_LAYER_ID = 'pinia:mutations';
const INSPECTOR_ID = 'pinia';
/**
* Gets the displayed name of a store in devtools
*
* @param id - id of the store
* @returns a formatted string
*/
const getStoreType = id => ':Pinia: ' + id;
/**
* Add the pinia plugin without any store. Allows displaying a Pinia plugin tab
* as soon as it is added to the application.
*
* @param app - Vue application
* @param pinia - pinia instance
*/
function registerPiniaDevtools(app, pinia) {
setupDevtoolsPlugin({
id: 'dev.esm.pinia',
label: 'Pinia',
logo: 'https://pinia.vuejs.org/logo.svg',
packageName: 'pinia',
homepage: 'https://pinia.vuejs.org',
componentStateTypes,
app
}, api => {
if (typeof api.now !== 'function') {
toastMessage('You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.');
}
api.addTimelineLayer({
id: MUTATIONS_LAYER_ID,
label: `Pinia`,
color: 0xe5df88
});
api.addInspector({
id: INSPECTOR_ID,
label: 'Pinia',
icon: 'storage',
treeFilterPlaceholder: 'Search stores',
actions: [{
icon: 'content_copy',
action: () => {
actionGlobalCopyState(pinia);
},
tooltip: 'Serialize and copy the state'
}, {
icon: 'content_paste',
action: async () => {
await actionGlobalPasteState(pinia);
api.sendInspectorTree(INSPECTOR_ID);
api.sendInspectorState(INSPECTOR_ID);
},
tooltip: 'Replace the state with the content of your clipboard'
}, {
icon: 'save',
action: () => {
actionGlobalSaveState(pinia);
},
tooltip: 'Save the state as a JSON file'
}, {
icon: 'folder_open',
action: async () => {
await actionGlobalOpenStateFile(pinia);
api.sendInspectorTree(INSPECTOR_ID);
api.sendInspectorState(INSPECTOR_ID);
},
tooltip: 'Import the state from a JSON file'
}],
nodeActions: [{
icon: 'restore',
tooltip: 'Reset the state (option store only)',
action: nodeId => {
const store = pinia._s.get(nodeId);
if (!store) {
toastMessage(`Cannot reset "${nodeId}" store because it wasn't found.`, 'warn');
} else if (!store._isOptionsAPI) {
toastMessage(`Cannot reset "${nodeId}" store because it's a setup store.`, 'warn');
} else {
store.$reset();
toastMessage(`Store "${nodeId}" reset.`);
}
}
}]
});
api.on.inspectComponent((payload, ctx) => {
const proxy = payload.componentInstance && payload.componentInstance.proxy;
if (proxy && proxy._pStores) {
const piniaStores = payload.componentInstance.proxy._pStores;
Object.values(piniaStores).forEach(store => {
payload.instanceData.state.push({
type: getStoreType(store.$id),
key: 'state',
editable: true,
value: store._isOptionsAPI ? {
_custom: {
value: ui_vue3.toRaw(store.$state),
actions: [{
icon: 'restore',
tooltip: 'Reset the state of this store',
action: () => store.$reset()
}]
}
} :
// NOTE: workaround to unwrap transferred refs
Object.keys(store.$state).reduce((state, key) => {
state[key] = store.$state[key];
return state;
}, {})
});
if (store._getters && store._getters.length) {
payload.instanceData.state.push({
type: getStoreType(store.$id),
key: 'getters',
editable: false,
value: store._getters.reduce((getters, key) => {
try {
getters[key] = store[key];
} catch (error) {
// @ts-expect-error: we just want to show it in devtools
getters[key] = error;
}
return getters;
}, {})
});
}
});
}
});
api.on.getInspectorTree(payload => {
if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
let stores = [pinia];
stores = stores.concat(Array.from(pinia._s.values()));
payload.rootNodes = (payload.filter ? stores.filter(store => '$id' in store ? store.$id.toLowerCase().includes(payload.filter.toLowerCase()) : PINIA_ROOT_LABEL.toLowerCase().includes(payload.filter.toLowerCase())) : stores).map(formatStoreForInspectorTree);
}
});
api.on.getInspectorState(payload => {
if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
const inspectedStore = payload.nodeId === PINIA_ROOT_ID ? pinia : pinia._s.get(payload.nodeId);
if (!inspectedStore) {
// this could be the selected store restored for a different project
// so it's better not to say anything here
return;
}
if (inspectedStore) {
payload.state = formatStoreForInspectorState(inspectedStore);
}
}
});
api.on.editInspectorState((payload, ctx) => {
if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
const inspectedStore = payload.nodeId === PINIA_ROOT_ID ? pinia : pinia._s.get(payload.nodeId);
if (!inspectedStore) {
return toastMessage(`store "${payload.nodeId}" not found`, 'error');
}
const {
path
} = payload;
if (!isPinia(inspectedStore)) {
// access only the state
if (path.length !== 1 || !inspectedStore._customProperties.has(path[0]) || path[0] in inspectedStore.$state) {
path.unshift('$state');
}
} else {
// Root access, we can omit the `.value` because the devtools API does it for us
path.unshift('state');
}
isTimelineActive = false;
payload.set(inspectedStore, path, payload.state.value);
isTimelineActive = true;
}
});
api.on.editComponentState(payload => {
if (payload.type.startsWith(':Pinia:')) {
const storeId = payload.type.replace(/^:Pinia:\s*/, '');
const store = pinia._s.get(storeId);
if (!store) {
return toastMessage(`store "${storeId}" not found`, 'error');
}
const {
path
} = payload;
if (path[0] !== 'state') {
return toastMessage(`Invalid path for store "${storeId}":\n${path}\nOnly state can be modified.`);
}
// rewrite the first entry to be able to directly set the state as
// well as any other path
path[0] = '$state';
isTimelineActive = false;
payload.set(store, path, payload.state.value);
isTimelineActive = true;
}
});
});
}
function addStoreToDevtools(app, store) {
if (!componentStateTypes.includes(getStoreType(store.$id))) {
componentStateTypes.push(getStoreType(store.$id));
}
setupDevtoolsPlugin({
id: 'dev.esm.pinia',
label: 'Pinia',
logo: 'https://pinia.vuejs.org/logo.svg',
packageName: 'pinia',
homepage: 'https://pinia.vuejs.org',
componentStateTypes,
app,
settings: {
logStoreChanges: {
label: 'Notify about new/deleted stores',
type: 'boolean',
defaultValue: true
}
// useEmojis: {
// label: 'Use emojis in messages',
// type: 'boolean',
// defaultValue: true,
// },
}
}, api => {
// gracefully handle errors
const now = typeof api.now === 'function' ? api.now.bind(api) : Date.now;
store.$onAction(({
after,
onError,
name,
args
}) => {
const groupId = runningActionId++;
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: {
time: now(),
title: 'Start ' + name,
subtitle: 'start',
data: {
store: formatDisplay(store.$id),
action: formatDisplay(name),
args
},
groupId
}
});
after(result => {
activeAction = undefined;
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: {
time: now(),
title: 'End ' + name,
subtitle: 'end',
data: {
store: formatDisplay(store.$id),
action: formatDisplay(name),
args,
result
},
groupId
}
});
});
onError(error => {
activeAction = undefined;
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: {
time: now(),
logType: 'error',
title: 'Error ' + name,
subtitle: 'end',
data: {
store: formatDisplay(store.$id),
action: formatDisplay(name),
args,
error
},
groupId
}
});
});
}, true);
store._customProperties.forEach(name => {
ui_vue3.watch(() => ui_vue3.unref(store[name]), (newValue, oldValue) => {
api.notifyComponentUpdate();
api.sendInspectorState(INSPECTOR_ID);
if (isTimelineActive) {
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: {
time: now(),
title: 'Change',
subtitle: name,
data: {
newValue,
oldValue
},
groupId: activeAction
}
});
}
}, {
deep: true
});
});
store.$subscribe(({
events,
type
}, state) => {
api.notifyComponentUpdate();
api.sendInspectorState(INSPECTOR_ID);
if (!isTimelineActive) return;
// rootStore.state[store.id] = state
const eventData = {
time: now(),
title: formatMutationType(type),
data: {
store: formatDisplay(store.$id),
...formatEventData(events)
},
groupId: activeAction
};
// reset for the next mutation
activeAction = undefined;
if (type === exports.MutationType.patchFunction) {
eventData.subtitle = 'Down';
} else if (type === exports.MutationType.patchObject) {
eventData.subtitle = 'Patch';
} else if (events && !Array.isArray(events)) {
eventData.subtitle = events.type;
}
if (events) {
eventData.data['rawEvent(s)'] = {
_custom: {
display: 'DebuggerEvent',
type: 'object',
tooltip: 'raw DebuggerEvent[]',
value: events
}
};
}
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: eventData
});
}, {
detached: true,
flush: 'sync'
});
const hotUpdate = store._hotUpdate;
store._hotUpdate = ui_vue3.markRaw(newStore => {
hotUpdate(newStore);
api.addTimelineEvent({
layerId: MUTATIONS_LAYER_ID,
event: {
time: now(),
title: 'Hot update ' + store.$id,
subtitle: 'HMR update',
data: {
store: formatDisplay(store.$id),
info: formatDisplay(`HMR update`)
}
}
});
// update the devtools too
api.notifyComponentUpdate();
api.sendInspectorTree(INSPECTOR_ID);
api.sendInspectorState(INSPECTOR_ID);
});
const {
$dispose
} = store;
store.$dispose = () => {
$dispose();
api.notifyComponentUpdate();
api.sendInspectorTree(INSPECTOR_ID);
api.sendInspectorState(INSPECTOR_ID);
api.getSettings().logStoreChanges && toastMessage(`Disposed "${store.$id}" store`);
};
// trigger an update so it can display new registered stores
api.notifyComponentUpdate();
api.sendInspectorTree(INSPECTOR_ID);
api.sendInspectorState(INSPECTOR_ID);
api.getSettings().logStoreChanges && toastMessage(`"${store.$id}" store installed`);
});
}
let runningActionId = 0;
let activeAction;
/**
* Patches a store to enable action grouping in devtools by wrapping the store with a Proxy that is passed as the
* context of all actions, allowing us to set `runningAction` on each access and effectively associating any state
* mutation to the action.
*
* @param store - store to patch
* @param actionNames - list of actionst to patch
*/
function patchActionForGrouping(store, actionNames) {
// original actions of the store as they are given by pinia. We are going to override them
const actions = actionNames.reduce((storeActions, actionName) => {
// use toRaw to avoid tracking #541
storeActions[actionName] = ui_vue3.toRaw(store)[actionName];
return storeActions;
}, {});
for (const actionName in actions) {
store[actionName] = function () {
// setActivePinia(store._p)
// the running action id is incremented in a before action hook
const _actionId = runningActionId;
const trackedStore = new Proxy(store, {
get(...args) {
activeAction = _actionId;
return Reflect.get(...args);
},
set(...args) {
activeAction = _actionId;
return Reflect.set(...args);
}
});
return actions[actionName].apply(trackedStore, arguments);
};
}
}
/**
* pinia.use(devtoolsPlugin)
*/
function devtoolsPlugin({
app,
store,
options
}) {
// HMR module
if (store.$id.startsWith('__hot:')) {
return;
}
// detect option api vs setup api
if (options.state) {
store._isOptionsAPI = true;
}
// only wrap actions in option-defined stores as this technique relies on
// wrapping the context of the action with a proxy
if (typeof options.state === 'function') {
patchActionForGrouping(
// @ts-expect-error: can cast the store...
store, Object.keys(options.actions));
const originalHotUpdate = store._hotUpdate;
// Upgrade the HMR to also update the new actions
ui_vue3.toRaw(store)._hotUpdate = function (newStore) {
originalHotUpdate.apply(this, arguments);
patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions));
};
}
addStoreToDevtools(app,
// FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric?
store);
}
/**
* Creates a Pinia instance to be used by the application
*/
function createPinia() {
const scope = ui_vue3.effectScope(true);
// NOTE: here we could check the window object for a state and directly set it
// if there is anything like it with Vue 3 SSR
const state = scope.run(() => ui_vue3.ref({}));
let _p = [];
// plugins added before calling app.use(pinia)
let toBeInstalled = [];
const pinia = ui_vue3.markRaw({
install(app) {
// this allows calling useStore() outside of a component setup after
// installing pinia's plugin
setActivePinia(pinia);
{
pinia._a = app;
app.provide(piniaSymbol, pinia);
app.config.globalProperties.$pinia = pinia;
/* istanbul ignore else */
if (USE_DEVTOOLS) {
registerPiniaDevtools(app, pinia);
}
toBeInstalled.forEach(plugin => _p.push(plugin));
toBeInstalled = [];
}
},
use(plugin) {
if (!this._a && !isVue2) {
toBeInstalled.push(plugin);
} else {
_p.push(plugin);
}
return this;
},
_p,
// it's actually undefined here
// @ts-expect-error
_a: null,
_e: scope,
_s: new Map(),
state
});
// pinia devtools rely on dev only features so they cannot be forced unless
// the dev build of Vue is used. Avoid old browsers like IE11.
if (USE_DEVTOOLS && typeof Proxy !== 'undefined') {
pinia.use(devtoolsPlugin);
}
return pinia;
}
/**
* Checks if a function is a `StoreDefinition`.
*
* @param fn - object to test
* @returns true if `fn` is a StoreDefinition
*/
const isUseStore = fn => {
return typeof fn === 'function' && typeof fn.$id === 'string';
};
/**
* 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) && !ui_vue3.isRef(subPatch) && !ui_vue3.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;
}
/**
* Creates an _accept_ function to pass to `import.meta.hot` in Vite applications.
*
* @example
* ```js
* const useUser = defineStore(...)
* if (import.meta.hot) {
* import.meta.hot.accept(acceptHMRUpdate(useUser, import.meta.hot))
* }
* ```
*
* @param initialUseStore - return of the defineStore to hot update
* @param hot - `import.meta.hot`
*/
function acceptHMRUpdate(initialUseStore, hot) {
return newModule => {
const pinia = hot.data.pinia || initialUseStore._pinia;
if (!pinia) {
// this store is still not used
return;
}
// preserve the pinia instance across loads
hot.data.pinia = pinia;
// console.log('got data', newStore)
for (const exportName in newModule) {
const useStore = newModule[exportName];
// console.log('checking for', exportName)
if (isUseStore(useStore) && pinia._s.has(useStore.$id)) {
// console.log('Accepting update for', useStore.$id)
const id = useStore.$id;
if (id !== initialUseStore.$id) {
console.warn(`The id of the store changed from "${initialUseStore.$id}" to "${id}". Reloading.`);
// return import.meta.hot.invalidate()
return hot.invalidate();
}
const existingStore = pinia._s.get(id);
if (!existingStore) {
console.log(`[Pinia]: skipping hmr because store doesn't exist yet`);
return;
}
useStore(pinia, existingStore);
}
}
};
}
const noop = () => {};
function addSubscription(subscriptions, callback, detached, onCleanup = noop) {
subscriptions.push(callback);
const removeSubscription = () => {
const idx = subscriptions.indexOf(callback);
if (idx > -1) {
subscriptions.splice(idx, 1);
onCleanup();
}
};
if (!detached && ui_vue3.getCurrentInstance()) {
ui_vue3.onUnmounted(removeSubscription);
}
return removeSubscription;
}
function triggerSubscriptions(subscriptions, ...args) {
subscriptions.slice().forEach(callback => {
callback(...args);
});
}
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) && !ui_vue3.isRef(subPatch) && !ui_vue3.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 = Symbol('pinia:skipHydration');
/**
* Tells Pinia to skip the hydration process of a given object. This is useful in setup stores (only) when you return a
* stateful object in the store but it isn't really state. e.g. returning a router instance in a setup store.
*
* @param obj - target object
* @returns obj
*/
function skipHydrate(obj) {
return Object.defineProperty(obj, skipHydrateSymbol, {});
}
function shouldHydrate(obj) {
return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
}
const {
assign
} = Object;
function isComputed(o) {
return !!(ui_vue3.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 && !hot) {
/* istanbul ignore if */
{
pinia.state.value[id] = state ? state() : {};
}
}
// avoid creating a state in pinia.state.value
const localState = hot ?
// use ref() to unwrap refs inside state TODO: check if this is still necessary
ui_vue3.toRefs(ui_vue3.ref(state ? state() : {}).value) : ui_vue3.toRefs(pinia.state.value[id]);
return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
if (name in localState) {
console.warn(`[Pinia]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
}
computedGetters[name] = ui_vue3.markRaw(ui_vue3.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);
store.$reset = function $reset() {
const newState = state ? state() : {};
// we use a patch to group all changes into one single subscription
this.$patch($state => {
assign($state, newState);
});
};
return store;
}
function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
let scope;
const optionsForPlugin = assign({
actions: {}
}, options);
/* istanbul ignore if */
// @ts-expect-error: active is an internal property
if (!pinia._e.active) {
throw new Error('Pinia destroyed');
}
// watcher options for $subscribe
const $subscribeOptions = {
deep: true
// flush: 'post',
};
/* istanbul ignore else */
{
$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('Pinia: 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 = ui_vue3.markRaw([]);
let actionSubscriptions = ui_vue3.markRaw([]);
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 && !hot) {
/* istanbul ignore if */
{
pinia.state.value[$id] = {};
}
}
const hotState = ui_vue3.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 */
{
debuggerEvents = [];
}
if (typeof partialStateOrMutator === 'function') {
partialStateOrMutator(pinia.state.value[$id]);
subscriptionMutation = {
type: exports.MutationType.patchFunction,
storeId: $id,
events: debuggerEvents
};
} else {
mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
subscriptionMutation = {
type: exports.MutationType.patchObject,
payload: partialStateOrMutator,
storeId: $id,
events: debuggerEvents
};
}
const myListenerId = activeListener = Symbol();
ui_vue3.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]);
}
/* istanbul ignore next */
const $reset = () => {
throw new Error(`Pinia: Store "${$id}" is built using the setup syntax and does not implement $reset().`);
};
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);
});
}
// allow the afterCallback to override the return value
triggerSubscriptions(afterCallbackList, ret);
return ret;
};
}
const _hmrPayload = /*#__PURE__*/ui_vue3.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(() => ui_vue3.watch(() => pinia.state.value[$id], state => {
if (options.flush === 'sync' ? isSyncListening : isListening) {
callback({
storeId: $id,
type: exports.MutationType.direct,
events: debuggerEvents
}, state);
}
}, assign({}, $subscribeOptions, options)));
return removeSubscription;
},
$dispose
};
const store = ui_vue3.reactive(assign(IS_CLIENT ?
// devtools custom properties
{
_customProperties: ui_vue3.markRaw(new Set()),
_hmrPayload
} : {}, partialStore
// must be added later
// setupStore
));
// 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);
// TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
const setupStore = pinia._e.run(() => {
scope = ui_vue3.effectScope();
return scope.run(() => setup());
});
// overwrite existing actions to support $onAction
for (const key in setupStore) {
const prop = setupStore[key];
if (ui_vue3.isRef(prop) && !isComputed(prop) || ui_vue3.isReactive(prop)) {
// mark it as a piece of state to be serialized
if (hot) {
set(hotState.value, key, ui_vue3.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 (ui_vue3.isRef(prop)) {
prop.value = initialState[key];
} else {
// probably a reactive object, lets recursively assign
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 */
{
_hmrPayload.state.push(key);
}
// action
} else if (typeof prop === 'function') {
// @ts-expect-error: we are overriding the function we avoid wrapping if
const actionValue = 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 */
{
_hmrPayload.actions[key] = prop;
}
// list actions so they can be used in plugins
// @ts-expect-error
optionsForPlugin.actions[key] = prop;
} else {
// add getters for devtools
if (isComputed(prop)) {
_hmrPayload.getters[key] = isOptionsStore ?
// @ts-expect-error
options.getters[key] : prop;
if (IS_CLIENT) {
const getters =
// @ts-expect-error: it should be on the store
setupStore._getters || (setupStore._getters = ui_vue3.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(ui_vue3.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: () => hot ? hotState.value : pinia.state.value[$id],
set: state => {
/* istanbul ignore if */
if (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 */
{
store._hotUpdate = ui_vue3.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, ui_vue3.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] = ui_vue3.toRef(newStore._hmrPayload, 'hotState');
isSyncListening = true;
ui_vue3.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 ?
// special handling of options api
ui_vue3.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;
});
const nonEnumerable = {
writable: true,
configurable: true,
// avoid warning on devtools trying to display this property
enumerable: false
};
if (IS_CLIENT) {
['_p', '_hmrPayload', '_getters', '_customProperties'].forEach(p => {
Object.defineProperty(store, p, {
value: store[p],
...nonEnumerable
});
});
}
}
// apply all plugins
pinia._p.forEach(extender => {
/* istanbul ignore else */
if (IS_CLIENT) {
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 (store.$state && typeof store.$state === 'object' && typeof store.$state.constructor === 'function' && !store.$state.constructor.toString().includes('[native code]')) {
console.warn(`[Pinia]: 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';
if (typeof idOrOptions === 'string') {
id = idOrOptions;
// the option store setup will contain the actual options in this case
options = isSetupStore ? setupOptions : setup;
} else {
options = idOrOptions;
id = idOrOptions.id;
}
function useStore(pinia, hot) {
const currentInstance = ui_vue3.getCurrentInstance();
pinia =
// in test mode, ignore the argument provided as we can always retrieve a
// pinia instance with getActivePinia()
pinia || currentInstance && ui_vue3.inject(piniaSymbol);
if (pinia) setActivePinia(pinia);
if (!activePinia) {
throw new Error(`[Pinia]: getActivePinia was called with no active Pinia. Did you forget to install pinia?\n` + `\tconst pinia = createPinia()\n` + `\tapp.use(pinia)\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 */
{
// @ts-expect-error: not the right inferred type
useStore._pinia = pinia;
}
}
const store = pinia._s.get(id);
if (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);
}
// save stores in instances to access them devtools
if (IS_CLIENT && 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;
}
let mapStoreSuffix = 'Store';
/**
* Changes the suffix added by `mapStores()`. Can be set to an empty string.
* Defaults to `"Store"`. Make sure to extend the MapStoresCustomization
* interface if you are using TypeScript.
*
* @param suffix - new suffix
*/
function setMapStoreSuffix(suffix // could be 'Store' but that would be annoying for JS
) {
mapStoreSuffix = suffix;
}
/**
* Allows using stores without the composition API (`setup()`) by generating an
* object to be spread in the `computed` field of a component. It accepts a list
* of store definitions.
*
* @example
* ```js
* export default {
* computed: {
* // other computed properties
* ...mapStores(useUserStore, useCartStore)
* },
*
* created() {
* this.userStore // store with id "user"
* this.cartStore // store with id "cart"
* }
* }
* ```
*
* @param stores - list of stores to map to an object
*/
function mapStores(...stores) {
if (Array.isArray(stores[0])) {
console.warn(`[Pinia]: Directly pass all stores to "mapStores()" without putting them in an array:\n` + `Replace\n` + `\tmapStores([useAuthStore, useCartStore])\n` + `with\n` + `\tmapStores(useAuthStore, useCartStore)\n` + `This will fail in production if not fixed.`);
stores = stores[0];
}
return stores.reduce((reduced, useStore) => {
// @ts-expect-error: $id is added by defineStore
reduced[useStore.$id + mapStoreSuffix] = function () {
return useStore(this.$pinia);
};
return reduced;
}, {});
}
/**
* Allows using state and getters from one store without using the composition
* API (`setup()`) by generating an object to be spread in the `computed` field
* of a component.
*
* @param useStore - store to map from
* @param keysOrMapper - array or object
*/
function mapState(useStore, keysOrMapper) {
return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
reduced[key] = function () {
return useStore(this.$pinia)[key];
};
return reduced;
}, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
// @ts-expect-error
reduced[key] = function () {
const store = useStore(this.$pinia);
const storeKey = keysOrMapper[key];
// for some reason TS is unable to infer the type of storeKey to be a
// function
return typeof storeKey === 'function' ? storeKey.call(this, store) : store[storeKey];
};
return reduced;
}, {});
}
/**
* Alias for `mapState()`. You should use `mapState()` instead.
* @deprecated use `mapState()` instead.
*/
const mapGetters = mapState;
/**
* Allows directly using actions from your store without using the composition
* API (`setup()`) by generating an object to be spread in the `methods` field
* of a component.
*
* @param useStore - store to map from
* @param keysOrMapper - array or object
*/
function mapActions(useStore, keysOrMapper) {
return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
// @ts-expect-error
reduced[key] = function (...args) {
return useStore(this.$pinia)[key](...args);
};
return reduced;
}, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
// @ts-expect-error
reduced[key] = function (...args) {
return useStore(this.$pinia)[keysOrMapper[key]](...args);
};
return reduced;
}, {});
}
/**
* Allows using state and getters from one store without using the composition
* API (`setup()`) by generating an object to be spread in the `computed` field
* of a component.
*
* @param useStore - store to map from
* @param keysOrMapper - array or object
*/
function mapWritableState(useStore, keysOrMapper) {
return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
// @ts-ignore
reduced[key] = {
get() {
return useStore(this.$pinia)[key];
},
set(value) {
// it's easier to type it here as any
return useStore(this.$pinia)[key] = value;
}
};
return reduced;
}, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
// @ts-ignore
reduced[key] = {
get() {
return useStore(this.$pinia)[keysOrMapper[key]];
},
set(value) {
// it's easier to type it here as any
return useStore(this.$pinia)[keysOrMapper[key]] = value;
}
};
return reduced;
}, {});
}
/**
* 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(store) {
// See https://github.com/vuejs/pinia/issues/852
// It's easier to just use toRefs() even if it includes more stuff
{
store = ui_vue3.toRaw(store);
const refs = {};
for (const key in store) {
const value = store[key];
if (ui_vue3.isRef(value) || ui_vue3.isReactive(value)) {
// @ts-expect-error: the key is state or getter
refs[key] =
// ---
ui_vue3.toRef(store, key);
}
}
return refs;
}
}
/**
* Vue 2 Plugin that must be installed for pinia to work. Note **you don't need
* this plugin if you are using Nuxt.js**. Use the `buildModule` instead:
* https://pinia.vuejs.org/ssr/nuxt.html.
*
* @example
* ```js
* import Vue from 'vue'
* import { PiniaVuePlugin, createPinia } from 'pinia'
*
* Vue.use(PiniaVuePlugin)
* const pinia = createPinia()
*
* new Vue({
* el: '#app',
* // ...
* pinia,
* })
* ```
*
* @param _Vue - `Vue` imported from 'vue'.
*/
const PiniaVuePlugin = function (_Vue) {
// Equivalent of
// app.config.globalProperties.$pinia = pinia
_Vue.mixin({
beforeCreate() {
const options = this.$options;
if (options.pinia) {
const pinia = options.pinia;
// HACK: taken from provide(): https://github.com/vuejs/composition-api/blob/main/src/apis/inject.ts#L31
/* istanbul ignore else */
if (!this._provided) {
const provideCache = {};
Object.defineProperty(this, '_provided', {
get: () => provideCache,
set: v => Object.assign(provideCache, v)
});
}
this._provided[piniaSymbol] = pinia;
// propagate the pinia instance in an SSR friendly way
// avoid adding it to nuxt twice
/* istanbul ignore else */
if (!this.$pinia) {
this.$pinia = pinia;
}
pinia._a = this;
if (IS_CLIENT) {
// this allows calling useStore() outside of a component setup after
// installing pinia's plugin
setActivePinia(pinia);
}
if (USE_DEVTOOLS) {
registerPiniaDevtools(pinia._a, pinia);
}
} else if (!this.$pinia && options.parent && options.parent.$pinia) {
this.$pinia = options.parent.$pinia;
}
},
destroyed() {
delete this._pStores;
}
});
};
// origin-end
const version = '2.0.22';
exports.PiniaVuePlugin = PiniaVuePlugin;
exports.acceptHMRUpdate = acceptHMRUpdate;
exports.createPinia = createPinia;
exports.defineStore = defineStore;
exports.getActivePinia = getActivePinia;
exports.mapActions = mapActions;
exports.mapGetters = mapGetters;
exports.mapState = mapState;
exports.mapStores = mapStores;
exports.mapWritableState = mapWritableState;
exports.setActivePinia = setActivePinia;
exports.setMapStoreSuffix = setMapStoreSuffix;
exports.skipHydrate = skipHydrate;
exports.storeToRefs = storeToRefs;
exports.version = version;
}((this.BX.Vue3.Pinia = this.BX.Vue3.Pinia || {}),BX.Vue3));
})();
//# sourceMappingURL=pinia.bundle.js.map