create-bubbles 0.1.18 → 0.1.20

package/template-vue-vite-eslint/src/router/modules/index.ts

@@ -0,0 +1,36 @@
+import type { RouteRecordRaw } from 'vue-router'
+
+import type { MenuRouteRecordRawType } from '../interface'
+
+import { ExampleRoutes } from './example'
+
+export const menuRoutes: MenuRouteRecordRawType [] = [
+  {
+    path: '/home',
+    name: 'Home',
+    meta: { title: '首页概览', icon: 'svg-home' },
+    component: () => import('@/views/home/index.vue'),
+  },
+]
+
+export const routes: RouteRecordRaw[] = [
+  {
+    path: '/',
+    name: 'layout',
+    component: () => import('@/layout/default/index.vue'),
+    children: [
+      {
+        path: '/',
+        redirect: '/home',
+      },
+      ...menuRoutes,
+    ],
+  },
+  ...ExampleRoutes,
+  {
+    path: '/login',
+    name: 'login',
+    meta: { title: '登录' },
+    component: () => import('@/views/login/index.vue'),
+  },
+]

package/template-vue-vite-eslint/src/store/index.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vue'
+
+import { createPinia } from 'pinia'
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'
+
+export const store = createPinia()
+store.use(piniaPluginPersistedstate)
+
+export function setupStore(app: App) {
+  app.use(store)
+}

package/template-vue-vite-eslint/src/store/modules/user.ts

@@ -0,0 +1,20 @@
+import { defineStore } from 'pinia'
+
+import { store } from '..'
+
+export const useUserStore = defineStore(
+  'user',
+  {
+    state: () => {
+      return {
+        name: 'admin',
+        token: 'admin',
+        avatar: 'https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif',
+      }
+    },
+  },
+)
+
+export function useUserStoreWithOut() {
+  return useUserStore(store)
+}

package/template-vue-vite-eslint/src/styles/index.scss

@@ -0,0 +1,29 @@
+@use './font.scss';
+@use './variables.scss';
+
+html,
+body,
+#root {
+  width: 100%;
+  height: 100%;
+  font-family: 'SourceHanSansCN';
+}
+
+*,
+*::before,
+*::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+//弹窗的标题样式
+.dialog-title {
+  border-left: 3px solid #22b5ffff;
+  padding-left: 10px;
+  height: 16px;
+  color: #ffffffb8;
+  font: 700;
+  font-size: 16px;
+  line-height: 16px;
+}

package/template-vue-vite-eslint/src/styles/variables.scss

@@ -0,0 +1,3 @@
+:root {
+  --header-height: 80px;
+}

package/template-vue-vite-eslint/src/types/auto-import.d.ts

