valaxy 0.6.2 → 0.7.1

package/node/plugins/extendConfig.ts

@@ -1,46 +0,0 @@
-import { resolve } from 'path'
-import type { InlineConfig, Plugin } from 'vite'
-import { mergeConfig } from 'vite'
-import type { ResolvedValaxyOptions } from '../options'
-import { toAtFS } from '../utils'
-
-export function createConfigPlugin(options: ResolvedValaxyOptions): Plugin {
-  return {
-    name: 'valaxy:config',
-    config(config) {
-      const injection: InlineConfig = {
-        resolve: {
-          alias: {
-            '@/': `${toAtFS(options.userRoot)}/`,
-            '~/': `${toAtFS(options.clientRoot)}/`,
-            'valaxy/client': `${toAtFS(options.clientRoot)}/`,
-            'valaxy': toAtFS(resolve(options.clientRoot, 'index.ts')),
-            '@valaxyjs/client': `${toAtFS(options.clientRoot)}/`,
-            '@valaxyjs/config': '/@valaxyjs/config',
-            '@valaxyjs/context': '/@valaxyjs/context',
-            'valaxy/package.json': toAtFS(resolve(options.clientRoot, '../../package.json')),
-            [`valaxy-theme-${options.theme}/`]: `${toAtFS(resolve(options.themeRoot))}/`,
-            [`valaxy-theme-${options.theme}`]: `${toAtFS(resolve(options.themeRoot))}/index.ts`,
-          },
-        },
-
-        optimizeDeps: {
-          entries: [resolve(options.clientRoot, 'main.ts'), options.configFile],
-
-          // must need it
-          include: [
-            'vue',
-            'vue-router',
-            '@vueuse/core',
-            '@vueuse/head',
-            'dayjs',
-            'nprogress',
-          ],
-
-          exclude: ['@docsearch/js'],
-        },
-      }
-      return mergeConfig(config, injection)
-    },
-  }
-}

package/node/plugins/index.ts

@@ -1,224 +0,0 @@
-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 "${toAtFS(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/node/plugins/preset.ts

