create-packer 1.26.2 → 1.26.4

package/bin/createTemp.js

@@ -38,7 +38,7 @@ async function createTemp(dirname) {
         }
     ]);
     let tempInfo = tempInfoList.find(o => o.name === answer.temp);
-    if (tempInfo.children.length > 0) {
+    if (tempInfo?.children && tempInfo.children.length > 0) {
         answer = await inquirer.prompt([
             {
                 type: 'list',

package/package.json

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

package/template/cli/tsconfig.json

@@ -5,6 +5,7 @@
         "allowSyntheticDefaultImports": false,
         "resolveJsonModule": true,
         "allowJs": true,
+        "strictNullChecks": true,
         "target": "ESNext",
         "noImplicitAny": false,
         "moduleResolution": "node",

package/template/lib/react/tsconfig.json

@@ -11,6 +11,7 @@
         "jsx": "react-jsx",
         "allowSyntheticDefaultImports": true,
         "allowJs": true,
+        "strictNullChecks": true,
         "target": "ESNext",
         "noImplicitAny": false,
         "skipLibCheck": true,

package/template/lib/ts/tsconfig.json

@@ -4,6 +4,7 @@
         "esModuleInterop": true,
         "allowSyntheticDefaultImports": true,
         "allowJs": true,
+        "strictNullChecks": true,
         "target": "ESNext",
         "noImplicitAny": false,
         "moduleResolution": "node",

package/template/web-app/next/tsconfig.json

@@ -1,28 +1,21 @@
 {
-  "compilerOptions": {
-    "target": "es5",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "preserve",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "paths": {
-      "@/*": ["./*"]
-    },
-  },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"]
+    "extends": "./.svelte-kit/tsconfig.json",
+    "compilerOptions": {
+        "allowJs": true,
+        "strictNullChecks": true,
+        "checkJs": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "sourceMap": true,
+        "strict": true,
+        "paths": {
+            "@/*": ["./*"]
+        }
+    }
+    // Path aliases are handled by https://kit.svelte.dev/docs/configuration#alias
+    //
+    // If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
+    // from the referenced tsconfig.json - TypeScript does not merge them in
 }

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

@@ -4,7 +4,8 @@
         "target": "ESNext",
         "useDefineForClassFields": true,
         "lib": ["DOM", "DOM.Iterable", "ESNext"],
-        "allowJs": false,
+        "allowJs": true,
+        "strictNullChecks": true,
         "skipLibCheck": true,
         "esModuleInterop": false,
         "allowSyntheticDefaultImports": true,
@@ -22,6 +23,5 @@
         }
     },
     "include": ["**/*.tsx", "**/*.ts"],
-    "exclude": ["scripts", "vite.config.ts"],
-    "references": [{ "path": "./tsconfig.node.json" }]
+    "exclude": ["scripts"]
 }

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

@@ -4,7 +4,8 @@
         "target": "ESNext",
         "useDefineForClassFields": true,
         "lib": ["DOM", "DOM.Iterable", "ESNext"],
-        "allowJs": false,
+        "allowJs": true,
+        "strictNullChecks": true,
         "skipLibCheck": true,
         "esModuleInterop": false,
         "allowSyntheticDefaultImports": true,

package/template/web-app/svelte/tsconfig.json

@@ -2,6 +2,7 @@
     "extends": "./.svelte-kit/tsconfig.json",
     "compilerOptions": {
         "allowJs": true,
+        "strictNullChecks": true,
         "checkJs": true,
         "esModuleInterop": true,
         "forceConsistentCasingInFileNames": true,

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

@@ -0,0 +1,33 @@
+import { httpBodyType } from '../types'
+
+export class FetchError extends Error {
+    public request: Request
+
+    constructor(request: Request) {
+        super()
+        this.name = 'FetchError'
+        this.request = request
+    }
+}
+
+export async function pickRequestBody<Body = httpBodyType>(
+    req: Request
+): Promise<Body | undefined> {
+    let reqBody = void 0
+    try {
+        reqBody = await req.clone().json()
+    } catch {
+        /* empty */
+    }
+    return reqBody
+}
+
+export async function pickReponseBody<Body = any>(res: Response): Promise<Body | undefined> {
+    let body = void 0
+    try {
+        body = await res.clone().json()
+    } catch {
+        /** empty */
+    }
+    return body
+}

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

@@ -0,0 +1,58 @@
+import { KyInstance, Options } from 'ky'
+import { Input } from 'ky/distribution/types/options'
+import { includes, isString, omit } from 'lodash-es'
+import { stringify } from 'qs'
+import { Nullable } from '1k-types'
+import { configType, httpErrorType, requestOptionsType, serviceHooksType } from '../types'
+import { FetchError } from './base'
+
+export function createRequestActions(
+    prefixUrl: configType['prefixUrl'],
+    request: KyInstance,
+    hooks: serviceHooksType
+) {
+    function creator(method: Required<Options>['method']) {
+        return async function <DATA = any>(url: Input, option?: requestOptionsType): Promise<DATA> {
+            try {
+                return await request[method](url, omit(option, 'responseType'))[
+                    option?.responseType || 'json'
+                ]()
+            } catch (e: any) {
+                const searchParamsString = stringify(option?.searchParams, { addQueryPrefix: true })
+                let httpBody: Nullable<string> = void 0
+                if (option && isString(option?.body)) {
+                    httpBody = option.body
+                } else if (option?.body) {
+                    httpBody = 'other'
+                } else if (option?.json) {
+                    httpBody = JSON.stringify(option.json)
+                }
+                let error = new FetchError(
+                    new Request(prefixUrl + '/' + url + searchParamsString, {
+                        method,
+                        body: httpBody
+                    })
+                )
+                error.message = e.message
+                if (includes([httpErrorType.HTTPError, httpErrorType.TimeoutError], e.name)) {
+                    error = e
+                }
+                for (let i = 0; i < hooks.httpError.length; i++) {
+                    await hooks.httpError[i](error)
+                }
+                throw error
+            }
+        }
+    }
+
+    return {
+        get: creator('get'),
+        post: creator('post'),
+        put: creator('put'),
+        patch: creator('patch'),
+        head: creator('head'),
+        delete: creator('delete')
+    }
+}
+
+export type requestActionsType = ReturnType<typeof createRequestActions>

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

@@ -0,0 +1,46 @@
+import ky from 'ky'
+import { assign, isArray, isObject } from 'lodash-es'
+import { configType } from '../types'
+import { createRequestActions } from './createRequestActions'
+import { createServiceHooks } from './createServiceHooks'
+
+export function createService(config: configType) {
+    const { kyHooks, addHooks, serviceHooks } = createServiceHooks()
+    const globalParams: configType['globalParams'] = assign({}, config.globalParams)
+    const globalSearchParams: configType['globalSearchParams'] = assign(
+        {},
+        config.globalSearchParams
+    )
+    const request = ky.create({
+        prefixUrl: config.prefixUrl,
+        headers: config.headers,
+        hooks: kyHooks
+    })
+    const requestActions = createRequestActions(config.prefixUrl, request, serviceHooks)
+
+    function setGlobalParams(params: configType['globalParams']) {
+        assign(globalParams, params)
+    }
+    function setGlobalSearchParams(params: configType['globalSearchParams']) {
+        assign(globalSearchParams, params)
+    }
+
+    // init
+    // ------------------------------------------------------------------------
+    addHooks('beforeRequest', async req => {
+        const { searchParams, body } = req
+        req.searchParams = { ...globalSearchParams, ...searchParams }
+
+        if (!isArray(body) && isObject(body)) {
+            req.body = { ...globalParams, ...body }
+        }
+    })
+
+    return {
+        instance: request,
+        ...requestActions,
+        addHooks,
+        setGlobalParams,
+        setGlobalSearchParams
+    }
+}

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

@@ -0,0 +1,65 @@
+import { Hooks } from 'ky'
+import { omit } from 'lodash-es'
+import { parse, stringify } 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 || {})
+    }
+    const kyHooks: Hooks = {
+        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 })
+            }
+        ]
+    }
+    function addHooks<K extends keyof serviceHooksType>(
+        key: K,
+        callback: ArrayValues<serviceHooksType[K]>
+    ) {
+        serviceHooks[key].push(callback as any)
+    }
+
+    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 {
+        kyHooks,
+        serviceHooks,
+        addHooks
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './createRequestActions'
+export * from './createService'
+export * from './createServiceHooks'
+export * from './base'

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

@@ -1,22 +1,40 @@
-import { Options, HTTPError } from 'ky'
-import { Nullable } from '1k-types'
+import { HTTPError, NormalizedOptions, Options, TimeoutError } from 'ky'
+import { AnyArray, AnyObject, Nullable } from '1k-types'
+import { FetchError } from './tools'
 
-export interface configType extends Pick<Options, 'prefixUrl' | 'headers'> {
-    globalParams?: Record<string, any>
-    globalSearchParams?: Record<string, any>
-}
-export interface requestOptionsType extends Options {
-    responseType?: 'json' | 'text' | 'blob'
+export enum httpErrorType {
+    'HTTPError' = 'HTTPError',
+    'TimeoutError' = 'TimeoutError',
+    'FetchError' = 'FetchError'
 }
 
+export type httpBodyType = Nullable<string | number | AnyObject | AnyArray>
+
 export type beforeRequestType = (req: {
     searchParams: Record<string, any>
-    body: Nullable<Record<string, any>>
+    body: httpBodyType
     headers: Headers
     method: Options['method']
 }) => Promise<void> | void
-export type beforeErrorType = (error: HTTPError) => Promise<void> | void
+export type httpErrorHooksType = (
+    error: HTTPError | TimeoutError | FetchError
+) => Promise<void> | void
+export type AfterResponseHook = (arg: {
+    request: Request
+    options: NormalizedOptions
+    response: Response
+}) => Promise<void> | void
 export interface serviceHooksType {
-    beforeError: beforeErrorType[]
+    httpError: httpErrorHooksType[]
     beforeRequest: beforeRequestType[]
+    afterResponse: AfterResponseHook[]
+}
+
+export interface configType extends Pick<Options, 'prefixUrl' | 'headers'> {
+    globalParams?: Record<string, any>
+    globalSearchParams?: Record<string, any>
+    hooks?: Partial<serviceHooksType>
+}
+export interface requestOptionsType extends Options {
+    responseType?: 'json' | 'text' | 'blob'
 }

package/template/web-extension/tsconfig.json

@@ -4,10 +4,12 @@
         "target": "ESNext",
         "useDefineForClassFields": true,
         "lib": ["DOM", "DOM.Iterable", "ESNext"],
-        "allowJs": false,
+        "allowJs": true,
+        "strictNullChecks": true,
         "skipLibCheck": true,
         "esModuleInterop": false,
         "allowSyntheticDefaultImports": true,
+        "noImplicitAny": false,
         "strict": true,
         "forceConsistentCasingInFileNames": true,
         "strictPropertyInitialization": false,
@@ -15,7 +17,6 @@
         "moduleResolution": "Node",
         "resolveJsonModule": true,
         "isolatedModules": true,
-        "noImplicitAny": false,
         "noEmit": true,
         "jsx": "react-jsx",
         "paths": {
@@ -23,6 +24,5 @@
         }
     },
     "include": ["**/*.tsx", "**/*.ts"],
-    "exclude": ["scripts", "vite.config.ts"],
-    "references": [{ "path": "./tsconfig.node.json" }]
+    "exclude": ["scripts"]
 }

