@gx-design-vue/create-gx-cli 0.1.12 → 0.1.13

package/template-gx-design-thin/build/util/index.ts

@@ -1,131 +0,0 @@
-import fs from 'node:fs'
-import path, { resolve } from 'node:path'
-import dotenv from 'dotenv'
-
-export const rootPath = process.cwd()
-
-export function pathResolve(dir: string) {
-  return resolve(process.cwd(), '.', dir)
-}
-
-/**
- * Whether to generate package preview
- */
-export function isReportMode(): boolean {
-  return process.env.REPORT === 'true'
-}
-
-// Read all environment variable configuration files to process.env
-export function wrapperEnv(envConf: Recordable): ViteEnv {
-  const ret: any = {}
-
-  for (const envName of Object.keys(envConf)) {
-    let realName = envConf[envName].replace(/\\n/g, '\n')
-    realName = realName === 'true' ? true : realName === 'false' ? false : realName
-
-    ret[envName] = realName
-    process.env[envName] = realName
-  }
-  return ret
-}
-
-/**
- * 获取当前环境下生效的配置文件名
- */
-function getConfFiles() {
-  const script = process.env.npm_lifecycle_script
-  const reg = new RegExp('--mode ([a-z]+)')
-  const result = reg.exec(script as string) as any
-  if (result) {
-    const mode = result[1] as string
-    return [ '.env', `.env.${mode}` ]
-  }
-  return [ '.env', '.env.production' ]
-}
-
-/**
- * Get the environment variables starting with the specified prefix
- * @param match prefix
- * @param confFiles ext
- */
-export function getEnvConfig(confFiles = getConfFiles()): Partial<ViteEnv> {
-  let envConfig: Partial<ViteEnv> = {}
-  confFiles.forEach((item) => {
-    try {
-      const env = dotenv.parse(fs.readFileSync(path.resolve(process.cwd(), item)))
-      envConfig = { ...envConfig, ...env }
-    } catch (e) {
-      console.error(`Error in parsing ${item}`, e)
-    }
-  })
-  return envConfig
-}
-
-/**
- * Get user root directory
- * @param dir file path
- */
-export function getRootPath(...dir: string[]) {
-  return path.resolve(process.cwd(), ...dir)
-}
-
-export function getDefaultPath(supportTs = true) {
-  return path.resolve(process.cwd(), `src/main.${supportTs ? 'ts' : 'js'}`)
-}
-
-export function fileExists(f: string) {
-  try {
-    fs.accessSync(f, fs.constants.W_OK)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-function q(t) {
-  return t.reduce((n, e) => n + e)
-}
-
-function Gt(t, n?: number) {
-  if (t === 0)
-    return '0 Bytes'
-  const e = 1024
-  const r = n || 2
-  const o = [ 'Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB' ]
-  const s = Math.floor(Math.log(t) / Math.log(e))
-  return `${Number.parseFloat((t / e ** s).toFixed(r))} ${o[s]}`
-}
-
-const ot = []
-
-export function getPackageSize({ folder, callBack, format = !0 }) {
-  fs.readdir(folder, (err, files) => {
-    if (err)
-      throw err
-
-    let index = 0
-    const callBacks = () => {
-      if (++index === files.length) {
-        callBack(format ? Gt(q(ot)) : q(ot))
-      }
-    }
-
-    files.forEach((p) => {
-      fs.stat(`${folder}/${p}`, (err, stat) => {
-        if (err)
-          throw err
-        if (stat.isFile()) {
-          ot.push(stat.size)
-          callBacks()
-        } else {
-          getPackageSize({
-            folder: `${folder}/${p}`,
-            callBack: callBacks
-          })
-        }
-      })
-    })
-
-    files.length === 0 && callBack(0)
-  })
-}

package/template-gx-design-thin/build/vite/cdn.ts

@@ -1,63 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { defaultSettings } from '../../config'
-
-const { cdnUrl, cdnModules } = defaultSettings
-
-function getModuleVersion(name: string): string {
-  const pwd = process.cwd()
-  const pkgFile = path.join(pwd, 'node_modules', name, 'package.json')
-  if (fs.existsSync(pkgFile)) {
-    const pkgJson = JSON.parse(fs.readFileSync(pkgFile, 'utf8'))
-    return pkgJson.version
-  }
-
-  return ''
-}
-
-function isFullPath(path: string) {
-  return path.startsWith('http:') || path.startsWith('https:') || path.startsWith('//')
-}
-
-function renderUrl(data: CdnModuleList & {
-  version: string
-}) {
-  const { path } = data
-  if (isFullPath(path))
-    return path
-  return cdnUrl.replace(/\{name\}/g, data.name)
-    .replace(/\{version\}/g, data.version)
-    .replace(/\{path\}/g, path)
-}
-
-function getCdnModuleFiles() {
-  return cdnModules.map(m => {
-    const version = getModuleVersion(m.name)
-    if (!version) {
-      throw new Error(`modules: ${m.name} package.json file does not exist`)
-    }
-
-    let css = m.css || []
-    if (!Array.isArray(css) && css) {
-      css = [ css ]
-    }
-
-    return {
-      js: renderUrl({
-        ...m,
-        version
-      }),
-      css
-    }
-  })
-}
-
-export function getExternalMap() {
-  const externalMap = {}
-  cdnModules.forEach((v) => {
-    externalMap[v.name] = v.globalName
-  })
-  return externalMap
-}
-
-export default getCdnModuleFiles()

package/template-gx-design-thin/build/vite/optimizer.ts

@@ -1,26 +0,0 @@
-import type { GetManualChunk } from 'rollup'
-
-const vendorLibs: { match: string[]; output: string }[] = [
-  {
-    match: ['ant-design-vue'],
-    output: 'ant-design-vue',
-  },
-  {
-    match: ['@gx-design-vue/pro-field'],
-    output: 'pro-field',
-  },
-  {
-    match: ['@gx-design-vue/pro-form'],
-    output: 'pro-form',
-  },
-]
-
-export const configManualChunk: GetManualChunk = (id: string) => {
-  if (/[\\/]node_modules[\\/]/.test(id)) {
-    const matchItem = vendorLibs.find((item) => {
-      const reg = new RegExp(`[\\/]node_modules[\\/]_?(${item.match.join('|')})(.*)`, 'ig')
-      return reg.test(id)
-    })
-    return matchItem ? matchItem.output : null
-  }
-}

package/template-gx-design-thin/build/vite/plugin/appConfig.ts

@@ -1,91 +0,0 @@
-import colors from 'picocolors'
-import type { PluginOption } from 'vite'
-import { readPackageJSON } from 'pkg-types'
-
-import { getEnvConfig, rootPath } from '../../util'
-import { createContentHash, strToHex } from '../../util/hash'
-
-const GLOBAL_CONFIG_FILE_NAME = '_app.config.js'
-const PLUGIN_NAME = 'app-config'
-
-async function createAppConfigPlugin({
-  isBuild
-}: {
-  isBuild: boolean;
-}): Promise<PluginOption> {
-  let publicPath: string
-  let source: string
-  if (!isBuild) {
-    return {
-      name: PLUGIN_NAME
-    }
-  }
-  const { version = '' } = await readPackageJSON(rootPath)
-
-  return {
-    name: PLUGIN_NAME,
-    async configResolved(_config) {
-      const appTitle = _config?.env?.VITE_GLOB_APP_TITLE ?? ''
-      publicPath = _config.base
-      source = await getConfigSource(appTitle)
-    },
-    async transformIndexHtml(html) {
-      publicPath = publicPath.endsWith('/') ? publicPath : `${publicPath}/`
-
-      const appConfigSrc = `${
-        publicPath || '/'
-      }${GLOBAL_CONFIG_FILE_NAME}?v=${version}-${createContentHash(source)}`
-
-      return {
-        html,
-        tags: [
-          {
-            tag: 'script',
-            attrs: {
-              src: appConfigSrc
-            }
-          }
-        ]
-      }
-    },
-    async generateBundle() {
-      try {
-        this.emitFile({
-          type: 'asset',
-          fileName: GLOBAL_CONFIG_FILE_NAME,
-          source
-        })
-      } catch (error) {
-        console.log(
-          colors.red(`configuration file configuration file failed to package:\n${error}`)
-        )
-      }
-    }
-  }
-}
-
-/**
- * Get the configuration file variable name
- * @param env
- */
-const getVariableName = (title: string) => {
-  return `__PRODUCTION__${strToHex(title) || '__APP'}__CONF__`.toUpperCase().replace(/\s/g, '')
-}
-
-async function getConfigSource(appTitle: string) {
-  const config = await getEnvConfig()
-  const variableName = getVariableName(appTitle)
-  const windowVariable = `window.${variableName}`
-  // Ensure that the variable will not be modified
-  let source = `${windowVariable}=${JSON.stringify(config)};`
-  source += `
-    Object.freeze(${windowVariable});
-    Object.defineProperty(window, "${variableName}", {
-      configurable: false,
-      writable: false,
-    });
-  `.replace(/\s/g, '')
-  return source
-}
-
-export { createAppConfigPlugin }

package/template-gx-design-thin/build/vite/plugin/autoImport.ts

@@ -1,26 +0,0 @@
-import autoImport from 'unplugin-auto-import/vite'
-import Components from 'unplugin-vue-components/vite'
-import { AntDesignVueResolver } from 'unplugin-vue-components/resolvers'
-import { defaultSettings } from '../../../config'
-
-const importsModules = [ 'vue', 'vue-router' ] as any
-
-export function createAutoImport() {
-  const useCdnModules = defaultSettings.useCdn && defaultSettings.cdnModules.some(el => importsModules.includes(el.name))
-  return [
-    autoImport({
-      include: [
-        /\.[tj]sx?$/, // .ts, .tsx, .js, .jsx
-        /\.vue$/, /\.vue\?vue/, // .vue
-        /\.md$/ // .md
-      ],
-      imports: useCdnModules ? [] : importsModules,
-      dts: 'types/auto-imports.d.ts',
-      dirs: [ 'src/store' ]
-    }),
-    Components({
-      resolvers: [ AntDesignVueResolver({ importStyle: false, resolveIcons: true }) ],
-      dts: 'types/ant-design-import.d.ts'
-    })
-  ]
-}

package/template-gx-design-thin/build/vite/plugin/compress.ts

@@ -1,31 +0,0 @@
-import type { Plugin } from 'vite'
-
-import compressPlugin from 'vite-plugin-compression'
-
-export function configCompressPlugin(
-  compress: 'gzip' | 'brotli' | 'none',
-  deleteOriginFile = false
-): Plugin | Plugin[] {
-  const compressList = compress.split(',')
-
-  const plugins: Plugin[] = []
-
-  if (compressList.includes('gzip')) {
-    plugins.push(
-      compressPlugin({
-        ext: '.gz',
-        deleteOriginFile
-      })
-    )
-  }
-  if (compressList.includes('brotli')) {
-    plugins.push(
-      compressPlugin({
-        ext: '.br',
-        algorithm: 'brotliCompress',
-        deleteOriginFile
-      })
-    )
-  }
-  return plugins
-}

package/template-gx-design-thin/build/vite/plugin/html.ts

@@ -1,39 +0,0 @@
-import type { PluginOption } from 'vite'
-import { createHtmlPlugin } from 'vite-plugin-html'
-
-import cdnModules from '../cdn'
-import { GLOB_CONFIG_FILE_NAME } from '../../constant'
-import { defaultSettings } from '../../../config'
-import pkg from '../../../package.json'
-
-const { title, publicPath, useCdn } = defaultSettings
-
-export function configHtmlPlugin(_: ViteEnv, isBuild: boolean) {
-  const path = publicPath.endsWith('/') ? publicPath : `${publicPath}/`
-
-  const getAppConfigSrc = () => {
-    return `${path || '/'}${GLOB_CONFIG_FILE_NAME}?v=${pkg.version}-${new Date().getTime()}`
-  }
-
-  const htmlPlugin: PluginOption[] = createHtmlPlugin({
-    minify: isBuild,
-    inject: {
-      // Inject data into ejs template
-      data: {
-        VUE_APP_TITLE: title,
-        injectScript: useCdn && isBuild ? cdnModules.map(e => e.js).filter(el => el) : [],
-        injectLink: useCdn && isBuild ? cdnModules.map(e => e.css).filter(el => el) : []
-      },
-      // Embed the generated app.config.js file
-      tags: isBuild
-        ? [
-          {
-            tag: 'script',
-            attrs: { src: getAppConfigSrc() }
-          }
-        ]
-        : []
-    }
-  })
-  return htmlPlugin
-}

package/template-gx-design-thin/build/vite/plugin/index.ts

@@ -1,75 +0,0 @@
-import type { PluginOption } from 'vite'
-
-import vue from '@vitejs/plugin-vue'
-import vueJsx from '@vitejs/plugin-vue-jsx'
-import VueDevTools from 'vite-plugin-vue-devtools'
-import legacy from '@vitejs/plugin-legacy'
-
-import vueSetupExtend from 'vite-plugin-vue-setup-extend'
-
-import Unocss from 'unocss/vite'
-
-import { configPwaConfig } from './pwa'
-import { configHtmlPlugin } from './html'
-import { configMockPlugin } from './mock'
-import viteNotice from './viteNotice'
-import { createAutoImport } from './autoImport'
-import { configCompressPlugin } from './compress'
-import { createAppConfigPlugin } from './appConfig'
-import { configVisualizerConfig } from './visualizer'
-
-export async function createVitePlugins(viteEnv: ViteEnv, isBuild: boolean) {
-  const {
-    VITE_APP_ENV,
-    VITE_USE_MOCK,
-    VITE_LEGACY,
-    VITE_BUILD_COMPRESS,
-    VITE_BUILD_COMPRESS_DELETE_ORIGIN_FILE
-  } = viteEnv
-
-  const isDev = VITE_APP_ENV === 'dev'
-
-  const vitePlugins: PluginOption[] = [
-    // have to
-    vue(),
-    // have to
-    vueJsx()
-  ]
-
-  // vite-plugin-app-info
-  vitePlugins.push(await createAppConfigPlugin({ isBuild }))
-  // vite-plugin-vue-devtools
-  vitePlugins.push(VueDevTools() as any)
-  // vite-plugin-windicss
-  vitePlugins.push(Unocss())
-  // vite-plugin-vue-setup-extend
-  vitePlugins.push(vueSetupExtend())
-  // @vitejs/plugin-legacy
-  VITE_LEGACY && isBuild && vitePlugins.push(legacy())
-  // vite-plugin-html
-  vitePlugins.push(configHtmlPlugin(viteEnv, isBuild))
-  // vite-plugin-build-info
-  vitePlugins.push(await viteNotice())
-  // vite-plugin-mock
-  const useMock = isDev || VITE_USE_MOCK
-  useMock && vitePlugins.push(configMockPlugin())
-
-  // rollup-plugin-visualizer
-  vitePlugins.push(configVisualizerConfig())
-
-  // unplugin-auto-import/vite
-  vitePlugins.push(createAutoImport())
-
-  // The following plugins only work in the production environment
-  if (isBuild) {
-    // rollup-plugin-gzip
-    vitePlugins.push(
-      configCompressPlugin(VITE_BUILD_COMPRESS, VITE_BUILD_COMPRESS_DELETE_ORIGIN_FILE)
-    )
-
-    // vite-plugin-pwa
-    vitePlugins.push(configPwaConfig(viteEnv))
-  }
-
-  return vitePlugins
-}

package/template-gx-design-thin/build/vite/plugin/mock.ts

@@ -1,14 +0,0 @@
-import { viteMockServe } from './viteMock'
-
-export function configMockPlugin() {
-  return viteMockServe({
-    ignore: /^_/,
-    mockPath: 'mock',
-    enable: true,
-    injectCode: `
-      import { setupProdMockServer } from '../mock/_createProductionServer';
-
-      setupProdMockServer();
-      `,
-  })
-}

package/template-gx-design-thin/build/vite/plugin/pwa.ts

@@ -1,31 +0,0 @@
-import { VitePWA } from 'vite-plugin-pwa'
-
-import { defaultSettings } from '../../../config'
-
-export function configPwaConfig(env: ViteEnv) {
-  const { title, shortName } = defaultSettings
-  const { VITE_USE_PWA } = env
-
-  if (VITE_USE_PWA) {
-    const pwaPlugin = VitePWA({
-      manifest: {
-        name: title || 'GX Pro Admin',
-        short_name: shortName || 'gx_pro_admin',
-        icons: [
-          {
-            src: './resource/img/pwa-192x192.png',
-            sizes: '192x192',
-            type: 'image/png'
-          },
-          {
-            src: './resource/img/pwa-512x512.png',
-            sizes: '512x512',
-            type: 'image/png'
-          }
-        ]
-      }
-    })
-    return pwaPlugin
-  }
-  return []
-}

package/template-gx-design-thin/build/vite/plugin/visualizer.ts

@@ -1,14 +0,0 @@
-import { visualizer } from 'rollup-plugin-visualizer'
-import { isReportMode } from '../../util'
-
-export function configVisualizerConfig() {
-  if (isReportMode()) {
-    return visualizer({
-      filename: './node_modules/.cache/visualizer/stats.html',
-      open: true,
-      gzipSize: true,
-      brotliSize: true
-    }) as Plugin
-  }
-  return []
-}

package/template-gx-design-thin/build/vite/plugin/viteMock/client.ts

@@ -1,88 +0,0 @@
-import mockJs from 'mockjs'
-import { pathToRegexp } from 'path-to-regexp'
-
-const Mock = mockJs as any
-
-export function createProdMockServer(mockList: any[]) {
-  Mock.XHR.prototype.__send = Mock.XHR.prototype.send
-  Mock.XHR.prototype.send = function () {
-    if (this.custom.xhr) {
-      this.custom.xhr.withCredentials = this.withCredentials || false
-
-      if (this.responseType) {
-        this.custom.xhr.responseType = this.responseType
-      }
-    }
-    if (this.custom.requestHeaders) {
-      const headers: any = {}
-      for (let k in this.custom.requestHeaders) {
-        headers[k.toString().toLowerCase()] = this.custom.requestHeaders[k]
-      }
-      this.custom.options = Object.assign({}, this.custom.options, { headers })
-    }
-    this.__send.apply(this, arguments)
-  }
-
-  Mock.XHR.prototype.proxy_open = Mock.XHR.prototype.open
-
-  Mock.XHR.prototype.open = function () {
-    let responseType = this.responseType
-    this.proxy_open(...arguments)
-    if (this.custom.xhr) {
-      if (responseType) {
-        this.custom.xhr.responseType = responseType
-      }
-    }
-  }
-
-  for (const { url, method, response, timeout } of mockList) {
-    __setupMock__(timeout)
-    Mock.mock(
-      pathToRegexp(url, undefined, { end: false }),
-      method || 'get',
-      __XHR2ExpressReqWrapper__(response)
-    )
-  }
-}
-
-function __param2Obj__(url: string) {
-  const search = url.split('?')[1]
-  if (!search) {
-    return {}
-  }
-  return JSON.parse(
-    '{"' +
-    decodeURIComponent(search)
-      .replace(/"/g, '\\"')
-      .replace(/&/g, '","')
-      .replace(/=/g, '":"')
-      .replace(/\+/g, ' ') +
-    '"}'
-  )
-}
-
-function __XHR2ExpressReqWrapper__(handle: (d: any) => any) {
-  return function (options: any) {
-    let result = null
-    if (typeof handle === 'function') {
-      const { body, type, url, headers } = options
-      result = handle({
-        method: type,
-        body: JSON.parse(body),
-        query: __param2Obj__(url),
-        headers
-      })
-    } else {
-      result = handle
-    }
-
-    return Mock.mock(result)
-  }
-}
-
-function __setupMock__(timeout = 0) {
-  timeout &&
-  Mock.setup({
-    timeout
-  })
-}