vuex-composition-helpers - npm Package Compare versions

Comparing version 1.0.26 to 1.1.0

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

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

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>;

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>;

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>;

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>;
 };

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 <[e-mail]>",

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 @@

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);
+}

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),
 	}
 }

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>;

No alert changes

Improved metrics

Total package byte prevSize

41424

increased by13.35%

Lines of code

562

increased by10.63%

Number of lines in readme file

284

increased by4.8%

No dependency changes