🚀 Big News: Socket Acquires Coana to Bring Reachability Analysis to Every Appsec Team.Learn more →
Socket
Book a DemoInstallSign in
Socket
Book a DemoInstallSign in

vuex-composition-helpers

Package Overview
Dependencies
Maintainers
1
Versions
35
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vuex-composition-helpers - npm Package Compare versions

Comparing version

1.0.26
to
1.1.0

120

dist/global.js

@@ -6,37 +6,109 @@ import { computed } from '@vue/composition-api';

}
function computedNamespacedState(store, namespace, prop) {
let module = namespace.split('/').reduce((module, key) => module[key], store.state);
return computed(() => module[prop]);
}
export function useStore() {
return getStoreFromInstance();
}
export function useState(storeOrMap, map) {
let store = storeOrMap;
if (arguments.length === 1) {
map = store;
store = getStoreFromInstance();
export function useState(storeOrNamespace, namespaceOrMap, map) {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = namespaceOrMap || null;
realMap = map || null;
}
return useMapping(store, null, map, computedState);
else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace || null;
}
else {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = null;
}
realMap = namespaceOrMap || null;
}
else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace || null;
}
return useMapping(realStore, realNamespace, realMap, !realNamespace ? computedState : computedNamespacedState);
}
export function useGetters(storeOrMap, map) {
let store = storeOrMap;
if (arguments.length === 1) {
map = store;
store = getStoreFromInstance();
export function useGetters(storeOrNamespace, namespaceOrMap, map) {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = namespaceOrMap || null;
realMap = map || null;
}
return useMapping(store, null, map, computedGetter);
else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace || null;
}
else {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = null;
}
realMap = namespaceOrMap || null;
}
else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace || null;
}
return useMapping(realStore, realNamespace, realMap, computedGetter);
}
export function useMutations(storeOrMap, map) {
let store = storeOrMap;
if (arguments.length === 1) {
map = store;
store = getStoreFromInstance();
export function useMutations(storeOrNamespace, namespaceOrMap, map) {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = namespaceOrMap || null;
realMap = map || null;
}
return useMapping(store, null, map, getMutation);
else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace || null;
}
else {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = null;
}
realMap = namespaceOrMap || null;
}
else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace || null;
}
return useMapping(realStore, realNamespace, realMap, getMutation);
}
export function useActions(storeOrMap, map) {
let store = storeOrMap;
if (arguments.length === 1) {
map = store;
store = getStoreFromInstance();
export function useActions(storeOrNamespace, namespaceOrMap, map) {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = namespaceOrMap || null;
realMap = map || null;
}
return useMapping(store, null, map, getAction);
else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace || null;
}
else {
realStore = storeOrNamespace || getStoreFromInstance();
realNamespace = null;
}
realMap = namespaceOrMap || null;
}
else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace || null;
}
return useMapping(realStore, realNamespace, realMap, getAction);
}
//# sourceMappingURL=global.js.map

71

dist/namespaced.js

@@ -1,59 +0,6 @@

