valaxy 0.3.11 → 0.6.0

package/node/plugins/index.ts

@@ -0,0 +1,224 @@
+import fs from 'fs'
+
+import { join, relative } from 'path'
+import type { Plugin, ResolvedConfig } from 'vite'
+// import consola from 'consola'
+import { resolveConfig } from '../config'
+import type { ResolvedValaxyOptions, ValaxyServerOptions } from '../options'
+import { resolveImportPath, slash, toAtFS } from '../utils'
+import { createMarkdownToVueRenderFn } from '../markdown/markdownToVue'
+import type { PageDataPayload } from '../../types'
+import { checkMd } from '../markdown/check'
+import { VALAXY_CONFIG_ID } from './valaxy'
+
+/**
+ * for /@valaxyjs/styles
+ * @param roots
+ * @returns
+ */
+function generateStyles(roots: string[], options: ResolvedValaxyOptions) {
+  const imports: string[] = []
+
+  // katex
+  if (options.config.features.katex) {
+    imports.push(`import "${toAtFS(resolveImportPath('katex/dist/katex.min.css', true))}"`)
+    imports.push(`import "${join(options.clientRoot, 'styles/third/katex.scss')}"`)
+  }
+
+  for (const root of roots) {
+    const styles: string[] = []
+
+    const autoloadNames = ['index', 'css-vars']
+    autoloadNames.forEach((name) => {
+      styles.push(join(root, 'styles', `${name}.css`))
+      styles.push(join(root, 'styles', `${name}.scss`))
+    })
+
+    for (const style of styles) {
+      if (fs.existsSync(style))
+        imports.push(`import "${toAtFS(style)}"`)
+    }
+  }
+
+  return imports.join('\n')
+}
+
+function generateLocales(roots: string[]) {
+  const imports: string[] = [
+    'const messages = { "zh-CN": {}, en: {} }',
+  ]
+  const languages = ['zh-CN', 'en']
+
+  roots.forEach((root, i) => {
+    languages.forEach((lang) => {
+      const langYml = `${root}/locales/${lang}.yml`
+      if (fs.existsSync(langYml) && fs.readFileSync(langYml, 'utf-8')) {
+        const varName = lang.replace('-', '') + i
+        imports.push(`import ${varName} from "${toAtFS(langYml)}"`)
+        imports.push(`Object.assign(messages['${lang}'], ${varName})`)
+      }
+    })
+  })
+
+  imports.push('export default messages')
+  return imports.join('\n')
+}
+
+export function createValaxyPlugin(options: ResolvedValaxyOptions, serverOptions: ValaxyServerOptions = {}): Plugin {
+  const valaxyPrefix = '/@valaxy'
+
+  let valaxyConfig = options.config
+
+  const roots = [options.clientRoot, options.themeRoot, options.userRoot]
+
+  let markdownToVue: Awaited<ReturnType<typeof createMarkdownToVueRenderFn>>
+  let hasDeadLinks = false
+  let config: ResolvedConfig
+
+  return {
+    name: 'valaxy',
+    enforce: 'pre',
+
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig
+      markdownToVue = await createMarkdownToVueRenderFn(
+        options.userRoot,
+        options.config.markdownIt,
+        options.pages,
+        config.define,
+        config.command === 'build',
+        config.base,
+        options.config.lastUpdated,
+      )
+    },
+
+    configureServer(server) {
+      server.watcher.add([
+        options.configFile,
+        options.userRoot,
+        options.themeRoot,
+      ])
+    },
+
+    resolveId(id) {
+      if (id.startsWith(valaxyPrefix))
+        return id
+      return null
+    },
+
+    load(id) {
+      if (id === `/${VALAXY_CONFIG_ID}`)
+        // stringify twice for \"
+        return `export default ${JSON.stringify(JSON.stringify(valaxyConfig))}`
+
+      if (id === '/@valaxyjs/context') {
+        return `export default ${JSON.stringify(JSON.stringify({
+          userRoot: options.userRoot,
+          // clientRoot: options.clientRoot,
+        }))}`
+      }
+
+      // generate styles
+      if (id === '/@valaxyjs/styles')
+        return generateStyles(roots, options)
+
+      if (id === '/@valaxyjs/locales')
+        return generateLocales(roots)
+
+      if (id.startsWith(valaxyPrefix))
+        return ''
+    },
+
+    async transform(code, id) {
+      if (id.endsWith('.md')) {
+        checkMd(code, id)
+        code.replace('{%', '\{\%')
+        code.replace('%}', '\%\}')
+
+        // const scripts = [
+        // '<script setup>',
+        // 'import { useRoute } from "vue-router"',
+        // 'const route = useRoute()',
+        // `route.meta.headers = ${JSON.stringify(_md.__data)}`,
+        // `export const data = JSON.parse(${JSON.stringify(JSON.stringify(pageData))})`,
+        // `frontmatter.data = JSON.parse(${JSON.stringify(JSON.stringify(pageData))})`,
+        // '</script>',
+        // ]
+
+        // const li = code.lastIndexOf('</script>')
+        // code = code.slice(0, li) + scripts.join('\n') + code.slice(li + 9)
+
+        // transform .md files into vueSrc so plugin-vue can handle it
+        const { vueSrc, deadLinks, includes } = await markdownToVue(
+          code,
+          id,
+          config.publicDir,
+        )
+        if (deadLinks.length)
+          hasDeadLinks = true
+
+        if (includes.length) {
+          includes.forEach((i) => {
+            this.addWatchFile(i)
+          })
+        }
+
+        return vueSrc
+      }
+    },
+
+    renderStart() {
+      if (hasDeadLinks)
+        throw new Error('One or more pages contain dead links.')
+    },
+
+    async handleHotUpdate(ctx) {
+      // handle valaxy.config.ts hmr
+      const { file, server, read } = ctx
+      if (file !== options.configFile)
+        return
+
+      // send headers
+      if (file.endsWith('.md')) {
+        const content = await read()
+        const { pageData, vueSrc } = await markdownToVue(
+          content,
+          file,
+          join(options.userRoot, 'public'),
+        )
+
+        const path = `/${slash(relative(`${options.userRoot}/pages`, file))}`
+        const payload: PageDataPayload = {
+          // path: `/${slash(relative(srcDir, file))}`,
+          path,
+          pageData,
+        }
+
+        server.ws.send({
+          type: 'custom',
+          event: 'valaxy:pageData',
+          data: payload,
+        })
+
+        // overwrite src so vue plugin can handle the HMR
+        ctx.read = () => vueSrc
+      }
+
+      const { config } = await resolveConfig()
+
+      serverOptions.onConfigReload?.(config, options.config)
+      Object.assign(options.config, config)
+
+      // if (config.base !== options.config.base)
+      //   consola.warn('[valaxy]: config.base has changed. Please restart the dev server.')
+      valaxyConfig = config
+
+      const moduleIds = [`/${VALAXY_CONFIG_ID}`, '/@valaxyjs/context']
+      const moduleEntries = [
+        ...Array.from(moduleIds).map(id => server.moduleGraph.getModuleById(id)),
+      ].filter(<T>(item: T): item is NonNullable<T> => !!item)
+
+      return moduleEntries
+    },
+  }
+}

