create-packer 1.46.4 → 1.47.0

package/template/electron-react/postcss.config.cjs

@@ -1,8 +1,8 @@
-module.exports = {
-    plugins: {
-        'postcss-import': {},
-        'postcss-nesting': {},
-        autoprefixer: {},
-        ...(process.env.NODE_ENV === 'production' ? { cssnano: {} } : {})
-    }
-}
+module.exports = {
+    plugins: {
+        'postcss-import': {},
+        'postcss-nesting': {},
+        autoprefixer: {},
+        ...(process.env.NODE_ENV === 'production' ? { cssnano: {} } : {})
+    }
+}

package/template/electron-react/renderer/domain/components/app-context.tsx

@@ -1,31 +1,31 @@
-import { FunctionComponent, ReactNode } from 'react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { Global, ThemeProvider } from '@emotion/react'
-import { request } from '@/renderer/shared/service'
-import { globalCss, theme } from '@/renderer/shared/styles'
-
-const queryClient = new QueryClient({
-    defaultOptions: {
-        queries: {
-            queryFn: async ({ queryKey }) => {
-                const { data } = await request.get(queryKey[0] as string, {
-                    params: queryKey[1]
-                })
-                return data
-            }
-        }
-    }
-})
-export interface propsType {
-    children: ReactNode
-}
-export const Root: FunctionComponent<propsType> = props => {
-    return (
-        <ThemeProvider theme={theme}>
-            <QueryClientProvider client={queryClient}>
-                <Global styles={globalCss} />
-                {props.children}
-            </QueryClientProvider>
-        </ThemeProvider>
-    )
-}
+import { FunctionComponent, ReactNode } from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { Global, ThemeProvider } from '@emotion/react'
+import { request } from '@/renderer/shared/service'
+import { globalCss, theme } from '@/renderer/shared/styles'
+
+const queryClient = new QueryClient({
+    defaultOptions: {
+        queries: {
+            queryFn: async ({ queryKey }) => {
+                const { data } = await request.get(queryKey[0] as string, {
+                    params: queryKey[1]
+                })
+                return data
+            }
+        }
+    }
+})
+export interface propsType {
+    children: ReactNode
+}
+export const Root: FunctionComponent<propsType> = props => {
+    return (
+        <ThemeProvider theme={theme}>
+            <QueryClientProvider client={queryClient}>
+                <Global styles={globalCss} />
+                {props.children}
+            </QueryClientProvider>
+        </ThemeProvider>
+    )
+}

package/template/electron-react/renderer/domain/components/app.tsx

@@ -1,25 +1,25 @@
-import { useLayoutEffect, Suspense } from 'react'
-import { RouterProvider } from 'react-router/dom'
-import { request } from '@/renderer/shared/service'
-import { routerInstance } from '@/renderer/domain/router'
-import * as AppContext from './app-context'
-
-export const Root = () => {
-    useLayoutEffect(() => {
-        request.interceptors.response.use(
-            res => res,
-            error => {
-                console.log(error)
-                return Promise.reject(error)
-            }
-        )
-    }, [])
-
-    return (
-        <AppContext.Root>
-            <Suspense fallback={<>loading...</>}>
-                <RouterProvider router={routerInstance} />
-            </Suspense>
-        </AppContext.Root>
-    )
-}
+import { useLayoutEffect, Suspense } from 'react'
+import { RouterProvider } from 'react-router/dom'
+import { request } from '@/renderer/shared/service'
+import { routerInstance } from '@/renderer/domain/router'
+import * as AppContext from './app-context'
+
+export const Root = () => {
+    useLayoutEffect(() => {
+        request.interceptors.response.use(
+            res => res,
+            error => {
+                console.log(error)
+                return Promise.reject(error)
+            }
+        )
+    }, [])
+
+    return (
+        <AppContext.Root>
+            <Suspense fallback={<>loading...</>}>
+                <RouterProvider router={routerInstance} />
+            </Suspense>
+        </AppContext.Root>
+    )
+}

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