@@ -0,0 +1,78 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// Generated by unplugin-auto-import
+// biome-ignore lint: disable
+export {}
+declare global {
+  const EffectScope: typeof import('vue').EffectScope
+  const computed: typeof import('vue').computed
+  const createApp: typeof import('vue').createApp
+  const customRef: typeof import('vue').customRef
+  const defineAsyncComponent: typeof import('vue').defineAsyncComponent
+  const defineComponent: typeof import('vue').defineComponent
+  const effectScope: typeof import('vue').effectScope
+  const getCurrentInstance: typeof import('vue').getCurrentInstance
+  const getCurrentScope: typeof import('vue').getCurrentScope
+  const getCurrentWatcher: typeof import('vue').getCurrentWatcher
+  const h: typeof import('vue').h
+  const inject: typeof import('vue').inject
+  const isProxy: typeof import('vue').isProxy
+  const isReactive: typeof import('vue').isReactive
+  const isReadonly: typeof import('vue').isReadonly
+  const isRef: typeof import('vue').isRef
+  const isShallow: typeof import('vue').isShallow
+  const markRaw: typeof import('vue').markRaw
+  const nextTick: typeof import('vue').nextTick
+  const onActivated: typeof import('vue').onActivated
+  const onBeforeMount: typeof import('vue').onBeforeMount
+  const onBeforeRouteLeave: typeof import('vue-router').onBeforeRouteLeave
+  const onBeforeRouteUpdate: typeof import('vue-router').onBeforeRouteUpdate
+  const onBeforeUnmount: typeof import('vue').onBeforeUnmount
+  const onBeforeUpdate: typeof import('vue').onBeforeUpdate
+  const onDeactivated: typeof import('vue').onDeactivated
+  const onErrorCaptured: typeof import('vue').onErrorCaptured
+  const onMounted: typeof import('vue').onMounted
+  const onRenderTracked: typeof import('vue').onRenderTracked
+  const onRenderTriggered: typeof import('vue').onRenderTriggered
+  const onScopeDispose: typeof import('vue').onScopeDispose
+  const onServerPrefetch: typeof import('vue').onServerPrefetch
+  const onUnmounted: typeof import('vue').onUnmounted
+  const onUpdated: typeof import('vue').onUpdated
+  const onWatcherCleanup: typeof import('vue').onWatcherCleanup
+  const provide: typeof import('vue').provide
+  const reactive: typeof import('vue').reactive
+  const readonly: typeof import('vue').readonly
+  const ref: typeof import('vue').ref
+  const resolveComponent: typeof import('vue').resolveComponent
+  const shallowReactive: typeof import('vue').shallowReactive
+  const shallowReadonly: typeof import('vue').shallowReadonly
+  const shallowRef: typeof import('vue').shallowRef
+  const toRaw: typeof import('vue').toRaw
+  const toRef: typeof import('vue').toRef
+  const toRefs: typeof import('vue').toRefs
+  const toValue: typeof import('vue').toValue
+  const triggerRef: typeof import('vue').triggerRef
+  const unref: typeof import('vue').unref
+  const useAttrs: typeof import('vue').useAttrs
+  const useCssModule: typeof import('vue').useCssModule
+  const useCssVars: typeof import('vue').useCssVars
+  const useId: typeof import('vue').useId
+  const useLink: typeof import('vue-router').useLink
+  const useModel: typeof import('vue').useModel
+  const useRoute: typeof import('vue-router').useRoute
+  const useRouter: typeof import('vue-router').useRouter
+  const useSlots: typeof import('vue').useSlots
+  const useTemplateRef: typeof import('vue').useTemplateRef
+  const watch: typeof import('vue').watch
+  const watchEffect: typeof import('vue').watchEffect
+  const watchPostEffect: typeof import('vue').watchPostEffect
+  const watchSyncEffect: typeof import('vue').watchSyncEffect
+}
+// for type re-export
+declare global {
+  // @ts-ignore
+  export type { Component, Slot, Slots, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, ShallowRef, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue'
+  import('vue')
+}

package/template-vue-vite-eslint/src/types/components.d.ts

@@ -0,0 +1,18 @@
+/* eslint-disable */
+// @ts-nocheck
+// biome-ignore lint: disable
+// oxlint-disable
+// ------
+// Generated by unplugin-vue-components
+// Read more: https://github.com/vuejs/core/pull/3399
+
+export {}
+
+/* prettier-ignore */
+declare module 'vue' {
+  export interface GlobalComponents {
+    RouterLink: typeof import('vue-router')['RouterLink']
+    RouterView: typeof import('vue-router')['RouterView']
+    SvgIcon: typeof import('./../components/Icon/svg-icon.vue')['default']
+  }
+}

package/template-vue-vite-eslint/src/types/vite-env.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="vite/client" />
+
+/* eslint-disable */
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}
+
+// vite-plugin-svg-icons 类型声明
+declare module 'virtual:svg-icons-register' {
+  const register: () => void
+  export default register
+}

package/template-vue-vite-eslint/src/utils/env.ts

@@ -0,0 +1,11 @@
+/**
+ * 通过一个文件导出所有的环境变量这样方便统一修改
+ * @returns
+ */
+export const envVariables = {
+  PORT: import.meta.env.VITE_PORT,
+  PATH: import.meta.env.VITE_PATH,
+  APP_NAME: import.meta.env.VITE_APP_NAME,
+  /** 后端接口前缀 */
+  API_AFFIX: import.meta.env.VITE_API_AFFIX,
+}

