create-packer 1.46.3 → 1.47.0

package/template/electron-react/renderer/shared/components/index.ts

@@ -1 +1 @@
-export * as componentInstance from './componentInstance'
+export * as componentInstance from './componentInstance'

package/template/electron-react/renderer/shared/hooks/defineRouter/defineRouter.types.ts

@@ -1,33 +1,33 @@
-import { FunctionComponent, ReactNode } from 'react'
-import { RouteObject } from 'react-router'
-
-export type routeType = Omit<RouteObject, 'children' | 'id'> & {
-    id: string
-    meta?: {
-        title?: string
-        /** 只在当前路由才显示的小提示 */
-        tip?: string
-    }
-    /** 静态配置，便于回退 */
-    unauthorizedOrigin?: boolean
-    /** 动态使用，用于程序校验 */
-    unauthorized?: boolean
-    query?: () => Record<string, any>
-    menu?: {
-        hidden?: boolean
-        icon?: FunctionComponent
-        label?: ReactNode
-    }
-    children?: routeType[]
-}
-
-export type editableRouteType = Omit<routeType, 'element' | 'errorElement' | 'children'>
-
-export interface routerFactoryArgType {
-    basename: string
-    routes: routeType[]
-}
-
-export type routeByIdType = Omit<routeType, 'children'> & {
-    pos: string
-}
+import { FunctionComponent, ReactNode } from 'react'
+import { RouteObject } from 'react-router'
+
+export type routeType = Omit<RouteObject, 'children' | 'id'> & {
+    id: string
+    meta?: {
+        title?: string
+        /** 只在当前路由才显示的小提示 */
+        tip?: string
+    }
+    /** 静态配置，便于回退 */
+    unauthorizedOrigin?: boolean
+    /** 动态使用，用于程序校验 */
+    unauthorized?: boolean
+    query?: () => Record<string, any>
+    menu?: {
+        hidden?: boolean
+        icon?: FunctionComponent
+        label?: ReactNode
+    }
+    children?: routeType[]
+}
+
+export type editableRouteType = Omit<routeType, 'element' | 'errorElement' | 'children'>
+
+export interface routerFactoryArgType {
+    basename: string
+    routes: routeType[]
+}
+
+export type routeByIdType = Omit<routeType, 'children'> & {
+    pos: string
+}

package/template/electron-react/renderer/shared/hooks/defineRouter/deineRouter.tsx

