File manager

File manager - Edit - /home/web/vm-3fadc827.na4u.ru/www/bitrix/modules/ui/install/js/ui/vue3/pinia/dist/pinia.bundle.js

Back
;(function() { if ( typeof this.BX !== 'undefined' && typeof this.BX.Vue3 !== 'undefined' && typeof this.BX.Vue3.Pinia !== 'undefined' ) { var currentVersion = '2.0.11'; 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.11 * (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 environmentMode = ui_vue3.BitrixVue.developerMode ? 'development' : 'production'; 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 = environmentMode !== '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 / (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'; / * 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=\sutf-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 => { 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' }] }); 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: store.$state, actions: [{ icon: 'restore', tooltip: 'Reset the state of this store', action: () => store.$reset() }] } } : store.$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) => { getters[key] = store[key]; 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: {// useEmojis: { // label: 'Use emojis in messages', // type: 'boolean', // defaultValue: true, // }, } }, api => { store.$onAction(({ after, onError, name, args }) => { const groupId = runningActionId++; api.addTimelineEvent({ layerId: MUTATIONS_LAYER_ID, event: { time: Date.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: Date.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: Date.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: Date.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: Date.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: Date.now(), title: '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); 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); 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 (environmentMode !== 'production' && IS_CLIENT) { 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 if (environmentMode !== 'production' && IS_CLIENT) { 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(`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) { // no need to go through symbols because they cannot be serialized anyway for (const key in patchToApply) { const subPatch = patchToApply[key]; const targetValue = target[key]; if (isPlainObject(targetValue) && isPlainObject(subPatch) && !ui_vue3.isRef(subPatch) && !ui_vue3.isReactive(subPatch)) { target[key] = mergeReactiveObjects(targetValue, subPatch); } else { // @ts-expect-error: subPatch is a valid value target[key] = subPatch; } } return target; } const skipHydrateSymbol = environmentMode !== 'production' ? Symbol('pinia:skipHydration') : / istanbul ignore next / Symbol(); 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 && (!(environmentMode !== 'production') \|\| !hot)) { / istanbul ignore if / { pinia.state.value[id] = state ? state() : {}; } } // avoid creating a state in pinia.state.value const localState = environmentMode !== 'production' && 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) => { computedGetters[name] = ui_vue3.markRaw(ui_vue3.computed(() => { setActivePinia(pinia); // it was created just before const store = pinia._s.get(id); // allow cross using stores // 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); 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) { let scope; const buildState = options.state; const optionsForPlugin = assign({ actions: {} }, options); / istanbul ignore if / if (environmentMode !== 'production' && !pinia._e.active) { throw new Error('Pinia destroyed'); } // watcher options for $subscribe const $subscribeOptions = { deep: true // flush: 'post', }; / istanbul ignore else / if (environmentMode !== '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('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 are it is set // by the setup if (!buildState && !initialState && (!(environmentMode !== 'production') \|\| !hot)) { / istanbul ignore if / { pinia.state.value[$id] = {}; } } const hotState = ui_vue3.ref({}); function $patch(partialStateOrMutator) { let subscriptionMutation; isListening = isSyncListening = false; // reset the debugger events since patches are sync / istanbul ignore else / if (environmentMode !== 'production') { 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 }; } ui_vue3.nextTick().then(() => { 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 = environmentMode !== 'production' ? () => { throw new Error(`Pinia: Store "${$id}" is build using the setup syntax and does not implement $reset().`); } : noop; 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(environmentMode !== 'production' && 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 (environmentMode !== 'production' && 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 (!buildState) { // 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 / if (environmentMode !== '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 = environmentMode !== '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 (environmentMode !== 'production') { _hmrPayload.actions[key] = prop; } // list actions so they can be used in plugins // @ts-expect-error optionsForPlugin.actions[key] = prop; } else if (environmentMode !== 'production') { // add getters for devtools if (isComputed(prop)) { _hmrPayload.getters[key] = buildState ? // @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: () => environmentMode !== 'production' && hot ? hotState.value : pinia.state.value[$id], set: state => { / istanbul ignore if / if (environmentMode !== '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 (environmentMode !== 'production') { 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 = buildState ? // 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 }); }); } } pinia._p.forEach(extender => { / istanbul ignore else / if (environmentMode !== 'production' && 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 (environmentMode !== 'production' && 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 && buildState && 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() (environmentMode === 'test' && activePinia && activePinia._testing ? null : pinia) \|\| currentInstance && ui_vue3.inject(piniaSymbol); if (pinia) setActivePinia(pinia); if (environmentMode !== 'production' && !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 / if (environmentMode !== 'production') { // @ts-expect-error: not the right inferred type useStore._pinia = pinia; } } const store = pinia._s.get(id); if (environmentMode !== '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); } // save stores in instances to access them devtools if (environmentMode !== 'production' && 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 need 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 (environmentMode !== 'production' && 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) { 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/master/src/apis/inject.ts#L30 / 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 (environmentMode !== 'production') { registerPiniaDevtools(pinia._a, pinia); } } } else if (!this.$pinia && options.parent && options.parent.$pinia) { this.$pinia = options.parent.$pinia; } }, destroyed() { delete this._pStores; } }); }; const version = '2.0.11'; 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

| ver. 1.4 | Github | . | PHP 7.4.33 | Generation time: 0.28 | proxy | phpinfo | Settings