@@ -1 +1 @@
-export * as App from './app'
+export * as App from './app'

package/template/electron-react/renderer/domain/models/app.ts

@@ -1,7 +1,7 @@
-import { defineStore } from 'define-zustand'
-
-export const useApp = defineStore({
-    state: () => ({}),
-    getters: {},
-    actions: () => ({})
-})
+import { defineStore } from 'define-zustand'
+
+export const useApp = defineStore({
+    state: () => ({}),
+    getters: {},
+    actions: () => ({})
+})

package/template/electron-react/renderer/domain/router/components/index.ts

@@ -1,2 +1,2 @@
-export * as SubRouteOutlet from './sub-route-outlet'
-export * as RouteLayout from './route-layout'
+export * as SubRouteOutlet from './sub-route-outlet'
+export * as RouteLayout from './route-layout'

package/template/electron-react/renderer/domain/router/components/route-layout.tsx

@@ -1,19 +1,19 @@
-import { FunctionComponent } from 'react'
-import { Outlet } from 'react-router'
-import { last } from 'es-toolkit'
-import { routeType, useMatchRoutes } from '@/renderer/domain/router'
-
-export interface propsType {
-    Index: FunctionComponent
-    rootId: routeType['id']
-}
-
-export const Root: FunctionComponent<propsType> = ({ Index, rootId }) => {
-    const matchRoutes = useMatchRoutes()
-
-    if (last(matchRoutes)?.id === rootId) {
-        return <Index />
-    }
-
-    return <Outlet />
-}
+import { FunctionComponent } from 'react'
+import { Outlet } from 'react-router'
+import { last } from 'es-toolkit'
+import { routeType, useMatchRoutes } from '@/renderer/domain/router'
+
+export interface propsType {
+    Index: FunctionComponent
+    rootId: routeType['id']
+}
+
+export const Root: FunctionComponent<propsType> = ({ Index, rootId }) => {
+    const matchRoutes = useMatchRoutes()
+
+    if (last(matchRoutes)?.id === rootId) {
+        return <Index />
+    }
+
+    return <Outlet />
+}

package/template/electron-react/renderer/domain/router/components/sub-route-outlet.tsx

@@ -1,22 +1,22 @@
-import { FunctionComponent } from 'react'
-import { Outlet } from 'react-router'
-import { useMount } from 'react-use'
-import { last } from 'es-toolkit'
-import { useMatchRoutes, useRouter, routeType } from '@/renderer/domain/router'
-
-export interface propsType {
-    rootId: routeType['id']
-    homeId: routeType['id']
-}
-export const Root: FunctionComponent<propsType> = props => {
-    const matchRoutes = useMatchRoutes()
-    const navigate = useRouter(state => state.navigate)
-
-    useMount(() => {
-        if (last(matchRoutes)?.id === props.rootId) {
-            navigate({ id: props.homeId })
-        }
-    })
-
-    return <Outlet />
-}
+import { FunctionComponent } from 'react'
+import { Outlet } from 'react-router'
+import { useMount } from 'react-use'
+import { last } from 'es-toolkit'
+import { useMatchRoutes, useRouter, routeType } from '@/renderer/domain/router'
+
+export interface propsType {
+    rootId: routeType['id']
+    homeId: routeType['id']
+}
+export const Root: FunctionComponent<propsType> = props => {
+    const matchRoutes = useMatchRoutes()
+    const navigate = useRouter(state => state.navigate)
+
+    useMount(() => {
+        if (last(matchRoutes)?.id === props.rootId) {
+            navigate({ id: props.homeId })
+        }
+    })
+
+    return <Outlet />
+}

package/template/electron-react/renderer/domain/router/home/ids.ts

@@ -1,3 +1,3 @@
-export default {
-    home: 'home'
-}
+export default {
+    home: 'home'
+}

package/template/electron-react/renderer/domain/router/home/index.ts

@@ -1,2 +1,2 @@
-export { default as routes } from './routes'
-export { default as ids } from './ids'
+export { default as routes } from './routes'
+export { default as ids } from './ids'