package/template-vue-vite-eslint/src/utils/request/core/index.ts

@@ -0,0 +1,425 @@
+import {
+  deepMergeObject,
+  isPlainObject,
+  isReadableStream,
+  tryParseJsonString,
+} from './utils'
+import type {
+  AlovaGlobalCacheAdapter,
+  AlovaOptions,
+  AlovaRequestAdapter,
+  GlobalCacheConfig,
+  StatesExport,
+  StatesHook,
+} from 'alova'
+import { createAlova } from 'alova'
+import type { FetchRequestInit } from 'alova/fetch'
+import adapterFetch from 'alova/fetch'
+
+type MaybePromise<T> = T | Promise<T>
+type HeaderValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | (() => MaybePromise<string | number | boolean | null | undefined>)
+type StatusMatcher<RE> = number | number[] | ((status: number, response: RE) => boolean)
+type CodeMatcher = Array<number | string>
+
+export interface StatusMap<RE = unknown> {
+  success?: StatusMatcher<RE>
+  unAuthorized?: StatusMatcher<RE>
+}
+
+export interface CodeMap {
+  success?: CodeMatcher
+  unAuthorized?: CodeMatcher
+}
+
+export interface RequestMeta {
+  isWrapped?: boolean
+  isTransformResponse?: boolean
+  isShowSuccessMessage?: boolean
+  isShowErrorMessage?: boolean
+}
+
+export interface BaseRequestOption<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+> extends RequestMeta {
+  baseUrl?: string
+  timeout?: number
+  commonHeaders?: () => Record<string, HeaderValue>
+  statusMap?: StatusMap<RE>
+  codeMap?: CodeMap
+  responseCodeKey?: string
+  responseDataKey?: string
+  responseMessageKey?: string
+  cacheFor?: GlobalCacheConfig<any> | null
+  cacheLogger?: boolean
+  statesHook?: StatesHook<SE>
+  successDefaultMessage?: string
+  errorDefaultMessage?: string
+  successMessageFunc?: (message: string) => void
+  errorMessageFunc?: (message: string) => void
+  unAuthorizedResponseFunc?: () => void
+  requestAdapter?: AlovaRequestAdapter<RC, RE, RH>
+  l1Cache?: AlovaGlobalCacheAdapter
+  l2Cache?: AlovaGlobalCacheAdapter
+  storageAdapter?: AlovaGlobalCacheAdapter
+}
+
+export type baseRequestOption<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+> = BaseRequestOption<RC, RE, RH, SE>
+
+export type RequestOption<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+> = BaseRequestOption<RC, RE, RH, SE>
+
+type RequestAlovaGenerics<RC extends object, RE, RH, SE extends StatesExport<any>> = {
+  Responded: unknown
+  Transformed: unknown
+  RequestConfig: RC
+  Response: RE
+  ResponseHeader: RH
+  L1Cache: AlovaGlobalCacheAdapter
+  L2Cache: AlovaGlobalCacheAdapter
+  StatesExport: SE
+}
+
+type ResolvedRequestOption<RC extends object, RE, RH, SE extends StatesExport<any>> = Required<
+  Pick<
+    BaseRequestOption<RC, RE, RH, SE>,
+    | 'baseUrl'
+    | 'statusMap'
+    | 'codeMap'
+    | 'responseCodeKey'
+    | 'responseDataKey'
+    | 'responseMessageKey'
+    | 'isWrapped'
+    | 'isTransformResponse'
+    | 'isShowSuccessMessage'
+    | 'successDefaultMessage'
+    | 'isShowErrorMessage'
+    | 'errorDefaultMessage'
+    | 'cacheLogger'
+  >
+> &
+  BaseRequestOption<RC, RE, RH, SE>
+
+const DEFAULT_SUCCESS_MESSAGE = '操作成功'
+const DEFAULT_ERROR_MESSAGE = '服务异常'
+
+const defaultRequestOption: BaseRequestOption<any, any, any, any> = {
+  baseUrl: '/',
+  timeout: undefined,
+  statusMap: {
+    success: 200,
+    unAuthorized: 401,
+  },
+  codeMap: {
+    success: [200],
+    unAuthorized: [401],
+  },
+  responseCodeKey: 'code',
+  responseDataKey: 'data',
+  responseMessageKey: 'message',
+  isWrapped: true,
+  isTransformResponse: true,
+  isShowSuccessMessage: false,
+  successDefaultMessage: DEFAULT_SUCCESS_MESSAGE,
+  isShowErrorMessage: true,
+  errorDefaultMessage: DEFAULT_ERROR_MESSAGE,
+  cacheFor: null,
+  cacheLogger: true,
+  requestAdapter: adapterFetch() as AlovaRequestAdapter<any, any, any>,
+}
+
+function getMethodMeta(method: unknown): RequestMeta {
+  const methodRecord = method as { meta?: RequestMeta; config?: { meta?: RequestMeta } } | undefined
+  return methodRecord?.config?.meta ?? methodRecord?.meta ?? {}
+}
+
+function getMetaFlag(meta: RequestMeta, key: keyof RequestMeta, fallback: boolean): boolean {
+  const value = meta[key]
+  return typeof value === 'boolean' ? value : fallback
+}
+
+function isMatchedStatus<RE>(
+  status: number,
+  matcher: StatusMatcher<RE> | undefined,
+  response: RE,
+): boolean {
+  if (matcher === undefined) return status >= 200 && status < 300
+
+  if (typeof matcher === 'function') return matcher(status, response)
+
+  return Array.isArray(matcher) ? matcher.includes(status) : matcher === status
+}
+
+function isMatchedCode(code: unknown, matcher: CodeMatcher | undefined): boolean {
+  if (!matcher?.length) return true
+
+  return matcher.some((item) => String(item) === String(code))
+}
+
+function getResponseStatus(response: unknown): number {
+  const responseRecord = response as { status?: unknown; statusCode?: unknown }
+  const status = responseRecord.statusCode ?? responseRecord.status
+  return typeof status === 'number' ? status : Number(status)
+}
+
+function getResponseMessage(data: unknown, messageKey: string, defaultMessage: string): string {
+  if (!isPlainObject(data)) return defaultMessage
+
+  const message = data[messageKey] ?? data.message ?? data.msg
+  if (typeof message === 'string') return message || defaultMessage
+  if (typeof message === 'number') return String(message)
+
+  return defaultMessage
+}
+
+function getResponseField(data: unknown, key: string): unknown {
+  return isPlainObject(data) ? data[key] : undefined
+}
+
+async function parseFetchResponse(response: {
+  status?: number
+  body?: unknown
+  headers?: Headers | Record<string, unknown>
+  clone?: () => Response
+  json?: () => Promise<unknown>
+  text?: () => Promise<string>
+}): Promise<unknown> {
+  if (response.status === 204) return undefined
+
+  const reader = typeof response.clone === 'function' ? response.clone() : response
+  const contentType = getHeaderValue(response.headers, 'content-type')
+
+  if (contentType.includes('application/json') && typeof reader.json === 'function')
+    return reader.json()
+
+  if (contentType.startsWith('text/') && typeof reader.text === 'function')
+    return tryParseJsonString(await reader.text())
+
+  if (typeof reader.json === 'function') {
+    try {
+      return await reader.json()
+    } catch {
+      // Fall through to text parsing.
+    }
+  }
+
+  if (typeof reader.text === 'function') return tryParseJsonString(await reader.text())
+
+  return undefined
+}
+
+function getHeaderValue(
+  headers: Headers | Record<string, unknown> | undefined,
+  key: string,
+): string {
+  if (!headers) return ''
+
+  if (typeof Headers !== 'undefined' && headers instanceof Headers) return headers.get(key) ?? ''
+
+  const headerRecord = headers as Record<string, unknown>
+  const value =
+    headerRecord[key] ?? headerRecord[key.toLowerCase()] ?? headerRecord[key.toUpperCase()]
+  return typeof value === 'string' ? value : ''
+}
+
+async function getResponseData(response: unknown): Promise<unknown> {
+  const responseRecord = response as {
+    body?: unknown
+    data?: unknown
+    json?: () => Promise<unknown>
+    text?: () => Promise<string>
+  }
+
+  if ('data' in responseRecord && !isReadableStream(responseRecord.body))
+    return tryParseJsonString(responseRecord.data)
+
+  if (
+    isReadableStream(responseRecord.body) ||
+    typeof responseRecord.json === 'function' ||
+    typeof responseRecord.text === 'function'
+  ) {
+    return parseFetchResponse(responseRecord)
+  }
+
+  return response
+}
+
+async function resolveHeaderValue(value: HeaderValue): Promise<string | undefined> {
+  const resolved = typeof value === 'function' ? await value() : value
+  if (resolved === null || resolved === undefined) return undefined
+  return String(resolved)
+}
+
+function setHeader(target: unknown, key: string, value: string): void {
+  if (typeof Headers !== 'undefined' && target instanceof Headers) {
+    target.set(key, value)
+    return
+  }
+
+  if (Array.isArray(target)) {
+    target.push([key, value])
+    return
+  }
+
+  ;(target as Record<string, string>)[key] = value
+}
+
+function resolveConfig<RC extends object, RE, RH, SE extends StatesExport<any>>(
+  option: BaseRequestOption<RC, RE, RH, SE>,
+): ResolvedRequestOption<RC, RE, RH, SE> {
+  return deepMergeObject(defaultRequestOption, option) as ResolvedRequestOption<RC, RE, RH, SE>
+}
+
+export function createInstance<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+>(option: RequestOption<RC, RE, RH, SE> = {}) {
+  const config = resolveConfig(option)
+
+  const alovaOptions: AlovaOptions<RequestAlovaGenerics<RC, RE, RH, SE>> = {
+    baseURL: config.baseUrl,
+    timeout: config.timeout,
+    cacheFor: config.cacheFor as GlobalCacheConfig<any>,
+    cacheLogger: config.cacheLogger,
+    statesHook: config.statesHook,
+    requestAdapter: config.requestAdapter!,
+    l1Cache: config.l1Cache,
+    l2Cache: config.l2Cache ?? config.storageAdapter,
+    beforeRequest: async (method) => {
+      const methodConfig = method.config as { headers?: unknown }
+      const headers = methodConfig.headers ?? {}
+      methodConfig.headers = headers
+
+      for (const [key, value] of Object.entries(config.commonHeaders?.() ?? {})) {
+        const resolvedValue = await resolveHeaderValue(value)
+        if (resolvedValue !== undefined) setHeader(headers, key, resolvedValue)
+      }
+    },
+    responded: {
+      onSuccess: async (response, method) => {
+        const meta = getMethodMeta(method)
+        const shouldTransform = getMetaFlag(meta, 'isTransformResponse', config.isTransformResponse)
+        const showSuccess = getMetaFlag(meta, 'isShowSuccessMessage', config.isShowSuccessMessage)
+        const showError = getMetaFlag(meta, 'isShowErrorMessage', config.isShowErrorMessage)
+        const isWrapped = getMetaFlag(meta, 'isWrapped', config.isWrapped)
+
+        if (!shouldTransform) return response
+
+        const status = getResponseStatus(response)
+        const data = await getResponseData(response)
+
+        if (!isMatchedStatus(status, config.statusMap.success, response)) {
+          if (isMatchedStatus(status, config.statusMap.unAuthorized, response))
+            config.unAuthorizedResponseFunc?.()
+
+          if (showError) {
+            config.errorMessageFunc?.(
+              getResponseMessage(data, config.responseMessageKey, config.errorDefaultMessage),
+            )
+          }
+          return Promise.reject(response)
+        }
+
+        if (!isWrapped) {
+          if (showSuccess) config.successMessageFunc?.(config.successDefaultMessage)
+          return data
+        }
+
+        const code = getResponseField(data, config.responseCodeKey)
+        const responseData = getResponseField(data, config.responseDataKey)
+        const responseMessage = getResponseMessage(
+          data,
+          config.responseMessageKey,
+          config.successDefaultMessage,
+        )
+
+        if (!isMatchedCode(code, config.codeMap.success)) {
+          if (isMatchedCode(code, config.codeMap.unAuthorized)) config.unAuthorizedResponseFunc?.()
+
+          if (showError) {
+            config.errorMessageFunc?.(
+              getResponseMessage(data, config.responseMessageKey, config.errorDefaultMessage),
+            )
+          }
+          return Promise.reject(response)
+        }
+
+        if (showSuccess) config.successMessageFunc?.(responseMessage)
+
+        return responseData
+      },
+      onError: (error, method) => {
+        const meta = getMethodMeta(method)
+        const showError = getMetaFlag(meta, 'isShowErrorMessage', config.isShowErrorMessage)
+
+        if (showError) {
+          config.errorMessageFunc?.(
+            error instanceof Error ? error.message : config.errorDefaultMessage,
+          )
+        }
+        return Promise.reject(error)
+      },
+    },
+  }
+
+  return createAlova(alovaOptions)
+}
+
+export type RequestInstance<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+> = ReturnType<typeof createInstance<RC, RE, RH, SE>>
+
+export type DualCallInstance<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+> = RequestInstance<RC, RE, RH, SE> &
+  ((option?: RequestOption<RC, RE, RH, SE>) => RequestInstance<RC, RE, RH, SE>)
+
+export function createDualCallInstance<
+  RC extends object = FetchRequestInit,
+  RE = Response,
+  RH = Headers,
+  SE extends StatesExport<any> = StatesExport<any>,
+>(baseConfig: BaseRequestOption<RC, RE, RH, SE>): DualCallInstance<RC, RE, RH, SE> {
+  const defaultInstance = createInstance(baseConfig)
+  const dualInstance = ((option?: RequestOption<RC, RE, RH, SE>) => {
+    if (!option) return defaultInstance
+    return createInstance(deepMergeObject(baseConfig, option))
+  }) as DualCallInstance<RC, RE, RH, SE>
+
+  Object.assign(dualInstance, defaultInstance)
+  dualInstance.Get = defaultInstance.Get.bind(defaultInstance)
+  dualInstance.Post = defaultInstance.Post.bind(defaultInstance)
+  dualInstance.Put = defaultInstance.Put.bind(defaultInstance)
+  dualInstance.Delete = defaultInstance.Delete.bind(defaultInstance)
+  dualInstance.Patch = defaultInstance.Patch.bind(defaultInstance)
+  dualInstance.Head = defaultInstance.Head.bind(defaultInstance)
+  dualInstance.Options = defaultInstance.Options.bind(defaultInstance)
+  dualInstance.Request = defaultInstance.Request.bind(defaultInstance)
+
+  return dualInstance
+}

