feat(build): replace gulp static pipeline with vite

scripts/static-pipeline.mjs

@@ -0,0 +1,158 @@
+import { execFileSync } from 'node:child_process'
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const staticDir = path.join(rootDir, 'static')
+
+const staticCleanKeep = new Set([
+  'entitlements.plist',
+  'node_modules',
+  'package.json',
+  'pnpm-lock.yaml',
+])
+
+function run(command, args, options = {}) {
+  execFileSync(command, args, {
+    cwd: options.cwd ?? rootDir,
+    env: { ...process.env, ...(options.env ?? {}) },
+    shell: process.platform === 'win32',
+    stdio: 'inherit',
+  })
+}
+
+function clean() {
+  mkdirSync(staticDir, { recursive: true })
+
+  for (const entry of readdirSync(staticDir)) {
+    if (staticCleanKeep.has(entry)) {
+      continue
+    }
+
+    rmSync(path.join(staticDir, entry), {
+      recursive: true,
+      force: true,
+      maxRetries: 10,
+      retryDelay: 100,
+    })
+  }
+}
+
+function ensureStaticNodeModules() {
+  if (!existsSync(path.join(staticDir, 'node_modules'))) {
+    run('pnpm', ['install', '--frozen-lockfile'], { cwd: staticDir })
+  }
+}
+
+function electron() {
+  ensureStaticNodeModules()
+  run('pnpm', ['electron:dev'], { cwd: staticDir })
+}
+
+function versionFromSource() {
+  const versionSource = readFileSync(path.join(rootDir, 'src/main/frontend/version.cljs'), 'utf8')
+  const match = versionSource.match(/[0-9.]{3,}/)
+
+  if (!match) {
+    throw new Error('release version error in src/**/*/version.cljs')
+  }
+
+  return match[0]
+}
+
+function electronMaker() {
+  run('pnpm', ['cljs:release-electron'])
+  run('pnpm', ['vite:workers-build'])
+
+  const packagePath = path.join(staticDir, 'package.json')
+  const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'))
+  packageJson.version = versionFromSource()
+  writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`)
+
+  ensureStaticNodeModules()
+  run('pnpm', ['electron:make'], { cwd: staticDir })
+}
+
+function syncWorkersToMobile() {
+  const source = path.join(staticDir, 'js', 'db-worker.js')
+  const dest = path.join(staticDir, 'mobile', 'js', 'db-worker.js')
+
+  if (!existsSync(source)) {
+    throw new Error(`Missing worker output: ${source}`)
+  }
+
+  mkdirSync(path.dirname(dest), { recursive: true })
+  copyFileSync(source, dest)
+}
+
+function switchReactDevelopmentMode() {
+  const pairs = [
+    ['react.development.js', 'react.production.min.js'],
+    ['react-dom.development.js', 'react-dom.production.min.js'],
+  ]
+
+  for (const [fromName, toName] of pairs) {
+    const from = path.join(staticDir, 'js', fromName)
+    const to = path.join(staticDir, 'js', toName)
+
+    if (!existsSync(from)) {
+      continue
+    }
+
+    rmSync(to, { force: true })
+    renameSync(from, to)
+  }
+}
+
+async function cap() {
+  const mode = process.env.PLATFORM || 'ios'
+  const logseqAppServerUrl = 'http://localhost:3002'
+
+  if (typeof global.fetch === 'function') {
+    try {
+      await fetch(logseqAppServerUrl)
+    } catch {
+      throw new Error(`Please check if the service is ON. (${logseqAppServerUrl})`)
+    }
+  }
+
+  process.stdout.write(`------ Cap ${mode.toUpperCase()} -----\n`)
+  process.stdout.write(`Dev serve at: ${logseqAppServerUrl}\n`)
+  process.stdout.write('--------------------------------------\n')
+
+  run('pnpm', ['exec', 'cap', 'sync', mode], {
+    env: { LOGSEQ_APP_SERVER_URL: logseqAppServerUrl },
+  })
+  rmSync(path.join(rootDir, 'ios/App/App/public/out'), { recursive: true, force: true })
+  run('pnpm', ['exec', 'cap', 'run', mode], {
+    env: { LOGSEQ_APP_SERVER_URL: logseqAppServerUrl },
+  })
+}
+
+const tasks = {
+  cap,
+  clean,
+  electron,
+  'electron-maker': electronMaker,
+  'switch-react-development-mode': switchReactDevelopmentMode,
+  'sync-workers-to-mobile': syncWorkersToMobile,
+}
+
+const taskName = process.argv[2]
+const task = tasks[taskName]
+
+if (!task) {
+  throw new Error(`Unknown static pipeline task: ${taskName}`)
+}
+
+await task()