package/template/electron-react/renderer/domain/router/home/routes.tsx

@@ -1,13 +1,13 @@
-import { lazy } from 'react'
-import { type routeType } from '../router.types'
-import ids from './ids'
-
-const routes: routeType[] = [
-    {
-        path: 'home',
-        id: ids.home,
-        Component: lazy(() => import('@/renderer/pages/home'))
-    }
-]
-
-export default routes
+import { lazy } from 'react'
+import { type routeType } from '../router.types'
+import ids from './ids'
+
+const routes: routeType[] = [
+    {
+        path: 'home',
+        id: ids.home,
+        Component: lazy(() => import('@/renderer/pages/home'))
+    }
+]
+
+export default routes

package/template/electron-react/renderer/domain/router/ids.ts

@@ -1,6 +1,6 @@
-import * as home from './home'
-export default {
-    root: 'root',
-    notFound: 'notFound',
-    ...home.ids
-}
+import * as home from './home'
+export default {
+    root: 'root',
+    notFound: 'notFound',
+    ...home.ids
+}

package/template/electron-react/renderer/domain/router/index.ts

@@ -1,4 +1,4 @@
-export { default as routerIds } from './ids'
-export * from './router'
-export * from './router.types'
-export * from './components'
+export { default as routerIds } from './ids'
+export * from './router'
+export * from './router.types'
+export * from './components'

package/template/electron-react/renderer/domain/router/router.tsx

@@ -1,28 +1,28 @@
-import { lazy } from 'react'
-import { createBrowserRouter } from 'react-router'
-import { defineRouter, routeType } from '@/renderer/shared/hooks'
-import ids from './ids'
-import * as home from './home'
-
-const routes: routeType[] = [
-    {
-        path: '/',
-        id: ids.root,
-        Component: lazy(() => import('@/renderer/pages')),
-        children: [
-            ...home.routes,
-            {
-                path: '*',
-                id: ids.notFound,
-                Component: lazy(() => import('@/renderer/pages/not-found'))
-            }
-        ]
-    }
-]
-
-export const routerInstance = createBrowserRouter(routes as never, {
-    basename: import.meta.env.PUBLIC_BASE_URL
-})
-
-export const { useMatchRoutes, useQuery, useRouter, useRoutePermission } =
-    defineRouter(routerInstance)
+import { lazy } from 'react'
+import { createBrowserRouter } from 'react-router'
+import { defineRouter, routeType } from '@/renderer/shared/hooks'
+import ids from './ids'
+import * as home from './home'
+
+const routes: routeType[] = [
+    {
+        path: '/',
+        id: ids.root,
+        Component: lazy(() => import('@/renderer/pages')),
+        children: [
+            ...home.routes,
+            {
+                path: '*',
+                id: ids.notFound,
+                Component: lazy(() => import('@/renderer/pages/not-found'))
+            }
+        ]
+    }
+]
+
+export const routerInstance = createBrowserRouter(routes as never, {
+    basename: import.meta.env.PUBLIC_BASE_URL
+})
+
+export const { useMatchRoutes, useQuery, useRouter, useRoutePermission } =
+    defineRouter(routerInstance)

package/template/electron-react/renderer/domain/router/router.types.ts

@@ -1,3 +1,3 @@
-import { routeType as $routeType } from '@/renderer/shared/hooks'
-
-export type routeType = $routeType
+import { routeType as $routeType } from '@/renderer/shared/hooks'
+
+export type routeType = $routeType

package/template/electron-react/renderer/main.tsx

@@ -1,4 +1,4 @@
-import { createRoot } from 'react-dom/client'
-import { App } from '@/renderer/domain/components'
-
-createRoot(document.getElementById('root') as HTMLElement).render(<App.Root />)
+import { createRoot } from 'react-dom/client'
+import { App } from '@/renderer/domain/components'
+
+createRoot(document.getElementById('root') as HTMLElement).render(<App.Root />)

package/template/electron-react/renderer/pages/home/index.ts