package/template/workspace/pnpm/packages/test/tsconfig.json

@@ -4,6 +4,7 @@
         "esModuleInterop": true,
         "allowSyntheticDefaultImports": true,
         "allowJs": true,
+        "strictNullChecks": true,
         "target": "ESNext",
         "noImplicitAny": false,
         "moduleResolution": "node",

package/template/workspace/pnpm/tsconfig.json

@@ -1,17 +1,18 @@
 {
-  "compilerOptions": {
-    "module": "CommonJS",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "allowJs": true,
-    "target": "ESNext",
-    "noImplicitAny": false,
-    "moduleResolution": "node",
-    "sourceMap": false,
-    "declaration": true,
-    "outDir": "lib",
-    "baseUrl": "."
-  },
-  "include": ["tasks/**/*"],
-  "exclude": ["node_modules/**/*"],
+    "compilerOptions": {
+        "module": "CommonJS",
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "allowJs": true,
+        "strictNullChecks": true,
+        "target": "ESNext",
+        "noImplicitAny": false,
+        "moduleResolution": "node",
+        "sourceMap": false,
+        "declaration": true,
+        "outDir": "lib",
+        "baseUrl": "."
+    },
+    "include": ["tasks/**/*"],
+    "exclude": ["node_modules/**/*"]
 }

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

