@qse/edu-scripts 0.0.0-beta.0

package/src/cli.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import './utils/beforeStart.js'
+
+import fs from 'fs-extra'
+import yargs from 'yargs'
+import { fileURLToPath } from 'node:url'
+
+import start from './start.js'
+import build from './build.js'
+import deploy from './deploy.js'
+import autoRefactor from './auto-refactor.js'
+import commitDist from './commit-dist.js'
+import * as generator from './generator.js'
+
+const pkg = fs.readJsonSync(fileURLToPath(import.meta.resolve('../package.json')))
+
+yargs(process.argv.slice(2))
+  .usage(`教育工程化 webpack5 基础框架\n文档: ${pkg.homepage}`)
+  .command(
+    'start',
+    '开发',
+    (yargs) => yargs.option('port', { alias: 'p', desc: '指定端口' }),
+    (args) => start(args)
+  )
+  .command(
+    'build',
+    '打包',
+    (yargs) =>
+      yargs
+        .option('analyze', {
+          alias: 'a',
+          desc: '分析代码',
+          default: false,
+          boolean: true,
+        })
+        .option('output-html', {
+          alias: 'o',
+          desc: '输出 html 文件',
+          default: false,
+          boolean: true,
+        }),
+    (args) => build(args)
+  )
+  .command(
+    'deploy',
+    '自动部署 dist 到 v1 服务器',
+    (yargs) =>
+      yargs
+        .option('school', { alias: 's', desc: '上传到校端', default: false, boolean: true })
+        .option('bureau', { alias: 'b', desc: '上传到局端', default: false, boolean: true })
+        .option('documentshelves', {
+          alias: 'd',
+          desc: '上传到公文',
+          default: false,
+          boolean: true,
+        })
+        .option('compositionshelves', {
+          alias: 'c',
+          desc: '上传到文曲智阅',
+          default: false,
+          boolean: true,
+        })
+        .option('compositionshelves-dingtalk', {
+          alias: 'cd',
+          desc: '上传到文曲智阅(钉钉一方化)',
+          default: false,
+          boolean: true,
+        }),
+    (args) => deploy(args)
+  )
+  .command(['generator', 'g'], '自动生成代码', (yargs) =>
+    yargs
+      .command('override', '创建 override 文件', {}, (args) => generator.override(args))
+      .command('tailwind', '创建 tailwind 文件', {}, (args) => generator.tailwind(args))
+      .command('ts', '创建 tsconfig 文件', {}, (args) => generator.ts(args))
+      .showHelpOnFail(true)
+      .demandCommand(1, '')
+  )
+  .command('auto-refactor', '自动改造项目', {}, () => autoRefactor())
+  .command(
+    'commit-dist',
+    '提交 dist 目录到 dist 分支',
+    (yargs) => yargs.option('rm-local', { desc: '提交完后删除本地 dist', type: 'boolean' }),
+    (args) => commitDist(args)
+  )
+  .showHelpOnFail(true)
+  .demandCommand(1, '')
+  .alias({ v: 'version', h: 'help' }).argv

package/src/commit-dist.js