package/{src/node → node}/plugins/preset.ts

@@ -10,14 +10,13 @@ import Vue from '@vitejs/plugin-vue'
 import Pages from 'vite-plugin-pages'
 import Layouts from 'vite-plugin-vue-layouts'
 import Components from 'unplugin-vue-components/vite'
-import { VitePWA } from 'vite-plugin-pwa'
 import VueI18n from '@intlify/vite-plugin-vue-i18n'
 import Inspect from 'vite-plugin-inspect'
 
 import { dim, yellow } from 'kolorist'
 import type { ResolvedValaxyOptions, ValaxyServerOptions } from '../options'
 import { setupMarkdownPlugins } from '../markdown'
-import { createMarkdownPlugin, excerpt_separator } from './markdown'
+// import { createMarkdownPlugin, excerpt_separator } from './markdown'
 import { createUnocssPlugin } from './unocss'
 import { createConfigPlugin } from './extendConfig'
 import { createValaxyPlugin } from '.'
@@ -33,7 +32,7 @@ export async function ViteValaxyPlugins(
 ): Promise<(PluginOption | PluginOption[])[] | undefined> {
   const { clientRoot, themeRoot, userRoot } = options
 
-  const MarkdownPlugin = createMarkdownPlugin(options)
+  // const MarkdownPlugin = createMarkdownPlugin(options)
   const UnocssPlugin = await createUnocssPlugin(options)
 
   const ValaxyPlugin = createValaxyPlugin(options, serverOptions)
@@ -43,7 +42,7 @@ export async function ViteValaxyPlugins(
 
   const roots = [clientRoot, themeRoot, userRoot]
 
-  const { default: ThemePlugin } = await import(`valaxy-theme-${options.theme}`)
+  const { default: ThemePlugin } = (await import(`valaxy-theme-${options.theme}`))
 
   const customElements = new Set([
   // katex
@@ -91,8 +90,8 @@ export async function ViteValaxyPlugins(
       },
     }),
 
-    ValaxyPlugin,
     createConfigPlugin(options),
+    ValaxyPlugin,
 
     ThemePlugin(options.config.themeConfig),
 
@@ -119,7 +118,7 @@ export async function ViteValaxyPlugins(
         })
 
         const md = fs.readFileSync(path, 'utf-8')
-        const { data, excerpt } = matter(md, { excerpt_separator })
+        const { data, excerpt } = matter(md, { excerpt_separator: '<!-- more -->' })
 
         // warn for post frontmatter
         if (route.path.startsWith('/posts/')) {
@@ -171,36 +170,7 @@ export async function ViteValaxyPlugins(
     // UnocssPlugin,
     UnocssPlugin,
 
-    ...MarkdownPlugin,
-
-    // https://github.com/antfu/vite-plugin-pwa
-    VitePWA({
-      registerType: 'autoUpdate',
-      includeAssets: ['favicon.svg', 'safari-pinned-tab.svg'],
-      manifest: {
-        name: 'Theme Yun',
-        short_name: 'Yun',
-        theme_color: '#ffffff',
-        icons: [
-          {
-            src: '/pwa-192x192.png',
-            sizes: '192x192',
-            type: 'image/png',
-          },
-          {
-            src: '/pwa-512x512.png',
-            sizes: '512x512',
-            type: 'image/png',
-          },
-          {
-            src: '/pwa-512x512.png',
-            sizes: '512x512',
-            type: 'image/png',
-            purpose: 'any maskable',
-          },
-        ],
-      },
-    }),
+    // ...MarkdownPlugin,
 
     // https://github.com/intlify/bundle-tools/tree/main/packages/vite-plugin-vue-i18n
     VueI18n({

package/{src/node → node}/rss.ts

@@ -24,7 +24,7 @@ const markdown = MarkdownIt({
 export async function build(options: ResolvedValaxyOptions) {
   const { config } = options
 
-  if (!config.url) {
+  if (!config.url || config.url === '/') {
     consola.error('You must set "config.url" to generate rss.')
     return
   }

package/{src/node → node}/server.ts

@@ -12,10 +12,12 @@ export async function createServer(
   // default editor vscode
   process.env.EDITOR = process.env.EDITOR || 'code'
 
-  const server = await createViteServer(mergeConfig(
-    viteConfig,
-    await createViteConfig(options, serverOptions),
-  ))
+  const server = await createViteServer(
+    mergeConfig(
+      viteConfig,
+      await createViteConfig(options, serverOptions),
+    ),
+  )
 
   return server
 }

package/{src/node → node}/utils/cli.ts

@@ -7,7 +7,7 @@ import consola from 'consola'
 import type { InlineConfig, ViteDevServer } from 'vite'
 import { createServer } from '../server'
 import type { ResolvedValaxyOptions } from '../options'
-import { version } from '../../../package.json'
+import { version } from '../../package.json'
 import { createSafelist } from '../plugins/unocss'
 
 let server: ViteDevServer | undefined

package/node/utils/getGitTimestamp.ts

@@ -0,0 +1,13 @@
+import { spawn } from 'cross-spawn'
+
+export function getGitTimestamp(file: string) {
+  return new Promise<number>((resolve, reject) => {
+    const child = spawn('git', ['log', '-1', '--pretty="%ci"', file])
+    let output = ''
+    child.stdout.on('data', d => (output += String(d)))
+    child.on('close', () => {
+      resolve(+new Date(output))
+    })
+    child.on('error', reject)
+  })
+}

package/node/utils/index.ts

@@ -0,0 +1,59 @@
+import { join } from 'path'
+import isInstalledGlobally from 'is-installed-globally'
+import globalDirs from 'global-dirs'
+import { sync as resolve } from 'resolve'
+import consola from 'consola'
+
+export * from './getGitTimestamp'
+
+/**
+ * transform obj for vite cde
+ * @param obj
+ * @returns
+ */
+export const transformObject = (obj: any) => {
+  return `JSON.parse(${JSON.stringify(JSON.stringify(obj))})`
+}
+
+export function slash(str: string) {
+  return str.replace(/\\/g, '/')
+}
+
+export function ensurePrefix(prefix: string, str: string) {
+  if (!str.startsWith(prefix))
+    return prefix + str
+  return str
+}
+
+export function toAtFS(path: string) {
+  return `/@fs${ensurePrefix('/', slash(path))}`
+}
+
+export function resolveImportPath(importName: string, ensure: true): string
+export function resolveImportPath(importName: string, ensure?: boolean): string | undefined
+export function resolveImportPath(importName: string, ensure = false) {
+  try {
+    return resolve(importName, {
+      preserveSymlinks: false,
+    })
+  }
+  catch {}
+
+  if (isInstalledGlobally) {
+    try {
+      return require.resolve(join(globalDirs.yarn.packages, importName))
+    }
+    catch {}
+
+    try {
+      return require.resolve(join(globalDirs.npm.packages, importName))
+    }
+    catch {}
+  }
+
+  if (ensure)
+    throw new Error(`Failed to resolve package ${importName}`)
+
+  consola.error(`Failed to resolve package ${importName}`)
+  return undefined
+}

package/node/utils/net.ts

@@ -0,0 +1,20 @@
+import net from 'net'
+
+export async function findFreePort(start: number): Promise<number> {
+  if (await isPortFree(start))
+    return start
+  return await findFreePort(start + 1)
+}
+
+function isPortFree(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+      .listen(port, () => {
+        server.close()
+        resolve(true)
+      })
+      .on('error', () => {
+        resolve(false)
+      })
+  })
+}

package/{src/node → node}/vite.ts

@@ -1,9 +1,10 @@
-import { join } from 'path'
+import { dirname, join } from 'path'
 import type { InlineConfig } from 'vite'
 import { splitVendorChunkPlugin } from 'vite'
 import type { ResolvedValaxyOptions, ValaxyServerOptions } from './options'
 
 import { ViteValaxyPlugins } from './plugins/preset'
+import { resolveImportPath } from './utils'
 
 export type Mode = 'dev' | 'build'
 
@@ -24,6 +25,8 @@ export async function createViteConfig(options: ResolvedValaxyOptions, serverOpt
     // always string
     define: {
       __DEV__: options.mode === 'dev' ? 'true' : 'false',
+
+      __ALGOLIA__: !!options.config.search.algolia.enable,
     },
 
     root: options.clientRoot,
@@ -39,6 +42,7 @@ export async function createViteConfig(options: ResolvedValaxyOptions, serverOpt
           options.clientRoot,
           options.themeRoot,
           options.userRoot,
+          dirname(resolveImportPath('katex/package.json', true)),
         ],
       },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valaxy",
-  "version": "0.3.11",
+  "version": "0.6.0",
   "description": "📄 Vite & Vue powered static blog generator.",
   "author": {
     "email": "me@yunyoujun.cn",
@@ -16,10 +16,22 @@
     "blog"
   ],
   "exports": {
-    ".": "./src/index.ts",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./client": "./dist/client.d.ts",
+    "./client/*": "./client/*",
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "require": "./dist/node/index.js",
+      "import": "./dist/node/index.mjs"
+    },
     "./*": "./*"
   },
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "bin": {
     "vala": "./bin/valaxy.js",
@@ -29,20 +41,27 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
+    "@antfu/utils": "^0.5.2",
     "@ctrl/tinycolor": "^3.4.1",
+    "@docsearch/css": "^3.1.0",
+    "@docsearch/js": "^3.1.0",
     "@iconify-json/carbon": "^1.1.5",
     "@iconify-json/ri": "^1.1.2",
     "@intlify/vite-plugin-vue-i18n": "^3.4.0",
     "@vitejs/plugin-vue": "^2.3.3",
-    "@vueuse/core": "^8.6.0",
+    "@vueuse/core": "^8.7.4",
     "@vueuse/head": "^0.7.6",
     "consola": "^2.15.3",
     "critters": "^0.0.16",
+    "cross-spawn": "^7.0.3",
     "dayjs": "^1.11.3",
     "escape-html": "^1.0.3",
     "feed": "^4.2.2",
+    "gray-matter": "^4.0.3",
     "katex": "^0.16.0",
     "kolorist": "^1.5.1",
+    "lru-cache": "^7.10.1",
+    "markdown-it": "^13.0.1",
     "markdown-it-anchor": "^8.6.4",
     "markdown-it-attrs": "^4.1.4",
     "markdown-it-container": "^3.0.0",
@@ -55,37 +74,38 @@
     "pinia": "^2.0.14",
     "prism-theme-vars": "^0.2.3",
     "prismjs": "^1.28.0",
-    "sass": "^1.52.2",
+    "sass": "^1.52.3",
+    "shiki": "^0.10.1",
     "star-markdown-css": "^0.3.3",
     "unconfig": "^0.3.4",
-    "unocss": "^0.38.0",
+    "unocss": "^0.39.3",
     "unplugin-vue-components": "^0.19.6",
-    "vite": "^2.9.10",
+    "vite": "^2.9.12",
     "vite-plugin-inspect": "^0.5.0",
-    "vite-plugin-md": "^0.13.1",
-    "vite-plugin-pages": "^0.23.0",
-    "vite-plugin-pwa": "^0.12.0",
+    "vite-plugin-pages": "^0.24.2",
     "vite-plugin-vue-layouts": "^0.6.0",
-    "vite-ssg": "0.20.1",
+    "vite-ssg": "0.19.2",
     "vite-ssg-sitemap": "0.2.7",
     "vue": "^3.2.37",
     "vue-i18n": "^9.1.10",
-    "vue-router": "^4.0.15",
+    "vue-router": "^4.0.16",
     "yargs": "^17.5.1"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.2",
     "@types/katex": "^0.14.0",
+    "@types/lru-cache": "^7.10.10",
     "@types/markdown-it-link-attributes": "^3.0.1",
     "@types/nprogress": "^0.2.0",
     "@types/yargs": "^17.0.10",
     "debug": "^4.3.4",
     "diacritics": "^1.3.0",
     "https-localhost": "^4.7.1",
-    "type-fest": "^2.13.0"
+    "type-fest": "^2.13.1"
   },
   "scripts": {
     "build": "rimraf dist && tsup --splitting",
-    "dev": "tsup --watch --splitting",
+    "dev": "tsup --splitting --watch",
     "lint": "eslint \"**/*.{vue,ts,js}\"",
     "preview": "vite preview",
     "preview-https": "serve dist"

package/shared/index.ts

@@ -0,0 +1 @@
+export const EXTERNAL_URL_RE = /^https?:/i

package/tsup.config.ts

@@ -3,19 +3,22 @@ import { defineConfig } from 'tsup'
 export default defineConfig((options) => {
   return {
     entry: [
-      'src/index.ts',
-      'src/node/index.ts',
-      'src/node/cli.ts',
+      'index.ts',
+      // 'client/index.ts',
+      'node/index.ts',
+      'node/cli.ts',
+      // 'types/index.ts',
     ],
     // https://tsup.egoist.sh/#code-splitting
     // Code splitting currently only works with the esm output format, and it's enabled by default. If you want code splitting for cjs output format as well, try using --splitting flag which is an experimental feature to get rid of the limitation in esbuild.
-    splitting: true,
+    // splitting: true,
     clean: true,
     dts: true,
     format: ['cjs', 'esm'],
     minify: !options.watch,
     external: [
       '@valaxyjs/config',
+      '@valaxyjs/context',
       'valaxy-theme-yun',
     ],
   }