@@ -1,186 +0,0 @@
-import fs from 'fs'
-import type { PluginOption } from 'vite'
-
-import consola from 'consola'
-
-import MarkdownIt from 'markdown-it'
-import matter from 'gray-matter'
-
-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 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 { createUnocssPlugin } from './unocss'
-import { createConfigPlugin } from './extendConfig'
-import { createValaxyPlugin } from '.'
-
-export interface ValaxyPluginOptions {
-  components?: Parameters<typeof Components>[0]
-}
-
-export async function ViteValaxyPlugins(
-  options: ResolvedValaxyOptions,
-  serverOptions: ValaxyServerOptions = {},
-  pluginOptions: ValaxyPluginOptions = {},
-): Promise<(PluginOption | PluginOption[])[] | undefined> {
-  const { clientRoot, themeRoot, userRoot } = options
-
-  // const MarkdownPlugin = createMarkdownPlugin(options)
-  const UnocssPlugin = await createUnocssPlugin(options)
-
-  const ValaxyPlugin = createValaxyPlugin(options, serverOptions)
-
-  const mdIt = new MarkdownIt({ html: true })
-  await setupMarkdownPlugins(mdIt, options.config.markdownIt)
-
-  const roots = [clientRoot, themeRoot, userRoot]
-
-  const { default: ThemePlugin } = (await import(`valaxy-theme-${options.theme}`))
-
-  const customElements = new Set([
-  // katex
-    'annotation',
-    'math',
-    'menclose',
-    'mfrac',
-    'mglyph',
-    'mi',
-    'mlabeledtr',
-    'mn',
-    'mo',
-    'mover',
-    'mpadded',
-    'mphantom',
-    'mroot',
-    'mrow',
-    'mspace',
-    'msqrt',
-    'mstyle',
-    'msub',
-    'msubsup',
-    'msup',
-    'mtable',
-    'mtd',
-    'mtext',
-    'mtr',
-    'munder',
-    'munderover',
-    'semantics',
-
-    // meting
-    'meting-js',
-  ])
-
-  return [
-    Vue({
-      include: [/\.vue$/, /\.md$/],
-      template: {
-        compilerOptions: {
-          isCustomElement: (tag) => {
-            return customElements.has(tag)
-          },
-        },
-      },
-    }),
-
-    createConfigPlugin(options),
-    ValaxyPlugin,
-
-    ThemePlugin(options.config.themeConfig),
-
-    // https://github.com/hannoeru/vite-plugin-pages
-    Pages({
-      extensions: ['vue', 'md'],
-      dirs: roots.map(root => `${root}/pages`),
-      /**
-       * we need get frontmatter before route, so write it in Pages.extendRoute
-       */
-      extendRoute(route) {
-        let path = route.component
-        if (!route.meta)
-          route.meta = {}
-
-        // add default layout for home, can be overrode
-        if (route.path === '/')
-          route.meta.layout = 'home'
-
-        roots.forEach((root) => {
-          const pagePath = root + route.component
-          if (fs.existsSync(pagePath))
-            path = pagePath
-        })
-
-        const md = fs.readFileSync(path, 'utf-8')
-        const { data, excerpt } = matter(md, { excerpt_separator: '<!-- more -->' })
-
-        // warn for post frontmatter
-        if (route.path.startsWith('/posts/')) {
-          route.meta.layout = 'post'
-          if (!data.date)
-            consola.warn(`You forgot to write ${yellow('date')} for post: ${dim(`${route.component}`)}`)
-        }
-
-        route.meta = Object.assign(route.meta, {
-          frontmatter: Object.assign({ date: new Date() }, data),
-          excerpt: excerpt ? mdIt.render(excerpt) : '',
-        })
-
-        // set default updated
-        if (route.meta.frontmatter.updated)
-          route.meta.frontmatter.updated = route.meta.frontmatter.date
-
-        // set layout
-        if (data.layout)
-          route.meta.layout = data.layout
-
-        return route
-      },
-    }),
-    // https://github.com/JohnCampionJr/vite-plugin-vue-layouts
-    Layouts({
-      layoutsDirs: roots.map(root => `${root}/layouts`),
-    }),
-
-    // https://github.com/antfu/unplugin-vue-components
-    Components({
-      extensions: ['vue', 'md'],
-
-      // allow auto import and register components used in markdown
-      include: [/\.vue$/, /\.vue\?vue/, /\.md$/],
-      exclude: [],
-
-      // allow override
-      allowOverrides: true,
-      // override: user -> theme -> client
-      // latter override former
-      dirs: roots.map(root => `${root}/components`).concat(roots.map(root => `${root}/layouts`)).concat(['src/components', 'components']),
-      dts: `${options.userRoot}/components.d.ts`,
-
-      ...pluginOptions,
-    }),
-
-    // https://github.com/antfu/unocss
-    // UnocssPlugin,
-    UnocssPlugin,
-
-    // ...MarkdownPlugin,
-
-    // https://github.com/intlify/bundle-tools/tree/main/packages/vite-plugin-vue-i18n
-    VueI18n({
-      runtimeOnly: true,
-      compositionOnly: true,
-      include: roots.map(root => `${root}/locales/**`),
-    }),
-
-    // https://github.com/antfu/vite-plugin-inspect
-    // Visit http://localhost:3333/__inspect/ to see the inspector
-    options.mode === 'dev' && Inspect(),
-  ]
-}

package/node/plugins/unocss.ts