@@ -0,0 +1,103 @@
+import chalk from 'chalk'
+import paths from './config/paths.js'
+import fs from 'fs-extra'
+import cp from 'child_process'
+import tmp from 'tmp'
+
+const exec = (cmd, opts) => cp.execSync(cmd, { encoding: 'utf-8', stdio: 'pipe', ...opts })
+
+function validateSVNRoot(root) {
+  const ls = exec(`svn ls ${root}`)
+  return ['trunk', 'branches'].every((s) => ls.includes(s))
+}
+
+function getWorkingCopyInfo() {
+  exec(`svn up`)
+  const url = exec(`svn info --show-item url`).trim()
+  const revision = exec(`svn info --show-item last-changed-revision`).trim()
+  const author = exec(`svn info --show-item last-changed-author`).trim()
+
+  let branch = 'trunk'
+  let root = url.replace(/\/trunk$/, '')
+  if (url.includes('/branches/')) {
+    branch = url.split('/').pop()
+    root = url.replace(/\/branches\/[^/]+$/, '')
+  }
+  let distBranchURL = root + '/branches/dist'
+  let distBranchDirURL = distBranchURL + '/' + branch
+  if (!validateSVNRoot(root)) {
+    console.log(chalk.red('SVN目录不符合规则，必须包含 trunk branches'))
+    process.exit(1)
+  }
+
+  return { url, branch, revision, author, distBranchURL, distBranchDirURL, root }
+}
+
+function copyDistToRepo(info) {
+  const tmpdir = tmp.dirSync().name
+
+  try {
+    exec(`svn ls ${info.distBranchDirURL} --depth empty`)
+  } catch (error) {
+    if (error.message.includes('non-existent')) {
+      exec(
+        `svn mkdir ${info.distBranchDirURL} --parents -m "[edu-scripts] create ${info.branch} dist"`
+      )
+    } else {
+      throw error
+    }
+  }
+  exec(`svn co ${info.distBranchDirURL} ${tmpdir}`)
+
+  try {
+    exec(`svn rm * --force -q`, { cwd: tmpdir })
+  } catch (error) {}
+
+  fs.copySync(paths.dist, tmpdir)
+
+  exec(`svn add * --force --auto-props --parents --depth infinity -q`, { cwd: tmpdir })
+
+  const msg = `[edu-scripts] commit ${info.branch} dist #${info.revision} @${info.author}`
+  exec(`svn ci -m "${msg}"`, { cwd: tmpdir })
+
+  fs.removeSync(tmpdir)
+}
+
+/**
+ * svn commit dist folder to dish branches
+ *
+ * @param {Object} args
+ * @param {boolean} args.rmLocal
+ */
+export default async function commitDist(args) {
+  if (!fs.existsSync(paths.dist)) {
+    console.log(chalk.red('未找到 dist 文件夹，请先 edu-scpirts build'))
+    process.exit(1)
+  }
+
+  if (exec('svn st').trim().length) {
+    console.log(chalk.red('似乎存在未提交的代码，请提交后重试。运行 svn st 查看具体信息'))
+    process.exit(1)
+  }
+
+  const info = getWorkingCopyInfo()
+
+  console.log(
+    chalk.green(
+      [
+        `分支: ${info.branch}`,
+        `版本: ${info.revision}`,
+        `作者: ${info.author}`,
+        `地址: ${info.distBranchDirURL}`,
+      ].join('\n')
+    )
+  )
+
+  copyDistToRepo(info)
+
+  if (args.rmLocal) {
+    fs.removeSync(paths.dist)
+  }
+
+  console.log(chalk.green('提交完成'))
+}

package/src/config/paths.js

@@ -0,0 +1,38 @@
+import path from 'path'
+import fs from 'fs-extra'
+import { globbySync } from 'globby'
+
+function resolveApp(...filePath) {
+  return path.resolve(process.cwd(), ...filePath)
+}
+
+function getExistPath(...paths) {
+  for (const path of paths) {
+    if (fs.existsSync(path)) {
+      return path
+    }
+  }
+  return paths[0]
+}
+
+const paths = {
+  resolveApp,
+  eduAppEnv: resolveApp('src', 'edu-app-env.d.ts'),
+  dist: resolveApp('dist'),
+  sshSftp: resolveApp('.sftprc.json'),
+  nodeModules: resolveApp('node_modules'),
+  tsconfig: resolveApp('tsconfig.json'),
+  jsconfig: resolveApp('jsconfig.json'),
+  package: resolveApp('package.json'),
+  tailwind: resolveApp('tailwind.config.js'),
+  indexJS: resolveApp('src', 'index.js'),
+  pages: resolveApp('src', 'pages'),
+  override: resolveApp('edu-scripts.override.js'),
+  indexHTML: globbySync('./public/*.html', { absolute: true }),
+  src: resolveApp('src'),
+  public: resolveApp('public'),
+  static: resolveApp('public', 'static'),
+  theme: getExistPath(resolveApp('theme.json'), resolveApp('theme.js')),
+  mock: resolveApp('mock'),
+}
+export default paths

package/src/config/plugins/mock-server/defineMock.ts

@@ -0,0 +1,12 @@
+import type { RequestHandler } from 'express'
+type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE'
+type API = string
+
+export type MockConfig = Record<
+  `${Method} ${API}`,
+  string | number | null | undefined | boolean | Record<string, any> | RequestHandler
+>
+
+export function defineMock(config: MockConfig) {
+  return config
+}

package/src/config/plugins/mock-server/index.js

