create-packer 1.28.0 → 1.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-packer",
-  "version": "1.28.0",
+  "version": "1.29.0",
   "main": "index.js",
   "repository": "https://github.com/kevily/create-packer",
   "author": "1k <bug_zero@163.com>",

package/template/web-app/react/package.json

@@ -18,14 +18,14 @@
         "commit": "git add . && npm run cz"
     },
     "dependencies": {
-        "1k-types": "1.1.2",
+        "1k-types": "1.2.0",
         "axios": "1.3.6",
         "define-zustand": "3.1.0",
         "immer": "10.0.1",
         "lodash-es": "4.17.21",
         "qs": "6.11.2",
-        "react": "18.2.0",
-        "react-dom": "18.2.0",
+        "react": "18.3.1",
+        "react-dom": "18.3.1",
         "react-router-dom": "6.14.0",
         "react-use": "17.5.0",
         "zustand": "4.4.1"

package/template/web-app/react/shared/hooks/defineRouter/defineRouter.types.ts

@@ -8,6 +8,9 @@ export type routeType = Omit<RouteObject, 'children' | 'id'> & {
         /** 只在当前路由才显示的小提示 */
         tip?: string
     }
+    /** 静态配置，便于回退 */
+    unauthorizedOrigin?: boolean
+    /** 动态使用，用于程序校验 */
     unauthorized?: boolean
     query?: () => Record<string, any>
     menu?: {

package/template/web-app/react/shared/hooks/defineRouter/deineRouter.tsx

@@ -1,160 +1,160 @@
-import { DependencyList, useEffect, useMemo } from 'react'
-import { useMatches, useSearchParams, NavigateOptions, createBrowserRouter } from 'react-router-dom'
-import { assign, isArray, reduce, get, map, split, omit, cloneDeep, last, forEach } from 'lodash-es'
-import { stringify, parse } from 'qs'
-import { defineStore } from 'define-zustand'
-import { routeByIdType, routeType, editableRouteType } from './defineRouter.types'
-
-export default function defineRouter(router: ReturnType<typeof createBrowserRouter>) {
-    const useRouter = defineStore({
-        state: () => ({
-            routes: cloneDeep(router.routes) as routeType[]
-        }),
-        getter: {
-            routesById: state => {
-                return (function flat(routes: routeType[], parentRoute?: routeByIdType) {
-                    return reduce(
-                        routes,
-                        (result, { children, ...route }, i) => {
-                            const $route: routeByIdType = {
-                                ...route,
-                                pos: parentRoute?.pos ? `${parentRoute?.pos}-${i}` : `${i}`
-                            }
-                            if (parentRoute) {
-                                $route.path = `${
-                                    parentRoute.path === '/' ? '' : parentRoute.path
-                                }/${$route.path}`
-                            }
-                            result[$route.id] = $route
-                            if (isArray(children)) {
-                                assign(result, flat(children, $route))
-                            }
-                            return result
-                        },
-                        {} as Record<string, routeByIdType>
-                    )
-                })(state.routes)
-            }
-        },
-        actions: (getState, action) => {
-            function posToLodashPath(pos: string) {
-                if (pos) {
-                    return `[${split(pos, '-').join('].children[')}]`
-                }
-                return ''
-            }
-
-            function updateRoute(id: routeType['id'], updator: (route: editableRouteType) => void) {
-                const { routesById, routes } = getState()
-                const newRoutes = cloneDeep(routes)
-                const path = posToLodashPath(routesById[id].pos)
-                const route: routeType = get(newRoutes, path)
-                const newRoute = cloneDeep(omit(route, ['element', 'errorElement', 'children']))
-                updator(newRoute)
-                assign(route, newRoute)
-                action.setState({ routes: newRoutes })
-            }
-            function getRoute(id: routeType['id'], path?: string | string[]) {
-                const { routesById } = getState()
-                const route = routesById[id]
-                if (path) {
-                    return get(route, path)
-                }
-                return route
-            }
-
-            function genRouteUrl(id: routeType['id'], query?: Record<string, any>) {
-                const path = getRoute(id, 'path')
-                if (path) {
-                    const { origin } = window.location
-                    let url = origin + router.basename + path
-                    url += query ? `?${stringify(query)}` : ''
-                    return url
-                }
-                return void 0
-            }
-
-            function openRoute(id: routeType['id'], query?: Record<string, any>) {
-                const url = genRouteUrl(id, query)
-                if (url) {
-                    window.open(url)
-                }
-            }
-
-            function reloadRoute(id: routeType['id'], query?: Record<string, any>) {
-                const url = genRouteUrl(id, query)
-                if (url) {
-                    window.location.replace(url)
-                }
-            }
-
-            function navigate(
-                to: { id: routeType['id']; query?: Record<string, any> },
-                opts?: NavigateOptions
-            ) {
-                return router.navigate(
-                    {
-                        pathname: getRoute(to.id, 'path'),
-                        search: to.query ? stringify(to.query) : ''
-                    },
-                    opts
-                )
-            }
-
-            return {
-                navigate,
-                getRoute,
-                genRouteUrl,
-                openRoute,
-                reloadRoute,
-                updateRoute
-            }
-        }
-    })
-    function useQuery<Q>() {
-        const [params] = useSearchParams()
-        const query = parse(params.toString())
-
-        return query as Q
-    }
-
-    function useMatchRoutes(): routeType[] {
-        const matches = useMatches()
-        const getRoute = useRouter(state => state.getRoute)
-        return useMemo(() => map(matches, o => getRoute(o.id)), [matches])
-    }
-
-    /**
-     * @description 验证器返回false则无权限
-     */
-    function useRoutePermission(
-        config: {
-            redirectRouteId: string
-            validator: (currentRoute?: routeType) => boolean
-        },
-        deps: DependencyList
-    ) {
-        const matchRoutes = useMatchRoutes()
-        const currentRoute = last(matchRoutes)
-        const updateRoute = useRouter(state => state.updateRoute)
-        const navigate = useRouter(state => state.navigate)
-        const routesById = useRouter(state => state.routesById)
-
-        useEffect(() => {
-            forEach(routesById, route => {
-                updateRoute(route.id, route => {
-                    route.unauthorized = !config.validator(route)
-                })
-            })
-        }, deps)
-
-        useEffect(() => {
-            const result = config.validator(currentRoute)
-            if (!result && config.redirectRouteId) {
-                navigate({ id: config.redirectRouteId }, { replace: true })
-            }
-        }, [currentRoute?.id, ...deps])
-    }
-
-    return { useRouter, useQuery, useMatchRoutes, useRoutePermission }
-}
+import { DependencyList, useEffect, useMemo } from 'react'
+import { useMatches, useSearchParams, NavigateOptions, createBrowserRouter } from 'react-router-dom'
+import { assign, isArray, reduce, get, map, split, omit, cloneDeep, last, forEach } from 'lodash-es'
+import { stringify, parse } from 'qs'
+import { defineStore } from 'define-zustand'
+import { routeByIdType, routeType, editableRouteType } from './defineRouter.types'
+
+export default function defineRouter(router: ReturnType<typeof createBrowserRouter>) {
+    const useRouter = defineStore({
+        state: () => ({
+            routes: cloneDeep(router.routes) as routeType[]
+        }),
+        getter: {
+            routesById: state => {
+                return (function flat(routes: routeType[], parentRoute?: routeByIdType) {
+                    return reduce(
+                        routes,
+                        (result, { children, ...route }, i) => {
+                            const $route: routeByIdType = {
+                                ...route,
+                                pos: parentRoute?.pos ? `${parentRoute?.pos}-${i}` : `${i}`
+                            }
+                            if (parentRoute) {
+                                $route.path = `${
+                                    parentRoute.path === '/' ? '' : parentRoute.path
+                                }/${$route.path}`
+                            }
+                            result[$route.id] = $route
+                            if (isArray(children)) {
+                                assign(result, flat(children, $route))
+                            }
+                            return result
+                        },
+                        {} as Record<string, routeByIdType>
+                    )
+                })(state.routes)
+            }
+        },
+        actions: (getState, action) => {
+            function posToLodashPath(pos: string) {
+                if (pos) {
+                    return `[${split(pos, '-').join('].children[')}]`
+                }
+                return ''
+            }
+
+            function updateRoute(id: routeType['id'], updator: (route: editableRouteType) => void) {
+                const { routesById, routes } = getState()
+                const newRoutes = cloneDeep(routes)
+                const path = posToLodashPath(routesById[id].pos)
+                const route: routeType = get(newRoutes, path)
+                const newRoute = cloneDeep(omit(route, ['element', 'errorElement', 'children']))
+                updator(newRoute)
+                assign(route, newRoute)
+                action.setState({ routes: newRoutes })
+            }
+            function getRoute(id: routeType['id'], path?: string | string[]) {
+                const { routesById } = getState()
+                const route = routesById[id]
+                if (path) {
+                    return get(route, path)
+                }
+                return route
+            }
+
+            function genRouteUrl(id: routeType['id'], query?: Record<string, any>) {
+                const path = getRoute(id, 'path')
+                if (path) {
+                    const { origin } = window.location
+                    let url = origin + router.basename + path
+                    url += query ? `?${stringify(query)}` : ''
+                    return url
+                }
+                return void 0
+            }
+
+            function openRoute(id: routeType['id'], query?: Record<string, any>) {
+                const url = genRouteUrl(id, query)
+                if (url) {
+                    window.open(url)
+                }
+            }
+
+            function reloadRoute(id: routeType['id'], query?: Record<string, any>) {
+                const url = genRouteUrl(id, query)
+                if (url) {
+                    window.location.replace(url)
+                }
+            }
+
+            function navigate(
+                to: { id: routeType['id']; query?: Record<string, any> },
+                opts?: NavigateOptions
+            ) {
+                return router.navigate(
+                    {
+                        pathname: getRoute(to.id, 'path'),
+                        search: to.query ? stringify(to.query) : ''
+                    },
+                    opts
+                )
+            }
+
+            return {
+                navigate,
+                getRoute,
+                genRouteUrl,
+                openRoute,
+                reloadRoute,
+                updateRoute
+            }
+        }
+    })
+    function useQuery<Q>() {
+        const [params] = useSearchParams()
+        const query = parse(params.toString())
+
+        return query as Q
+    }
+
+    function useMatchRoutes(): routeType[] {
+        const matches = useMatches()
+        const getRoute = useRouter(state => state.getRoute)
+        return useMemo(() => map(matches, o => getRoute(o.id)), [matches])
+    }
+
+    /**
+     * @description 验证器返回false则无权限
+     */
+    function useRoutePermission(
+        config: {
+            redirectRouteId: string
+            validator: (currentRoute?: routeType) => boolean
+        },
+        deps: DependencyList
+    ) {
+        const matchRoutes = useMatchRoutes()
+        const currentRoute = last(matchRoutes)
+        const updateRoute = useRouter(state => state.updateRoute)
+        const navigate = useRouter(state => state.navigate)
+        const routesById = useRouter(state => state.routesById)
+
+        useEffect(() => {
+            forEach(routesById, route => {
+                updateRoute(route.id, route => {
+                    route.unauthorized = !config.validator(route)
+                })
+            })
+        }, deps)
+
+        useEffect(() => {
+            const result = config.validator(currentRoute)
+            if (!result && config.redirectRouteId) {
+                navigate({ id: config.redirectRouteId }, { replace: true })
+            }
+        }, [currentRoute?.id, ...deps])
+    }
+
+    return { useRouter, useQuery, useMatchRoutes, useRoutePermission }
+}

package/template/web-app/react-webpack/package.json

@@ -19,14 +19,14 @@
         "commit": "git add . && npm run cz"
     },
     "dependencies": {
-        "1k-types": "1.1.2",
+        "1k-types": "1.2.0",
         "axios": "1.6.7",
         "define-zustand": "3.1.0",
         "immer": "10.0.3",
         "lodash-es": "4.17.21",
         "qs": "6.11.2",
-        "react": "18.2.0",
-        "react-dom": "18.2.0",
+        "react": "18.3.1",
+        "react-dom": "18.3.1",
         "react-router-dom": "6.14.0",
         "react-use": "17.5.0",
         "tailwindcss": "3.4.1",

package/template/web-app/react-webpack/shared/hooks/defineRouter/defineRouter.types.ts

@@ -8,6 +8,9 @@ export type routeType = Omit<RouteObject, 'children' | 'id'> & {
         /** 只在当前路由才显示的小提示 */
         tip?: string
     }
+    /** 静态配置，便于回退 */
+    unauthorizedOrigin?: boolean
+    /** 动态使用，用于程序校验 */
     unauthorized?: boolean
     query?: () => Record<string, any>
     menu?: {

package/template/web-app/react-webpack/shared/hooks/defineRouter/deineRouter.tsx

@@ -1,160 +1,160 @@
-import { DependencyList, useEffect, useMemo } from 'react'
-import { useMatches, useSearchParams, NavigateOptions, createBrowserRouter } from 'react-router-dom'
-import { assign, isArray, reduce, get, map, split, omit, cloneDeep, last, forEach } from 'lodash-es'
-import { stringify, parse } from 'qs'
-import { defineStore } from 'define-zustand'
-import { routeByIdType, routeType, editableRouteType } from './defineRouter.types'
-
-export default function defineRouter(router: ReturnType<typeof createBrowserRouter>) {
-    const useRouter = defineStore({
-        state: () => ({
-            routes: cloneDeep(router.routes) as routeType[]
-        }),
-        getter: {
-            routesById: state => {
-                return (function flat(routes: routeType[], parentRoute?: routeByIdType) {
-                    return reduce(
-                        routes,
-                        (result, { children, ...route }, i) => {
-                            const $route: routeByIdType = {
-                                ...route,
-                                pos: parentRoute?.pos ? `${parentRoute?.pos}-${i}` : `${i}`
-                            }
-                            if (parentRoute) {
-                                $route.path = `${
-                                    parentRoute.path === '/' ? '' : parentRoute.path
-                                }/${$route.path}`
-                            }
-                            result[$route.id] = $route
-                            if (isArray(children)) {
-                                assign(result, flat(children, $route))
-                            }
-                            return result
-                        },
-                        {} as Record<string, routeByIdType>
-                    )
-                })(state.routes)
-            }
-        },
-        actions: (getState, action) => {
-            function posToLodashPath(pos: string) {
-                if (pos) {
-                    return `[${split(pos, '-').join('].children[')}]`
-                }
-                return ''
-            }
-
-            function updateRoute(id: routeType['id'], updator: (route: editableRouteType) => void) {
-                const { routesById, routes } = getState()
-                const newRoutes = cloneDeep(routes)
-                const path = posToLodashPath(routesById[id].pos)
-                const route: routeType = get(newRoutes, path)
-                const newRoute = cloneDeep(omit(route, ['element', 'errorElement', 'children']))
-                updator(newRoute)
-                assign(route, newRoute)
-                action.setState({ routes: newRoutes })
-            }
-            function getRoute(id: routeType['id'], path?: string | string[]) {
-                const { routesById } = getState()
-                const route = routesById[id]
-                if (path) {
-                    return get(route, path)
-                }
-                return route
-            }
-
-            function genRouteUrl(id: routeType['id'], query?: Record<string, any>) {
-                const path = getRoute(id, 'path')
-                if (path) {
-                    const { origin } = window.location
-                    let url = origin + router.basename + path
-                    url += query ? `?${stringify(query)}` : ''
-                    return url
-                }
-                return void 0
-            }
-
-            function openRoute(id: routeType['id'], query?: Record<string, any>) {
-                const url = genRouteUrl(id, query)
-                if (url) {
-                    window.open(url)
-                }
-            }
-
-            function reloadRoute(id: routeType['id'], query?: Record<string, any>) {
-                const url = genRouteUrl(id, query)
-                if (url) {
-                    window.location.replace(url)
-                }
-            }
-
-            function navigate(
-                to: { id: routeType['id']; query?: Record<string, any> },
-                opts?: NavigateOptions
-            ) {
-                return router.navigate(
-                    {
-                        pathname: getRoute(to.id, 'path'),
-                        search: to.query ? stringify(to.query) : ''
-                    },
-                    opts
-                )
-            }
-
-            return {
-                navigate,
-                getRoute,
-                genRouteUrl,
-                openRoute,
-                reloadRoute,
-                updateRoute
-            }
-        }
-    })
-    function useQuery<Q>() {
-        const [params] = useSearchParams()
-        const query = parse(params.toString())
-
-        return query as Q
-    }
-
-    function useMatchRoutes(): routeType[] {
-        const matches = useMatches()
-        const getRoute = useRouter(state => state.getRoute)
-        return useMemo(() => map(matches, o => getRoute(o.id)), [matches])
-    }
-
-    /**
-     * @description 验证器返回false则无权限
-     */
-    function useRoutePermission(
-        config: {
-            redirectRouteId: string
-            validator: (currentRoute?: routeType) => boolean
-        },
-        deps: DependencyList
-    ) {
-        const matchRoutes = useMatchRoutes()
-        const currentRoute = last(matchRoutes)
-        const updateRoute = useRouter(state => state.updateRoute)
-        const navigate = useRouter(state => state.navigate)
-        const routesById = useRouter(state => state.routesById)
-
-        useEffect(() => {
-            forEach(routesById, route => {
-                updateRoute(route.id, route => {
-                    route.unauthorized = !config.validator(route)
-                })
-            })
-        }, deps)
-
-        useEffect(() => {
-            const result = config.validator(currentRoute)
-            if (!result && config.redirectRouteId) {
-                navigate({ id: config.redirectRouteId }, { replace: true })
-            }
-        }, [currentRoute?.id, ...deps])
-    }
-
-    return { useRouter, useQuery, useMatchRoutes, useRoutePermission }
-}
+import { DependencyList, useEffect, useMemo } from 'react'
+import { useMatches, useSearchParams, NavigateOptions, createBrowserRouter } from 'react-router-dom'
+import { assign, isArray, reduce, get, map, split, omit, cloneDeep, last, forEach } from 'lodash-es'
+import { stringify, parse } from 'qs'
+import { defineStore } from 'define-zustand'
+import { routeByIdType, routeType, editableRouteType } from './defineRouter.types'
+
+export default function defineRouter(router: ReturnType<typeof createBrowserRouter>) {
+    const useRouter = defineStore({
+        state: () => ({
+            routes: cloneDeep(router.routes) as routeType[]
+        }),
+        getter: {
+            routesById: state => {
+                return (function flat(routes: routeType[], parentRoute?: routeByIdType) {
+                    return reduce(
+                        routes,
+                        (result, { children, ...route }, i) => {
+                            const $route: routeByIdType = {
+                                ...route,
+                                pos: parentRoute?.pos ? `${parentRoute?.pos}-${i}` : `${i}`
+                            }
+                            if (parentRoute) {
+                                $route.path = `${
+                                    parentRoute.path === '/' ? '' : parentRoute.path
+                                }/${$route.path}`
+                            }
+                            result[$route.id] = $route
+                            if (isArray(children)) {
+                                assign(result, flat(children, $route))
+                            }
+                            return result
+                        },
+                        {} as Record<string, routeByIdType>
+                    )
+                })(state.routes)
+            }
+        },
+        actions: (getState, action) => {
+            function posToLodashPath(pos: string) {
+                if (pos) {
+                    return `[${split(pos, '-').join('].children[')}]`
+                }
+                return ''
+            }
+
+            function updateRoute(id: routeType['id'], updator: (route: editableRouteType) => void) {
+                const { routesById, routes } = getState()
+                const newRoutes = cloneDeep(routes)
+                const path = posToLodashPath(routesById[id].pos)
+                const route: routeType = get(newRoutes, path)
+                const newRoute = cloneDeep(omit(route, ['element', 'errorElement', 'children']))
+                updator(newRoute)
+                assign(route, newRoute)
+                action.setState({ routes: newRoutes })
+            }
+            function getRoute(id: routeType['id'], path?: string | string[]) {
+                const { routesById } = getState()
+                const route = routesById[id]
+                if (path) {
+                    return get(route, path)
+                }
+                return route
+            }
+
+            function genRouteUrl(id: routeType['id'], query?: Record<string, any>) {
+                const path = getRoute(id, 'path')
+                if (path) {
+                    const { origin } = window.location
+                    let url = origin + router.basename + path
+                    url += query ? `?${stringify(query)}` : ''
+                    return url
+                }
+                return void 0
+            }
+
+            function openRoute(id: routeType['id'], query?: Record<string, any>) {
+                const url = genRouteUrl(id, query)
+                if (url) {
+                    window.open(url)
+                }
+            }
+
+            function reloadRoute(id: routeType['id'], query?: Record<string, any>) {
+                const url = genRouteUrl(id, query)
+                if (url) {
+                    window.location.replace(url)
+                }
+            }
+
+            function navigate(
+                to: { id: routeType['id']; query?: Record<string, any> },
+                opts?: NavigateOptions
+            ) {
+                return router.navigate(
+                    {
+                        pathname: getRoute(to.id, 'path'),
+                        search: to.query ? stringify(to.query) : ''
+                    },
+                    opts
+                )
+            }
+
+            return {
+                navigate,
+                getRoute,
+                genRouteUrl,
+                openRoute,
+                reloadRoute,
+                updateRoute
+            }
+        }
+    })
+    function useQuery<Q>() {
+        const [params] = useSearchParams()
+        const query = parse(params.toString())
+
+        return query as Q
+    }
+
+    function useMatchRoutes(): routeType[] {
+        const matches = useMatches()
+        const getRoute = useRouter(state => state.getRoute)
+        return useMemo(() => map(matches, o => getRoute(o.id)), [matches])
+    }
+
+    /**
+     * @description 验证器返回false则无权限
+     */
+    function useRoutePermission(
+        config: {
+            redirectRouteId: string
+            validator: (currentRoute?: routeType) => boolean
+        },
+        deps: DependencyList
+    ) {
+        const matchRoutes = useMatchRoutes()
+        const currentRoute = last(matchRoutes)
+        const updateRoute = useRouter(state => state.updateRoute)
+        const navigate = useRouter(state => state.navigate)
+        const routesById = useRouter(state => state.routesById)
+
+        useEffect(() => {
+            forEach(routesById, route => {
+                updateRoute(route.id, route => {
+                    route.unauthorized = !config.validator(route)
+                })
+            })
+        }, deps)
+
+        useEffect(() => {
+            const result = config.validator(currentRoute)
+            if (!result && config.redirectRouteId) {
+                navigate({ id: config.redirectRouteId }, { replace: true })
+            }
+        }, [currentRoute?.id, ...deps])
+    }
+
+    return { useRouter, useQuery, useMatchRoutes, useRoutePermission }
+}

package/template/web-extension/package.json

@@ -27,7 +27,7 @@
         "zustand": "4.4.1"
     },
     "devDependencies": {
-        "1k-types": "1.1.2",
+        "1k-types": "1.2.0",
         "@commitlint/cli": "17.6.1",
         "@commitlint/config-conventional": "17.6.1",
         "@commitlint/cz-commitlint": "17.5.0",

package/template/web-extension/shared/service/tools/base.ts

@@ -1,3 +1,4 @@
+import { includes } from 'lodash-es'
 import { httpBodyType } from '../types'
 
 export class FetchError extends Error {
@@ -14,15 +15,24 @@ export async function pickRequestBody<Body = httpBodyType>(
     req: Request
 ): Promise<Body | undefined> {
     let reqBody = void 0
-    try {
-        reqBody = await req.clone().json()
-    } catch {
-        /* empty */
+    if (!includes(['GET', 'HEAD'], req.method)) {
+        const dataTypes = ['json', 'blob', 'text', 'formData'] as const
+        for (let i = 0; i < dataTypes.length; i++) {
+            try {
+                const dataType = dataTypes[i]
+                reqBody = await req.clone()[dataType]()
+            } catch {
+                /* empty */
+            }
+            if (reqBody) {
+                break
+            }
+        }
     }
     return reqBody
 }
 
-export async function pickReponseBody<Body = any>(res: Response): Promise<Body | undefined> {
+export async function pickResponseBody<Body = any>(res: Response): Promise<Body | undefined> {
     let body = void 0
     try {
         body = await res.clone().json()

package/template/web-extension/shared/service/tools/createRequestActions.ts

@@ -1,5 +1,5 @@
-import { KyInstance, Options } from 'ky'
-import { Input } from 'ky/distribution/types/options'
+import { KyInstance } from 'ky'
+import { Input, HttpMethod } from 'ky/distribution/types/options'
 import { includes, isFunction, isString, omit } from 'lodash-es'
 import { stringify } from 'qs'
 import { Nullable } from '1k-types'
@@ -12,7 +12,7 @@ export function createRequestActions(
     request: KyInstance,
     hooks: serviceHooksType
 ) {
-    function creator(method: Required<Options>['method']) {
+    function creator(method: HttpMethod) {
         return async function <DATA = any>(url: Input, option?: requestOptionsType): Promise<DATA> {
             const globalPrefix = isFunction(prefixUrl) ? await prefixUrl() : prefixUrl
             const $prefix = isFunction(option?.prefixUrl)
@@ -29,7 +29,7 @@ export function createRequestActions(
                 hooks: createKyRequestHooks(newHooks)
             }
             try {
-                const res = request[method](url, newOption)
+                const res = request[method](url, newOption) as any
                 if (option?.responseType === 'response') {
                     return await res
                 }

package/template/web-extension/shared/service/tools/createService.ts

@@ -1,5 +1,6 @@
 import ky from 'ky'
-import { assign, isArray, isObject } from 'lodash-es'
+import { assign, isPlainObject } from 'lodash-es'
+import { AnyObject } from '1k-types'
 import { configType } from '../types'
 import { createRequestActions } from './createRequestActions'
 import { createServiceHooks } from './hooks'
@@ -27,11 +28,15 @@ export function createService(config: configType) {
     // init
     // ------------------------------------------------------------------------
     addHooks('beforeRequest', async req => {
-        const { searchParams, body } = req
-        req.searchParams = { ...globalSearchParams, ...searchParams }
+        const body = isPlainObject(req.body) ? (req.body as AnyObject) : void 0
+        req.searchParams = {
+            ...globalSearchParams
+        }
 
-        if (!isArray(body) && isObject(body)) {
-            req.body = { ...globalParams, ...body }
+        if (isPlainObject(body)) {
+            req.body = {
+                ...globalParams
+            }
         }
     })
 

package/template/web-extension/shared/service/tools/hooks.ts

@@ -1,67 +1,73 @@
-import { Hooks } from 'ky'
-import { omit } from 'lodash-es'
-import { stringify, parse } from 'qs'
-import { ArrayValues } from '1k-types'
-import { serviceHooksType } from '../types'
-import { pickRequestBody } from './base'
-
-export function createServiceHooks(hooks?: Partial<serviceHooksType>) {
-    const serviceHooks: serviceHooksType = {
-        httpError: [],
-        beforeRequest: [],
-        afterResponse: [],
-        ...(hooks || {})
-    }
-
-    function addHooks<K extends keyof serviceHooksType>(
-        key: K,
-        callback: ArrayValues<serviceHooksType[K]>
-    ) {
-        serviceHooks[key].push(callback as any)
-    }
-
-    return {
-        serviceHooks,
-        addHooks
-    }
-}
-
-export function createKyRequestHooks(serviceHooks: serviceHooksType): Hooks {
-    async function forEachHooks<K extends keyof serviceHooksType>(
-        name: K,
-        arg: Parameters<ArrayValues<serviceHooksType[K]>>[0]
-    ) {
-        for (let i = 0; i < serviceHooks[name].length; i++) {
-            const fn = serviceHooks[name][i]
-            await fn(arg as never)
-        }
-    }
-    return {
-        beforeRequest: [
-            async req => {
-                // eslint-disable-next-line prefer-const
-                let [url, searchParams] = req.url.split('?')
-                const reqBody = await pickRequestBody(req)
-                const parsedSearchParams = parse(searchParams)
-                const reqConfig = {
-                    searchParams: parsedSearchParams,
-                    body: reqBody,
-                    headers: req.headers,
-                    method: req.method
-                }
-                await forEachHooks('beforeRequest', reqConfig)
-                url = url + stringify(reqConfig.searchParams, { addQueryPrefix: true })
-                return new Request(url, {
-                    ...omit(req, 'url'),
-                    headers: reqConfig.headers,
-                    body: reqBody ? JSON.stringify(reqConfig.body) : void 0
-                })
-            }
-        ],
-        afterResponse: [
-            async (request, options, response) => {
-                await forEachHooks('afterResponse', { request, options, response })
-            }
-        ]
-    }
-}
+import { Hooks } from 'ky'
+import { isNumber, isString, omit, some, isPlainObject, isArray } from 'lodash-es'
+import { stringify, parse } from 'qs'
+import { ArrayValues } from '1k-types'
+import { serviceHooksType } from '../types'
+import { pickRequestBody } from './base'
+
+export function createServiceHooks(hooks?: Partial<serviceHooksType>) {
+    const serviceHooks: serviceHooksType = {
+        httpError: [],
+        beforeRequest: [],
+        afterResponse: [],
+        ...(hooks || {})
+    }
+
+    function addHooks<K extends keyof serviceHooksType>(
+        key: K,
+        callback: ArrayValues<serviceHooksType[K]>
+    ) {
+        serviceHooks[key].push(callback as any)
+    }
+
+    return {
+        serviceHooks,
+        addHooks
+    }
+}
+
+export function createKyRequestHooks(serviceHooks: serviceHooksType): Hooks {
+    async function forEachHooks<K extends keyof serviceHooksType>(
+        name: K,
+        arg: Parameters<ArrayValues<serviceHooksType[K]>>[0]
+    ) {
+        for (let i = 0; i < serviceHooks[name].length; i++) {
+            const fn = serviceHooks[name][i]
+            await fn(arg as never)
+        }
+    }
+    return {
+        beforeRequest: [
+            async req => {
+                // eslint-disable-next-line prefer-const
+                let [url, searchParams] = req.url.split('?')
+                const reqBody = await pickRequestBody(req)
+                const parsedSearchParams = parse(searchParams)
+                const reqConfig = {
+                    searchParams: parsedSearchParams,
+                    body: reqBody,
+                    headers: req.headers,
+                    method: req.method
+                }
+                await forEachHooks('beforeRequest', reqConfig)
+                url = url + stringify(reqConfig.searchParams, { addQueryPrefix: true })
+                const isStringify = some([isNumber, isString, isPlainObject, isArray], fn => {
+                    return fn(reqConfig.body)
+                })
+                if (isStringify) {
+                    reqConfig.body = JSON.stringify(reqConfig.body)
+                }
+                return new Request(url, {
+                    ...omit(req, 'url'),
+                    headers: reqConfig.headers,
+                    body: (reqConfig.body ? reqConfig.body : void 0) as BodyInit
+                })
+            }
+        ],
+        afterResponse: [
+            async (request, options, response) => {
+                await forEachHooks('afterResponse', { request, options, response })
+            }
+        ]
+    }
+}

package/template/web-extension/shared/service/types.ts

@@ -39,8 +39,4 @@ export interface configType extends Pick<requestOptionsType, 'prefixUrl' | 'head
     globalParams?: Record<string, any>
     globalSearchParams?: Record<string, any>
     hooks?: Partial<serviceHooksType>
-    /**
-     * @default true
-     * */
-    isClearEmptyData?: boolean
 }