package/template-vue-vite-eslint/src/utils/request/core/utils.ts

@@ -0,0 +1,39 @@
+export function deepMergeObject<T = any>(source: T, target: Partial<T>): T {
+  const merge = (src: any, tgt: any): any => {
+    if (!isPlainObject(src) || !isPlainObject(tgt)) return tgt === undefined ? src : tgt
+
+    const result = { ...src }
+    for (const key of Object.keys(tgt)) {
+      const targetValue = tgt[key]
+      result[key] = isPlainObject(targetValue) ? merge(result[key], targetValue) : targetValue
+    }
+
+    return result
+  }
+
+  return merge(source, target)
+}
+
+export function isPlainObject(data: unknown): data is Record<string, any> {
+  return Object.prototype.toString.call(data) === '[object Object]'
+}
+
+export function isReadableStream(data: unknown): boolean {
+  if (typeof ReadableStream === 'undefined') return false
+  return data instanceof ReadableStream
+}
+
+export function tryParseJsonString(data: unknown): unknown {
+  if (typeof data !== 'string') return data
+
+  const value = data.trim()
+  if (!value) return data
+
+  if (!value.startsWith('{') && !value.startsWith('[')) return data
+
+  try {
+    return JSON.parse(value)
+  } catch {
+    return data
+  }
+}