@@ -1 +1 @@
-export { default } from './view'
+export { default } from './view'

package/template/electron-react/renderer/pages/index.tsx

@@ -1,18 +1,18 @@
-import { useEffect } from 'react'
-import { Outlet, useLocation } from 'react-router'
-import { useRouter, routerIds } from '@/renderer/domain/router'
-
-const Layout = () => {
-    const location = useLocation()
-    const navigate = useRouter(state => state.navigate)
-
-    useEffect(() => {
-        if (location.pathname === '/') {
-            navigate({ id: routerIds.home })
-        }
-    }, [location])
-
-    return <Outlet />
-}
-
-export default Layout
+import { useEffect } from 'react'
+import { Outlet, useLocation } from 'react-router'
+import { useRouter, routerIds } from '@/renderer/domain/router'
+
+const Layout = () => {
+    const location = useLocation()
+    const navigate = useRouter(state => state.navigate)
+
+    useEffect(() => {
+        if (location.pathname === '/') {
+            navigate({ id: routerIds.home })
+        }
+    }, [location])
+
+    return <Outlet />
+}
+
+export default Layout

package/template/electron-react/renderer/pages/not-found.tsx

@@ -1,3 +1,3 @@
-export default function NotFound() {
-    return <div>404</div>
-}
+export default function NotFound() {
+    return <div>404</div>
+}

package/template/electron-react/renderer/scripts/createChunks.ts

@@ -1,26 +1,26 @@
-import { SplitChunks } from '@rsbuild/core'
-
-export function createChunks(
-    chunks: Array<{ name: string; libs: string[] | RegExp; priority?: number }>
-) {
-    const result: Exclude<SplitChunks, false>['cacheGroups'] = {
-        vendors: {
-            test: /[\\/]node_modules[\\/]/,
-            chunks: 'all',
-            name: 'vendors',
-            priority: -1
-        }
-    }
-    chunks.forEach(({ name, libs, priority }) => {
-        result[name] = {
-            test: Array.isArray(libs)
-                ? new RegExp(`[\\\\/]node_modules[\\\\/](${libs.join('|')})[\\\\/]`)
-                : libs,
-            chunks: 'all',
-            name,
-            priority
-        }
-        return result
-    })
-    return result
-}
+import { SplitChunks } from '@rsbuild/core'
+
+export function createChunks(
+    chunks: Array<{ name: string; libs: string[] | RegExp; priority?: number }>
+) {
+    const result: Exclude<SplitChunks, false>['cacheGroups'] = {
+        vendors: {
+            test: /[\\/]node_modules[\\/]/,
+            chunks: 'all',
+            name: 'vendors',
+            priority: -1
+        }
+    }
+    chunks.forEach(({ name, libs, priority }) => {
+        result[name] = {
+            test: Array.isArray(libs)
+                ? new RegExp(`[\\\\/]node_modules[\\\\/](${libs.join('|')})[\\\\/]`)
+                : libs,
+            chunks: 'all',
+            name,
+            priority
+        }
+        return result
+    })
+    return result
+}

package/template/electron-react/renderer/scripts/index.ts

@@ -1 +1 @@
-export * from './createChunks'
+export * from './createChunks'

package/template/electron-react/renderer/shared/components/componentInstance.tsx