@@ -0,0 +1,150 @@
+import paths from '../../paths.js'
+import { globbySync } from 'globby'
+import chokidar from 'chokidar'
+import { debounce, memoize } from 'lodash-es'
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import express from 'express'
+import cookieParser from 'cookie-parser'
+import multer from 'multer'
+import { pathToRegexp } from 'path-to-regexp'
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const { register } = require('@swc-node/register/register')
+
+/**
+ * @type {Record<string,{handler:any;method:string;path:string}>}
+ */
+let mockCache = {}
+let isSetup = false
+
+const setupMock = debounce(function setupMock() {
+  // clean
+  mockCache = {}
+
+  const files = globbySync(paths.mock, { expandDirectories: { extensions: ['js', 'ts'] } })
+
+  if (isSetup) {
+    console.log(chalk.green('Mock files changed, reloaded'))
+  } else {
+    isSetup = true
+  }
+
+  // setup
+  for (const file of files) {
+    delete require.cache[require.resolve(file)]
+    try {
+      let mock = require(file)
+      mock = mock.default || mock
+
+      for (const key in mock) {
+        const [method, path] = key.split(' ')
+        mockCache[key] = { method, path, handler: mock[key] }
+      }
+    } catch (e) {
+      console.error(chalk.red(`Mock file ${file} error: ${e.message}`))
+    }
+  }
+}, 100)
+
+const getPathReAndKeys = memoize((path) => {
+  const keys = []
+  const re = pathToRegexp(path, keys)
+  return { re, keys }
+})
+
+function decodeParam(val) {
+  if (typeof val !== 'string' || val.length === 0) {
+    return val
+  }
+  try {
+    return decodeURIComponent(val)
+  } catch (err) {
+    if (err instanceof URIError) {
+      err.message = `Failed to decode param ' ${val} '`
+      // @ts-ignore
+      err.status = 400
+      // @ts-ignore
+      err.statusCode = 400
+    }
+    throw err
+  }
+}
+
+/**
+ * @type {import('express').RequestHandler}
+ */
+function mockMiddlewave(req, res, next) {
+  const { method, path } = req
+  for (const key in mockCache) {
+    const mock = mockCache[key]
+    if (mock.method !== method) continue
+    const { keys, re } = getPathReAndKeys(mock.path)
+    const m = re.exec(path)
+    if (m) {
+      console.log(chalk.green(`Mock: ${key}`))
+      res.setHeader('X-Mock', key)
+
+      if (typeof mock.handler === 'function') {
+        const params = {}
+        for (let i = 1; i < m.length; i += 1) {
+          const key = keys[i - 1]
+          const prop = key.name
+          const val = decodeParam(m[i])
+          if (val !== undefined) {
+            params[prop] = val
+          }
+        }
+        req.params = params
+
+        const middelwaves = [
+          express.urlencoded({ limit: '5mb', extended: true }),
+          express.json({ limit: '5mb', strict: false }),
+          multer().any(),
+          cookieParser(),
+          mock.handler,
+        ]
+
+        const throwNext = () => {
+          console.log(chalk.red(`Mock: ${key} don't use next()`))
+          res.sendStatus(500)
+        }
+
+        const mwNext = () => {
+          const middelwave = middelwaves.shift()
+          middelwave(req, res, middelwaves.length ? mwNext : throwNext)
+        }
+        mwNext()
+      } else {
+        res.json(mock.handler)
+      }
+      return
+    }
+  }
+  next()
+}
+
+/**
+ * @param {import('webpack-dev-server').Middleware[]} middelwaves
+ * @param {import('webpack-dev-server')} devServer
+ */
+function setupMockServer(middelwaves, devServer) {
+  if (!fs.existsSync(paths.mock)) return
+
+  register()
+
+  middelwaves.unshift({
+    name: 'edu-scripts-mock-middelwave',
+    middleware: mockMiddlewave,
+  })
+
+  console.log(
+    `<i> ${chalk.green.bold('[edu-scripts] Mock server created:')} ${chalk.cyan.bold(paths.mock)}`
+  )
+
+  chokidar.watch(paths.mock).on('all', setupMock)
+
+  return middelwaves
+}
+
+export default setupMockServer

package/src/config/plugins/postcss-safe-area.js

@@ -0,0 +1,21 @@
+const vars = [
+  'safe-area-inset-top',
+  'safe-area-inset-bottom',
+  'safe-area-inset-left',
+  'safe-area-inset-right',
+]
+
+const expr = new RegExp(`env\\(\\s*(${vars.join('|')})\\s*,?\\s*([^)]+)?\\s*\\)`, 'g')
+
+/** @type {import('postcss').PluginCreator} */
+export default () => {
+  return {
+    postcssPlugin: 'postcss-safe-area',
+    Declaration(decl) {
+      const fallback = decl.value.replace(expr, (match, param, defaultValue) => defaultValue || '0')
+      if (fallback !== decl.value) {
+        decl.cloneBefore({ value: fallback })
+      }
+    },
+  }
+}

package/src/config/plugins/ws-utils-createSocketURL.js