@@ -1,110 +0,0 @@
-import defu from 'defu'
-import type { VitePluginConfig } from 'unocss/vite'
-import Unocss from 'unocss/vite'
-
-import {
-  presetAttributify,
-  presetIcons,
-  presetTypography,
-  presetUno,
-  presetWebFonts,
-  transformerDirectives,
-  transformerVariantGroup,
-} from 'unocss'
-import type { ValaxyConfig } from 'valaxy'
-import type { ThemeUserConfig } from 'valaxy-theme-yun'
-import type { ResolvedValaxyOptions } from '../options'
-
-export const createSafelist = async (config: ValaxyConfig<ThemeUserConfig>) => {
-  const { generateSafelist } = await import(`valaxy-theme-${config.theme}`)
-
-  const safeIcons: string[] = [
-    'i-ri-archive-line',
-    'i-ri-folder-2-line',
-    'i-ri-price-tag-3-line',
-
-    'i-ri-cloud-line',
-  ]
-
-  let themeSafelist: string[] = []
-  if (typeof generateSafelist === 'function')
-    themeSafelist = generateSafelist(config.themeConfig)
-
-  const safelist = 'animate-fade-in m-auto text-left'.split(' ').concat([
-    'rotate-y-180',
-  ]).concat(safeIcons).concat(themeSafelist)
-
-  // generate icon safelist
-  if (config.social.length)
-    config.social.forEach(item => safelist.push(item.icon))
-
-  // sponsor icon
-  if (config.sponsor.methods.length)
-    config.sponsor.methods.forEach(item => safelist.push(item.icon))
-
-  return safelist
-}
-
-export const createUnocssConfig = async (options: ResolvedValaxyOptions) => {
-  const unocssConfig: VitePluginConfig = {
-    shortcuts: [
-      ['yun-main', 'lt-md:pl-0'],
-      ['yun-card', 'transition yun-transition shadow hover:shadow-lg'],
-      ['btn', 'px-4 py-1 rounded inline-block bg-sky-600 text-white cursor-pointer hover:bg-sky-700 disabled:cursor-default disabled:bg-gray-600 disabled:opacity-50'],
-      ['icon-btn', 'inline-block cursor-pointer select-none opacity-75 transition duration-200 ease-in-out hover:opacity-100 hover:text-sky-600'],
-      ['va-card', 'shadow hover:shadow-lg'],
-    ],
-    presets: [
-      presetUno(),
-      presetAttributify(),
-      presetIcons({
-        scale: 1.2,
-        // warn: true,
-      }),
-      presetTypography(),
-      // todo, add unocss config it
-      presetWebFonts({
-        fonts: {
-          serif: [
-            {
-              name: 'Noto Serif SC',
-              weights: [900],
-            },
-          ],
-          // sans: 'DM Sans',
-          // mono: 'DM Mono',
-        },
-      }),
-    ],
-    rules: [
-      // more see '~/styles/global/helper.scss'
-      ['yun-transition', {
-        'transition-duration': 'var(--va-transition-duration)',
-      }],
-      ['yun-text-light', {
-        color: 'var(--va-c-text-light)',
-      }],
-      ['font-serif', {
-        'font-family': 'var(--va-font-serif)',
-      }],
-      ['font-sans', {
-        'font-family': 'var(--va-font-sans)',
-      }],
-      ['font-mono', {
-        'font-family': 'var(--va-font-mono)',
-      }],
-    ],
-    transformers: [
-      transformerDirectives(),
-      transformerVariantGroup(),
-    ],
-    safelist: await createSafelist(options.config),
-  }
-
-  return defu(options.config.unocss, unocssConfig)
-}
-
-export const createUnocssPlugin = async (options: ResolvedValaxyOptions) => {
-  const config = await createUnocssConfig(options)
-  return Unocss(config)
-}

package/node/plugins/valaxy.ts

@@ -1 +0,0 @@
-export const VALAXY_CONFIG_ID = '@valaxyjs/config'

package/node/rss.ts