@@ -1,161 +1,161 @@
-import { DependencyList, useEffect, useMemo } from 'react'
-import { useMatches, useSearchParams, NavigateOptions, createBrowserRouter } from 'react-router'
-import { omit, cloneDeep, last } from 'es-toolkit'
-import { assign, isArray, reduce, get, map, split, forEach } from 'es-toolkit/compat'
-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[]
-        }),
-        getters: {
-            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: (setState, getState) => {
-            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)
-                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'
+import { omit, cloneDeep, last } from 'es-toolkit'
+import { assign, isArray, reduce, get, map, split, forEach } from 'es-toolkit/compat'
+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[]
+        }),
+        getters: {
+            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: (setState, getState) => {
+            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)
+                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/electron-react/renderer/shared/hooks/defineRouter/index.ts

@@ -1,2 +1,2 @@
-export { default as defineRouter } from './deineRouter'
-export * from './defineRouter.types'
+export { default as defineRouter } from './deineRouter'
+export * from './defineRouter.types'

package/template/electron-react/renderer/shared/hooks/index.ts

@@ -1,6 +1,6 @@
-export { default as useLoadingAction } from './useLoadingAction'
-export { default as useInterval } from './useInterval'
-export { default as useVisible } from './useVisible'
-export { default as useLowPriorityState } from './useLowPriorityState'
-export * from './useSyncState'
-export * from './defineRouter'
+export { default as useLoadingAction } from './useLoadingAction'
+export { default as useInterval } from './useInterval'
+export { default as useVisible } from './useVisible'
+export { default as useLowPriorityState } from './useLowPriorityState'
+export * from './useSyncState'
+export * from './defineRouter'

package/template/electron-react/renderer/shared/hooks/useInterval.ts

@@ -1,26 +1,26 @@
-import { useState } from 'react'
-import { useInterval as useRUInterval } from 'react-use'
-
-interface actionsType {
-    start: () => void
-    stop: () => void
-}
-export default function useInterval(
-    cb: (actions: actionsType) => Promise<void> | void,
-    delay: number
-): actionsType {
-    const [startInterval, setStartInterval] = useState(false)
-    const start: actionsType['start'] = () => {
-        setStartInterval(true)
-    }
-    const stop: actionsType['stop'] = () => {
-        setStartInterval(false)
-    }
-    useRUInterval(
-        async () => {
-            cb({ start, stop })
-        },
-        startInterval ? delay : null
-    )
-    return { start, stop }
-}
+import { useState } from 'react'
+import { useInterval as useRUInterval } from 'react-use'
+
+interface actionsType {
+    start: () => void
+    stop: () => void
+}
+export default function useInterval(
+    cb: (actions: actionsType) => Promise<void> | void,
+    delay: number
+): actionsType {
+    const [startInterval, setStartInterval] = useState(false)
+    const start: actionsType['start'] = () => {
+        setStartInterval(true)
+    }
+    const stop: actionsType['stop'] = () => {
+        setStartInterval(false)
+    }
+    useRUInterval(
+        async () => {
+            cb({ start, stop })
+        },
+        startInterval ? delay : null
+    )
+    return { start, stop }
+}

package/template/electron-react/renderer/shared/hooks/useLoadingAction.ts

@@ -1,27 +1,27 @@
-import { useCallback, useState, DependencyList, useRef } from 'react'
-
-export default function useLoadingAction<C extends (...arg: any) => Promise<any> | any>(
-    callback: C,
-    deps: DependencyList,
-    debounce = true
-) {
-    const [loading, setLoading] = useState(false)
-    const loadingSync = useRef(loading)
-    function $setLoading(loading: boolean) {
-        setLoading(loading)
-        loadingSync.current = loading
-    }
-    const action = useCallback(async (...arg: any) => {
-        if (debounce && loadingSync.current) {
-            return
-        }
-        try {
-            $setLoading(true)
-            return await callback(...arg)
-        } finally {
-            $setLoading(false)
-        }
-    }, deps) as C
-
-    return [loading, action] as const
-}
+import { useCallback, useState, DependencyList, useRef } from 'react'
+
+export default function useLoadingAction<C extends (...arg: any) => Promise<any> | any>(
+    callback: C,
+    deps: DependencyList,
+    debounce = true
+) {
+    const [loading, setLoading] = useState(false)
+    const loadingSync = useRef(loading)
+    function $setLoading(loading: boolean) {
+        setLoading(loading)
+        loadingSync.current = loading
+    }
+    const action = useCallback(async (...arg: any) => {
+        if (debounce && loadingSync.current) {
+            return
+        }
+        try {
+            $setLoading(true)
+            return await callback(...arg)
+        } finally {
+            $setLoading(false)
+        }
+    }, deps) as C
+
+    return [loading, action] as const
+}

package/template/electron-react/renderer/shared/hooks/useLowPriorityState.ts

@@ -1,26 +1,26 @@
-import { useEffect, useState, useTransition, DependencyList } from 'react'
-
-/**
- *
- * @param callback
- * @param watches If set, it is autorun callback
- * @returns
- */
-export default function useLowPriorityState<V>(callback: () => V, watches?: DependencyList) {
-    const [value, setValue] = useState<V>(callback)
-    const [loading, startTransition] = useTransition()
-
-    function startLoad() {
-        startTransition(() => {
-            setValue(callback())
-        })
-    }
-
-    useEffect(() => {
-        if (watches) {
-            startLoad()
-        }
-    }, watches)
-
-    return [value, { loading, startLoad }] as const
-}
+import { useEffect, useState, useTransition, DependencyList } from 'react'
+
+/**
+ *
+ * @param callback
+ * @param watches If set, it is autorun callback
+ * @returns
+ */
+export default function useLowPriorityState<V>(callback: () => V, watches?: DependencyList) {
+    const [value, setValue] = useState<V>(callback)
+    const [loading, startTransition] = useTransition()
+
+    function startLoad() {
+        startTransition(() => {
+            setValue(callback())
+        })
+    }
+
+    useEffect(() => {
+        if (watches) {
+            startLoad()
+        }
+    }, watches)
+
+    return [value, { loading, startLoad }] as const
+}

package/template/electron-react/renderer/shared/hooks/useSyncState.ts

@@ -1,15 +1,15 @@
-import { useRef, useState, Dispatch, SetStateAction } from 'react'
-import { isFunction } from 'es-toolkit'
-
-export function useSyncState<S>(initialState: S | (() => S)) {
-    const [state, setState] = useState(initialState)
-    const syncState = useRef<S>(state)
-
-    const $setState: Dispatch<SetStateAction<S>> = newState => {
-        const $newState = (isFunction(newState) ? newState(state) : newState) as S
-        setState($newState)
-        syncState.current = $newState
-    }
-
-    return [syncState, state, $setState] as const
-}
+import { useRef, useState, Dispatch, SetStateAction } from 'react'
+import { isFunction } from 'es-toolkit'
+
+export function useSyncState<S>(initialState: S | (() => S)) {
+    const [state, setState] = useState(initialState)
+    const syncState = useRef<S>(state)
+
+    const $setState: Dispatch<SetStateAction<S>> = newState => {
+        const $newState = (isFunction(newState) ? newState(state) : newState) as S
+        setState($newState)
+        syncState.current = $newState
+    }
+
+    return [syncState, state, $setState] as const
+}

package/template/electron-react/renderer/shared/hooks/useVisible.ts

@@ -1,27 +1,27 @@
-import { useState } from 'react'
-import { isFunction } from 'es-toolkit'
-
-export interface useVisibleConfigType {
-    defaultVisible?: boolean
-    onBeforeShow?: () => Promise<boolean | void>
-    onBeforeHide?: () => Promise<boolean | void>
-}
-export default function useVisible(config?: useVisibleConfigType) {
-    const [visible, setVisible] = useState(config?.defaultVisible ?? false)
-    const onShow = async () => {
-        let isShow: boolean | void = true
-        if (isFunction(config?.onBeforeShow)) {
-            isShow = await config?.onBeforeShow?.()
-        }
-        setVisible(isShow !== false)
-    }
-    const onClose = async () => {
-        let isHide: boolean | void = true
-        if (isFunction(config?.onBeforeHide)) {
-            isHide = await config?.onBeforeHide?.()
-        }
-        setVisible(isHide === false)
-    }
-
-    return { visible, onShow, onClose }
-}
+import { useState } from 'react'
+import { isFunction } from 'es-toolkit'
+
+export interface useVisibleConfigType {
+    defaultVisible?: boolean
+    onBeforeShow?: () => Promise<boolean | void>
+    onBeforeHide?: () => Promise<boolean | void>
+}
+export default function useVisible(config?: useVisibleConfigType) {
+    const [visible, setVisible] = useState(config?.defaultVisible ?? false)
+    const onShow = async () => {
+        let isShow: boolean | void = true
+        if (isFunction(config?.onBeforeShow)) {
+            isShow = await config?.onBeforeShow?.()
+        }
+        setVisible(isShow !== false)
+    }
+    const onClose = async () => {
+        let isHide: boolean | void = true
+        if (isFunction(config?.onBeforeHide)) {
+            isHide = await config?.onBeforeHide?.()
+        }
+        setVisible(isHide === false)
+    }
+
+    return { visible, onShow, onClose }
+}