@@ -1,80 +1,80 @@
-import {
-    forwardRef,
-    ForwardRefExoticComponent,
-    FunctionComponent,
-    PropsWithChildren,
-    PropsWithoutRef,
-    RefAttributes,
-    useImperativeHandle,
-    useRef,
-    useState
-} from 'react'
-import { createRoot } from 'react-dom/client'
-
-const instanceMap: Record<string, { pending: Promise<any>; instance: any }> = {}
-
-export interface refsType<P> {
-    $setProps: (newProps: P) => void
-    $updateProps: (newProps: Partial<P>) => void
-}
-
-export function create(Context?: FunctionComponent<PropsWithChildren<any>>) {
-    return async function <P extends Record<string, any>, Refs extends Record<string, any>>(
-        key: string,
-        Component: ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<Refs>>,
-        props?: P
-    ) {
-        let current = instanceMap[key]
-        if (!current) {
-            const div = document.createElement('div')
-            document.body.appendChild(div)
-            const ApiComponent = forwardRef<Refs & refsType<P>>((__, refs) => {
-                const ref = useRef<Refs>(null)
-                const [state, setState] = useState<Partial<P>>(props || {})
-
-                useImperativeHandle(refs, () => {
-                    return {
-                        $setProps: newProps => {
-                            setState(() => newProps)
-                        },
-                        $updateProps: newProps => {
-                            if (newProps) {
-                                setState(state => ({ ...state, ...newProps }))
-                            }
-                        },
-                        ...ref.current
-                    } as Refs & refsType<P>
-                })
-                if (Context) {
-                    return (
-                        <Context>
-                            <Component ref={ref} {...(state as any)} />
-                        </Context>
-                    )
-                }
-                return <Component ref={ref} {...(state as any)} />
-            })
-            current = instanceMap[key] = {
-                instance: void 0,
-                pending: new Promise<void>(resolve => {
-                    createRoot(div).render(
-                        (
-                            <ApiComponent
-                                ref={instance => {
-                                    current.instance = instanceMap[key].instance = instance!
-                                    resolve()
-                                }}
-                            />
-                        ) as never
-                    )
-                })
-            }
-        }
-        await current.pending
-        current.instance.$setProps(props)
-        // Delay return to avoid sync issue
-        // ------------------------------------------------------------------------
-        await new Promise(resolve => setTimeout(resolve))
-        return current.instance as Refs & refsType<P>
-    }
-}
+import {
+    forwardRef,
+    ForwardRefExoticComponent,
+    FunctionComponent,
+    PropsWithChildren,
+    PropsWithoutRef,
+    RefAttributes,
+    useImperativeHandle,
+    useRef,
+    useState
+} from 'react'
+import { createRoot } from 'react-dom/client'
+
+const instanceMap: Record<string, { pending: Promise<any>; instance: any }> = {}
+
+export interface refsType<P> {
+    $setProps: (newProps: P) => void
+    $updateProps: (newProps: Partial<P>) => void
+}
+
+export function create(Context?: FunctionComponent<PropsWithChildren<any>>) {
+    return async function <P extends Record<string, any>, Refs extends Record<string, any>>(
+        key: string,
+        Component: ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<Refs>>,
+        props?: P
+    ) {
+        let current = instanceMap[key]
+        if (!current) {
+            const div = document.createElement('div')
+            document.body.appendChild(div)
+            const ApiComponent = forwardRef<Refs & refsType<P>>((__, refs) => {
+                const ref = useRef<Refs>(null)
+                const [state, setState] = useState<Partial<P>>(props || {})
+
+                useImperativeHandle(refs, () => {
+                    return {
+                        $setProps: newProps => {
+                            setState(() => newProps)
+                        },
+                        $updateProps: newProps => {
+                            if (newProps) {
+                                setState(state => ({ ...state, ...newProps }))
+                            }
+                        },
+                        ...ref.current
+                    } as Refs & refsType<P>
+                })
+                if (Context) {
+                    return (
+                        <Context>
+                            <Component ref={ref} {...(state as any)} />
+                        </Context>
+                    )
+                }
+                return <Component ref={ref} {...(state as any)} />
+            })
+            current = instanceMap[key] = {
+                instance: void 0,
+                pending: new Promise<void>(resolve => {
+                    createRoot(div).render(
+                        (
+                            <ApiComponent
+                                ref={instance => {
+                                    current.instance = instanceMap[key].instance = instance!
+                                    resolve()
+                                }}
+                            />
+                        ) as never
+                    )
+                })
+            }
+        }
+        await current.pending
+        current.instance.$setProps(props)
+        // Delay return to avoid sync issue
+        // ------------------------------------------------------------------------
+        await new Promise(resolve => setTimeout(resolve))
+        return current.instance as Refs & refsType<P>
+    }
+}