import { computed } from '@vue/composition-api';
import { computedGetter, getAction, getMutation, getStoreFromInstance, useMapping } from './util';
function computedState(store, namespace, prop) {
let module = namespace.split('/').reduce((module, key) => module[key], store.state);
return computed(() => module[prop]);
}
export function useNamespacedState(storeOrNamespace, namespaceOrMap, map) {
let store, namespace;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap;
namespace = storeOrNamespace;
}
else {
store = storeOrNamespace || getStoreFromInstance();
namespace = namespaceOrMap;
}
return useMapping(store, namespace, map, computedState);
}
export function useNamespacedMutations(storeOrNamespace, namespaceOrMap, map) {
let store, namespace;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap;
namespace = storeOrNamespace;
}
else {
store = storeOrNamespace || getStoreFromInstance();
namespace = namespaceOrMap;
}
return useMapping(store, namespace, map, getMutation);
}
export function useNamespacedActions(storeOrNamespace, namespaceOrMap, map) {
let store, namespace;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap;
namespace = storeOrNamespace;
}
else {
store = storeOrNamespace || getStoreFromInstance();
namespace = namespaceOrMap;
}
return useMapping(store, namespace, map, getAction);
}
export function useNamespacedGetters(storeOrNamespace, namespaceOrMap, map) {
let store, namespace;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap;
namespace = storeOrNamespace;
}
else {
store = storeOrNamespace || getStoreFromInstance();
namespace = namespaceOrMap;
}
return useMapping(store, namespace, map, computedGetter);
}
import { useActions, useState, useGetters, useMutations } from './global';
export const useNamespacedActions = useActions;
export const useNamespacedGetters = useGetters;
export const useNamespacedMutations = useMutations;
export const useNamespacedState = useState;
export function createNamespacedHelpers(storeOrNamespace, namespace) {

@@ -71,8 +18,8 @@ let store = undefined;

return {
useState: (map) => useNamespacedState(store, namespace, map),
useGetters: (map) => useNamespacedGetters(store, namespace, map),
useMutations: (map) => useNamespacedMutations(store, namespace, map),
useActions: (map) => useNamespacedActions(store, namespace, map),
useState: (map) => useState(store, namespace, map),
useGetters: (map) => useGetters(store, namespace, map),
useMutations: (map) => useMutations(store, namespace, map),
useActions: (map) => useActions(store, namespace, map),
};
}
//# sourceMappingURL=namespaced.js.map

18