@@ -0,0 +1,140 @@
+/* eslint-disable no-restricted-globals */
+
+/**
+ * @param {{ protocol?: string, auth?: string, hostname?: string, port?: string, pathname?: string, search?: string, hash?: string, slashes?: boolean }} objURL
+ * @returns {string}
+ */
+function format(objURL) {
+  var protocol = objURL.protocol || ''
+  if (protocol && protocol.substr(-1) !== ':') {
+    protocol += ':'
+  }
+  var auth = objURL.auth || ''
+  if (auth) {
+    auth = encodeURIComponent(auth)
+    auth = auth.replace(/%3A/i, ':')
+    auth += '@'
+  }
+  var host = ''
+  if (objURL.hostname) {
+    host =
+      auth +
+      (objURL.hostname.indexOf(':') === -1 ? objURL.hostname : '['.concat(objURL.hostname, ']'))
+    if (objURL.port) {
+      host += ':'.concat(objURL.port)
+    }
+  }
+  var pathname = objURL.pathname || ''
+  if (objURL.slashes) {
+    host = '//'.concat(host || '')
+    if (pathname && pathname.charAt(0) !== '/') {
+      pathname = '/'.concat(pathname)
+    }
+  } else if (!host) {
+    host = ''
+  }
+  var search = objURL.search || ''
+  if (search && search.charAt(0) !== '?') {
+    search = '?'.concat(search)
+  }
+  var hash = objURL.hash || ''
+  if (hash && hash.charAt(0) !== '#') {
+    hash = '#'.concat(hash)
+  }
+  pathname = pathname.replace(
+    /[?#]/g,
+    /**
+     * @param {string} match
+     * @returns {string}
+     */
+    function (match) {
+      return encodeURIComponent(match)
+    }
+  )
+  search = search.replace('#', '%23')
+  return ''.concat(protocol).concat(host).concat(pathname).concat(search).concat(hash)
+}
+
+/**
+ * @param {URL & { fromCurrentScript?: boolean }} parsedURL
+ * @returns {string}
+ */
+function createSocketURL(parsedURL) {
+  var hostname = parsedURL.hostname
+
+  // Node.js module parses it as `::`
+  // `new URL(urlString, [baseURLString])` parses it as '[::]'
+  var isInAddrAny = hostname === '0.0.0.0' || hostname === '::' || hostname === '[::]'
+
+  // why do we need this check?
+  // hostname n/a for file protocol (example, when using electron, ionic)
+  // see: https://github.com/webpack/webpack-dev-server/pull/384
+  if (isInAddrAny && self.location.hostname && self.location.protocol.indexOf('http') === 0) {
+    hostname = self.location.hostname
+  }
+  var socketURLProtocol = parsedURL.protocol || self.location.protocol
+
+  // When https is used in the app, secure web sockets are always necessary because the browser doesn't accept non-secure web sockets.
+  if (
+    socketURLProtocol === 'auto:' ||
+    (hostname && isInAddrAny && self.location.protocol === 'https:')
+  ) {
+    socketURLProtocol = self.location.protocol
+  }
+  socketURLProtocol = socketURLProtocol.replace(/^(?:http|.+-extension|file)/i, 'ws')
+  var socketURLAuth = ''
+
+  // `new URL(urlString, [baseURLstring])` doesn't have `auth` property
+  // Parse authentication credentials in case we need them
+  if (parsedURL.username) {
+    socketURLAuth = parsedURL.username
+
+    // Since HTTP basic authentication does not allow empty username,
+    // we only include password if the username is not empty.
+    if (parsedURL.password) {
+      // Result: <username>:<password>
+      socketURLAuth = socketURLAuth.concat(':', parsedURL.password)
+    }
+  }
+
+  // In case the host is a raw IPv6 address, it can be enclosed in
+  // the brackets as the brackets are needed in the final URL string.
+  // Need to remove those as url.format blindly adds its own set of brackets
+  // if the host string contains colons. That would lead to non-working
+  // double brackets (e.g. [[::]]) host
+  //
+  // All of these web socket url params are optionally passed in through resourceQuery,
+  // so we need to fall back to the default if they are not provided
+  var socketURLHostname = (hostname || self.location.hostname || 'localhost').replace(
+    /^\[(.*)\]$/,
+    '$1'
+  )
+  var socketURLPort = parsedURL.port
+  if (!socketURLPort || socketURLPort === '0') {
+    socketURLPort = self.location.port
+  }
+
+  // If path is provided it'll be passed in via the resourceQuery as a
+  // query param so it has to be parsed out of the querystring in order for the
+  // client to open the socket to the correct location.
+  var socketURLPathname = '/ws'
+  if (parsedURL.pathname && !parsedURL.fromCurrentScript) {
+    socketURLPathname = parsedURL.pathname
+
+    if (hostname.indexOf('zhidianbao.cn') > -1 || hostname.indexOf('qsban.cn') > -1) {
+      var ctx = self.location.pathname.split('/')[1]
+      if (ctx) {
+        socketURLPathname = '/' + ctx + socketURLPathname
+      }
+    }
+  }
+  return format({
+    protocol: socketURLProtocol,
+    auth: socketURLAuth,
+    hostname: socketURLHostname,
+    port: socketURLPort,
+    pathname: socketURLPathname,
+    slashes: true,
+  })
+}
+export default createSocketURL