@@ -1,127 +0,0 @@
-import { dirname } from 'path'
-import { cyan, dim } from 'kolorist'
-
-import fg from 'fast-glob'
-import fs from 'fs-extra'
-import matter from 'gray-matter'
-import MarkdownIt from 'markdown-it'
-import type { Author, FeedOptions, Item } from 'feed'
-import { Feed } from 'feed'
-import consola from 'consola'
-import type { ResolvedValaxyOptions } from './options'
-
-const markdown = MarkdownIt({
-  html: true,
-  breaks: true,
-  linkify: true,
-})
-
-/**
- * generate rss
- * @param options
- * @returns
- */
-export async function build(options: ResolvedValaxyOptions) {
-  const { config } = options
-
-  if (!config.url || config.url === '/') {
-    consola.error('You must set "config.url" to generate rss.')
-    return
-  }
-
-  const siteUrl = config.url.endsWith('/') ? config.url : `${config.url}/`
-  const DOMAIN = config.url.endsWith('/') ? config.url.slice(0, -1) : config.url
-  const author: Author = {
-    name: options.config.author.name,
-    email: options.config.author.email,
-    link: options.config.author.link,
-  }
-
-  consola.info(`RSS Site Url: ${cyan(siteUrl)}`)
-
-  const ccVersion = (config.license.type === 'zero') ? '1.0' : '4.0'
-  const feedOptions: FeedOptions = {
-    title: config.title,
-    description: config.description,
-    id: siteUrl || 'valaxy',
-    link: siteUrl,
-    copyright: `CC ${config.license.type.toUpperCase()} ${ccVersion} ${new Date().getFullYear()} © ${config.author.name}`,
-    feedLinks: {
-      json: `${siteUrl}feed.json`,
-      atom: `${siteUrl}feed.atom`,
-      rss: `${siteUrl}feed.xml`,
-    },
-  }
-
-  // generate
-  const files = await fg(`${options.userRoot}/pages/posts/**/*.md`)
-
-  const posts: Item[] = []
-  files
-    .forEach((i) => {
-      const raw = fs.readFileSync(i, 'utf-8')
-      const { data, content, excerpt } = matter(raw)
-
-      // not add to posts
-      if (!data.date) {
-        consola.warn(`Do you forget to write date for ${dim(i)}`)
-        return false
-      }
-
-      if (data.draft) {
-        consola.warn(`Ignore draft post: ${dim(i)}`)
-        return false
-      }
-
-      // todo i18n
-
-      // render excerpt
-      const html = markdown.render(excerpt || content)
-        .replace('src="/', `src="${DOMAIN}/`)
-
-      if (data.image?.startsWith('/'))
-        data.image = DOMAIN + data.image
-
-      posts.push({
-        title: '',
-        ...data,
-        id: (data.id || '').toString(),
-        date: new Date(data.date),
-        published: new Date(data.updated || data.date),
-        content: html,
-        author: [author],
-        link: DOMAIN + i.replace(`${options.userRoot}/pages`, '').replace(/\.md$/, ''),
-      })
-    })
-
-  // sort by updated
-  posts.sort((a, b) => +new Date(b.published || b.date) - +new Date(a.published || a.date))
-  // await writeFeed('feed', feedOptions, posts)
-
-  // write
-  feedOptions.author = author
-  feedOptions.image = config.author.avatar.startsWith('http') ? config.author.avatar : `${DOMAIN}${config.author.avatar}`
-  feedOptions.favicon = `${DOMAIN}/${config.feed.favicon || config.favicon}`
-
-  const feed = new Feed(feedOptions)
-  posts.forEach(item => feed.addItem(item))
-  // items.forEach(i=> console.log(i.title, i.date))
-
-  await fs.ensureDir(dirname(`./dist/${config.feed.name}`))
-  const path = './dist'
-
-  const types = ['xml', 'atom', 'json']
-  types.forEach((type) => {
-    let data = ''
-    let name = `${path}/${config.feed.name || 'feed'}.${type}`
-    if (type === 'xml') { data = feed.rss2() }
-    else if (type === 'atom') {
-      if (!config.feed.name)
-        name = `${path}/atom.xml`
-      data = feed.atom1()
-    }
-    else if (type === 'json') { data = feed.json1() }
-    fs.writeFileSync(name, data, 'utf-8')
-    consola.info(`${type}: ${name}`)
-  })
-}