dist/types/global.d.ts
import { Store } from 'vuex/types';
import { ExtractGetterTypes, ExtractTypes, KnownKeys, RefTypes } from './util';
import { ExtractGetterTypes, ExtractTypes, KnownKeys, RefTypes, Namespace, Nullish } from './util';
export declare function useStore<TState = any>(): Store<TState>;
export declare function useState<TState = any>(storeOrMap: Store<TState> | KnownKeys<TState>[], map?: KnownKeys<TState>[]): RefTypes<TState>;
export declare function useGetters<TGetters = any>(storeOrMap: Store<any> | KnownKeys<TGetters>[], map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export declare function useMutations<TMutations = any>(storeOrMap: Store<any> | KnownKeys<TMutations>[], map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export declare function useActions<TActions = any>(storeOrMap: Store<any> | KnownKeys<TActions>[], map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export declare function useState<TState = any>(map: KnownKeys<TState>[]): RefTypes<TState>;
export declare function useState<TState = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TState>[]): RefTypes<TState>;
export declare function useState<TState = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TState>[]): RefTypes<TState>;
export declare function useGetters<TGetters = any>(map: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export declare function useGetters<TGetters = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export declare function useGetters<TGetters = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export declare function useMutations<TMutations = any>(map: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export declare function useMutations<TMutations = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export declare function useMutations<TMutations = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export declare function useActions<TActions = any>(map: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export declare function useActions<TActions = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export declare function useActions<TActions = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;

12

dist/types/namespaced.d.ts

@@ -0,8 +1,8 @@

import { Store } from 'vuex';
import { KnownKeys, RefTypes, ExtractTypes, ExtractGetterTypes } from './util';
import { Store } from 'vuex';
export declare type Nullish = null | undefined;
export declare function useNamespacedState<TState = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TState>[], map?: KnownKeys<TState>[]): RefTypes<TState>;
export declare function useNamespacedMutations<TMutations = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TMutations>[], map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export declare function useNamespacedActions<TActions = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TActions>[], map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export declare function useNamespacedGetters<TGetters = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TGetters>[], map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
import { useActions, useState, useGetters, useMutations } from './global';
export declare const useNamespacedActions: typeof useActions;
export declare const useNamespacedGetters: typeof useGetters;
export declare const useNamespacedMutations: typeof useMutations;
export declare const useNamespacedState: typeof useState;
export declare function createNamespacedHelpers<TState = any, TGetters = any, TActions = any, TMutations = any>(storeOrNamespace: Store<any> | string, namespace?: string): {

@@ -9,0 +9,0 @@ useState: (map?: KnownKeys<TState>[]) => RefTypes<TState>;

2

dist/types/util.d.ts

@@ -5,2 +5,4 @@ import { Ref } from '@vue/composition-api';

declare type InferGetterType<T> = T extends (...args: any) => any ? ReturnType<T> : any;
export declare type Nullish = null | undefined;
export declare type Namespace = string | Nullish;
export declare type ExtractTypes<O, TUnknown = any> = {

@@ -7,0 +9,0 @@ readonly [K in keyof O]: InferType<O[K], TUnknown>;

8

dist/types/wrapper.d.ts

@@ -8,6 +8,6 @@ export declare function wrapStore(store: any): {

};
useActions: (map?: unknown[] | undefined) => import("./util").ExtractTypes<unknown, Function>;
useGetters: (map?: unknown[] | undefined) => import("./util").ExtractGetterTypes<unknown>;
useMutations: (map?: unknown[] | undefined) => import("./util").ExtractTypes<unknown, Function>;
useState: (map?: unknown[] | undefined) => import("./util").RefTypes<unknown>;
useActions: (namespace?: import("./util").Namespace, map?: unknown[] | undefined) => import("./util").ExtractTypes<unknown, Function>;
useGetters: (namespace?: import("./util").Namespace, map?: unknown[] | undefined) => import("./util").ExtractGetterTypes<unknown>;
useMutations: (namespace?: import("./util").Namespace, map?: unknown[] | undefined) => import("./util").ExtractTypes<unknown, Function>;
useState: (namespace?: import("./util").Namespace, map?: unknown[] | undefined) => import("./util").RefTypes<unknown>;
};

2

package.json
{
"name": "vuex-composition-helpers",
"version": "1.0.26",
"version": "1.1.0",
"description": "Helpers to use Vuex store form Vue Composition API",

@@ -5,0 +5,0 @@ "author": "David Meir-Levy <davidmeirlevy@gmail.com>",

15

README.md

@@ -52,2 +52,3 @@ # vuex-composition-helpers

#### `createNamespacedHelpers`
```js

@@ -80,3 +81,3 @@ import { createNamespacedHelpers } from 'vuex-composition-helpers';

import store from '../store'; // local store file
const { useState, useActions } = createNamespacedHelpers(store, 'articles'); // specific module name
import const { useState, useActions } = createNamespacedHelpers(store, 'articles'); // specific module name
const { fetch } = useActions(['fetch']);

@@ -101,2 +102,14 @@

#### Inline namespacing
```js
import { useState, useActions } from 'vuex-composition-helpers';
export default {
setup(props) {
const { article, comments } = useState('sections/blog', ['article', 'comments']);
return { article, comments }
}
}
```
### Typescript mappings

@@ -103,0 +116,0 @@

128

src/global.ts
import {Store} from 'vuex/types';
import {computed} from '@vue/composition-api';
import {computedGetter, getAction, getMutation, getStoreFromInstance, useMapping, ExtractGetterTypes, ExtractTypes, KnownKeys, RefTypes} from './util';
import {computedGetter, getAction, getMutation, getStoreFromInstance, useMapping, ExtractGetterTypes, ExtractTypes, KnownKeys, RefTypes, Namespace, Nullish} from './util';

@@ -9,2 +9,7 @@ function computedState(store: any, prop: string) {

function computedNamespacedState(store: any, namespace: string, prop: string) {
let module = namespace.split('/').reduce((module, key) => module[key], store.state)
return computed(() => module[prop])
}
export function useStore<TState = any>() {

@@ -14,39 +19,104 @@ return getStoreFromInstance() as Store<TState>

export function useState<TState = any>(storeOrMap: Store<TState> | KnownKeys<TState>[], map?: KnownKeys<TState>[]): RefTypes<TState> {
let store = storeOrMap;
if (arguments.length === 1) {
map = store as KnownKeys<TState>[];
store = getStoreFromInstance();
export function useState<TState = any>(map: KnownKeys<TState>[]): RefTypes<TState>;
export function useState<TState = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TState>[]): RefTypes<TState>;
export function useState<TState = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TState>[]): RefTypes<TState>;
export function useState<TState = any>(storeOrNamespace: KnownKeys<TState>[] | Store<any> | Namespace, namespaceOrMap?: KnownKeys<TState>[] | Namespace, map?: KnownKeys<TState>[]): RefTypes<TState> {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = namespaceOrMap as string || null;
realMap = map as KnownKeys<TState>[] || null;
} else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace as string || null;
} else {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = null
}
realMap = namespaceOrMap as KnownKeys<TState>[] || null;
} else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace as KnownKeys<TState>[] || null;
}
return useMapping(store, null, map, computedState);
return useMapping(realStore, realNamespace, realMap, !realNamespace ? computedState : computedNamespacedState);
}
export function useGetters<TGetters = any>(storeOrMap: Store<any> | KnownKeys<TGetters>[], map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters> {
let store = storeOrMap;
if (arguments.length === 1) {
map = store as KnownKeys<TGetters>[];
store = getStoreFromInstance();
export function useGetters<TGetters = any>(map: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export function useGetters<TGetters = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export function useGetters<TGetters = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters>;
export function useGetters<TGetters = any>(storeOrNamespace: KnownKeys<TGetters>[] | Store<any> | Namespace, namespaceOrMap?: KnownKeys<TGetters>[] | Namespace, map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters> {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = namespaceOrMap as string || null;
realMap = map as KnownKeys<TGetters>[] || null;
} else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace as string || null;
} else {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = null
}
realMap = namespaceOrMap as KnownKeys<TGetters>[] || null;
} else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace as KnownKeys<TGetters>[] || null;
}
return useMapping(store, null, map, computedGetter);
return useMapping(realStore, realNamespace, realMap, computedGetter);
}
export function useMutations<TMutations = any>(storeOrMap: Store<any> | KnownKeys<TMutations>[], map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function> {
let store = storeOrMap;
if (arguments.length === 1) {
map = store as KnownKeys<TMutations>[];
store = getStoreFromInstance();
export function useMutations<TMutations = any>(map: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export function useMutations<TMutations = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export function useMutations<TMutations = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function>;
export function useMutations<TMutations = any>(storeOrNamespace: KnownKeys<TMutations>[] | Store<any> | Namespace, namespaceOrMap?: KnownKeys<TMutations>[] | Namespace, map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function> {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = namespaceOrMap as string || null;
realMap = map as KnownKeys<TMutations>[] || null;
} else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace as string || null;
} else {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = null
}
realMap = namespaceOrMap as KnownKeys<TMutations>[] || null;
} else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace as KnownKeys<TMutations>[] || null;
}
return useMapping(store, null, map, getMutation);
return useMapping(realStore, realNamespace, realMap, getMutation);
}
export function useActions<TActions = any>(storeOrMap: Store<any> | KnownKeys<TActions>[], map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function> {
let store = storeOrMap;
if (arguments.length === 1) {
map = store as KnownKeys<TActions>[];
store = getStoreFromInstance();
export function useActions<TActions = any>(map: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export function useActions<TActions = any>(storeOrNamespace: Store<any> | Namespace, map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export function useActions<TActions = any>(store: Store<any> | Nullish, namespace?: Namespace, map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function>;
export function useActions<TActions = any>(storeOrNamespace: KnownKeys<TActions>[] | Store<any> | Namespace, namespaceOrMap?: KnownKeys<TActions>[] | Namespace, map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function> {
let realStore, realNamespace, realMap;
if (arguments.length >= 3) {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = namespaceOrMap as string || null;
realMap = map as KnownKeys<TActions>[] || null;
} else if (arguments.length === 2) {
if (typeof storeOrNamespace === 'string') {
realStore = getStoreFromInstance();
realNamespace = storeOrNamespace as string || null;
} else {
realStore = storeOrNamespace as Store<any> || getStoreFromInstance();
realNamespace = null
}
realMap = namespaceOrMap as KnownKeys<TActions>[] || null;
} else {
realStore = getStoreFromInstance();
realNamespace = null;
realMap = storeOrNamespace as KnownKeys<TActions>[] || null;
}
return useMapping(store, null, map, getAction);
}
return useMapping(realStore, realNamespace, realMap, getAction);
}

79

src/namespaced.ts

@@ -0,68 +1,11 @@

import {Store} from 'vuex';
import {computed} from '@vue/composition-api';
import {computedGetter, getAction, getMutation, getStoreFromInstance, useMapping, KnownKeys, RefTypes, ExtractTypes, ExtractGetterTypes} from './util';
import {Store} from 'vuex';
import {computedGetter, getAction, getMutation, getStoreFromInstance, useMapping, KnownKeys, RefTypes, ExtractTypes, ExtractGetterTypes, Nullish} from './util';
import {useActions, useState, useGetters, useMutations} from './global'
export type Nullish = null | undefined;
export const useNamespacedActions = useActions
export const useNamespacedGetters = useGetters
export const useNamespacedMutations = useMutations
export const useNamespacedState = useState
function computedState(store: any, namespace: string, prop: string) {
let module = namespace.split('/').reduce((module, key) => module[key], store.state)
return computed(() => module[prop])
}
export function useNamespacedState<TState = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TState>[], map?: KnownKeys<TState>[]): RefTypes<TState> {
let store: Store<any>, namespace: string;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap as KnownKeys<TState>[];
namespace = storeOrNamespace as string;
} else {
store = storeOrNamespace as Store<TState> || getStoreFromInstance();
namespace = namespaceOrMap as string;
}
return useMapping(store, namespace, map, computedState);
}
export function useNamespacedMutations<TMutations = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TMutations>[], map?: KnownKeys<TMutations>[]): ExtractTypes<TMutations, Function> {
let store: Store<any>, namespace: string;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap as KnownKeys<TMutations>[];
namespace = storeOrNamespace as string;
} else {
store = storeOrNamespace as Store<any> || getStoreFromInstance();
namespace = namespaceOrMap as string;
}
return useMapping(store, namespace, map, getMutation);
}
export function useNamespacedActions<TActions = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TActions>[], map?: KnownKeys<TActions>[]): ExtractTypes<TActions, Function> {
let store: Store<any>, namespace: string;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap as KnownKeys<TActions>[];
namespace = storeOrNamespace as string;
} else {
store = storeOrNamespace as Store<any> || getStoreFromInstance();
namespace = namespaceOrMap as string;
}
return useMapping(store, namespace, map, getAction);
}
export function useNamespacedGetters<TGetters = any>(storeOrNamespace: Store<any> | string | Nullish, namespaceOrMap: string | KnownKeys<TGetters>[], map?: KnownKeys<TGetters>[]): ExtractGetterTypes<TGetters> {
let store: Store<any>, namespace: string;
if (arguments.length === 2) {
store = getStoreFromInstance();
map = namespaceOrMap as KnownKeys<TGetters>[];
namespace = storeOrNamespace as string;
} else {
store = storeOrNamespace as Store<any> || getStoreFromInstance();
namespace = namespaceOrMap as string;
}
return useMapping(store, namespace, map, computedGetter);
}
export function createNamespacedHelpers<TState = any, TGetters = any, TActions = any, TMutations = any>(storeOrNamespace: Store<any> | string, namespace?: string):{

@@ -84,7 +27,7 @@ useState: (map?: KnownKeys<TState>[]) => RefTypes<TState>;

return {
useState: (map?: KnownKeys<TState>[]) => useNamespacedState(store, namespace as string, map),
useGetters: (map?: KnownKeys<TGetters>[]) => useNamespacedGetters(store, namespace as string, map),
useMutations: (map?: KnownKeys<TMutations>[]) => useNamespacedMutations(store, namespace as string, map),
useActions: (map?: KnownKeys<TActions>[]) => useNamespacedActions(store, namespace as string, map),
useState: (map?: KnownKeys<TState>[]) => useState(store, namespace as string, map),
useGetters: (map?: KnownKeys<TGetters>[]) => useGetters(store, namespace as string, map),
useMutations: (map?: KnownKeys<TMutations>[]) => useMutations(store, namespace as string, map),
useActions: (map?: KnownKeys<TActions>[]) => useActions(store, namespace as string, map),
}
}

4

src/util.ts

@@ -20,2 +20,6 @@ import {computed, getCurrentInstance, Ref} from '@vue/composition-api';

export declare type Nullish = null | undefined;
export declare type Namespace = string | Nullish;
export declare type ExtractTypes<O, TUnknown = any> = {

@@ -22,0 +26,0 @@ readonly [K in keyof O]: InferType<O[K], TUnknown>;

dist/global.js.map

Sorry, the diff of this file is not supported yet

dist/namespaced.js.map

Sorry, the diff of this file is not supported yet

dist/util.js.map

Sorry, the diff of this file is not supported yet