@@ -1,132 +0,0 @@
-import ky, { Hooks, KyInstance, Options } from 'ky'
-import { Input } from 'ky/distribution/types/options'
-import { assign, includes, isArray, isObject, omit } from 'lodash-es'
-import { parse, stringify } from 'qs'
-import { ArrayValues } from '1k-types'
-import { configType, requestOptionsType, serviceHooksType } from './types'
-
-function createServiceHooks() {
-    const serviceHooks: serviceHooksType = {
-        beforeError: [],
-        beforeRequest: []
-    }
-    const kyHooks: Hooks = {
-        beforeError: [
-            async error => {
-                await foreachHooks('beforeError', error)
-                return error
-            }
-        ],
-        beforeRequest: [
-            async req => {
-                // eslint-disable-next-line prefer-const
-                let [url, searchParams] = req.url.split('?')
-                let reqBody = void 0
-                if (!includes(['GET', 'HEAD'], req.method)) {
-                    try {
-                        reqBody = await req.json()
-                    } catch {
-                        /* empty */
-                    }
-                }
-                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
-                })
-            }
-        ]
-    }
-    function addHooks<K extends keyof serviceHooksType>(
-        key: K,
-        callback: ArrayValues<serviceHooksType[K]>
-    ) {
-        serviceHooks[key].push(callback as any)
-    }
-
-    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 {
-        kyHooks,
-        serviceHooks,
-        addHooks
-    }
-}
-
-function createRequestActions(request: KyInstance) {
-    function creator(method: Required<Options>['method']) {
-        return function <DATA = any>(url: Input, option?: requestOptionsType): Promise<DATA> {
-            return request[method](url, omit(option, 'responseType'))[
-                option?.responseType || 'json'
-            ]()
-        }
-    }
-
-    return {
-        get: creator('get'),
-        post: creator('post'),
-        put: creator('put'),
-        patch: creator('patch'),
-        head: creator('head'),
-        delete: creator('delete')
-    }
-}
-export type requestActionsType = ReturnType<typeof createRequestActions>
-
-export function createService(config: configType) {
-    const { kyHooks, addHooks } = createServiceHooks()
-    const globalParams: configType['globalParams'] = assign({}, config.globalParams)
-    const globalSearchParams: configType['globalSearchParams'] = assign(
-        {},
-        config.globalSearchParams
-    )
-    const request = ky.create({
-        prefixUrl: config.prefixUrl,
-        headers: config.headers,
-        hooks: kyHooks
-    })
-    const requestActions = createRequestActions(request)
-
-    function setGlobalParams(params: configType['globalParams']) {
-        assign(globalParams, params)
-    }
-    function setGlobalSearchParams(params: configType['globalSearchParams']) {
-        assign(globalSearchParams, params)
-    }
-
-    // 初始化
-    // ------------------------------------------------------------------------
-    addHooks('beforeRequest', async req => {
-        const { searchParams, body } = req
-        req.searchParams = { ...globalSearchParams, ...searchParams }
-
-        if (!isArray(body) && isObject(body)) {
-            req.body = { ...globalParams, ...body }
-        }
-    })
-
-    return {
-        instance: request,
-        ...requestActions,
-        addHooks,
-        setGlobalParams,
-        setGlobalSearchParams
-    }
-}