valaxy 0.6.2 → 0.7.1

package/node/markdown/markdown-it/katex.ts

@@ -1,210 +0,0 @@
-// copy from https://github.com/slidevjs/slidev/blob/main/packages/slidev/node/plugins/markdown-it-katex.ts
-// Ported from https://github.com/waylonflinn/markdown-it-katex
-
-/* Process inline math */
-/*
-Like markdown-it-simplemath, this is a stripped down, simplified version of:
-https://github.com/runarberg/markdown-it-math
-
-It differs in that it takes (a subset of) LaTeX as input and relies on KaTeX
-for rendering output.
-*/
-
-import type { KatexOptions } from 'katex'
-import katex from 'katex'
-
-// Test if potential opening or closing delimieter
-// Assumes that there is a "$" at state.src[pos]
-function isValidDelim(state: any, pos: number) {
-  const max = state.posMax
-  let can_open = true
-  let can_close = true
-
-  const prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1
-  const nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1
-
-  // Check non-whitespace conditions for opening and closing, and
-  // check that closing delimeter isn't followed by a number
-  if (prevChar === 0x20/* " " */ || prevChar === 0x09
-            ||/* \t */ (nextChar >= 0x30/* "0" */ && nextChar <= 0x39/* "9" */))
-    can_close = false
-
-  if (nextChar === 0x20/* " " */ || nextChar === 0x09/* \t */)
-    can_open = false
-
-  return {
-    can_open,
-    can_close,
-  }
-}
-
-function math_inline(state: any, silent: boolean) {
-  let match, token, res, pos
-
-  if (state.src[state.pos] !== '$')
-    return false
-
-  res = isValidDelim(state, state.pos)
-  if (!res.can_open) {
-    if (!silent)
-      state.pending += '$'
-    state.pos += 1
-    return true
-  }
-
-  // First check for and bypass all properly escaped delimieters
-  // This loop will assume that the first leading backtick can not
-  // be the first character in state.src, which is known since
-  // we have found an opening delimieter already.
-  const start = state.pos + 1
-  match = start
-  // eslint-disable-next-line no-cond-assign
-  while ((match = state.src.indexOf('$', match)) !== -1) {
-    // Found potential $, look for escapes, pos will point to
-    // first non escape when complete
-    pos = match - 1
-    while (state.src[pos] === '\\') pos -= 1
-
-    // Even number of escapes, potential closing delimiter found
-    if (((match - pos) % 2) === 1)
-      break
-    match += 1
-  }
-
-  // No closing delimter found.  Consume $ and continue.
-  if (match === -1) {
-    if (!silent)
-      state.pending += '$'
-    state.pos = start
-    return true
-  }
-
-  // Check if we have empty content, ie: $$.  Do not parse.
-  if (match - start === 0) {
-    if (!silent)
-      state.pending += '$$'
-    state.pos = start + 1
-    return true
-  }
-
-  // Check for valid closing delimiter
-  res = isValidDelim(state, match)
-  if (!res.can_close) {
-    if (!silent)
-      state.pending += '$'
-    state.pos = start
-    return true
-  }
-
-  if (!silent) {
-    token = state.push('math_inline', 'math', 0)
-    token.markup = '$'
-    token.content = state.src.slice(start, match)
-  }
-
-  state.pos = match + 1
-  return true
-}
-
-function math_block(state: any, start: number, end: number, silent: boolean) {
-  let firstLine; let lastLine; let next; let lastPos
-  let found = false
-  let pos = state.bMarks[start] + state.tShift[start]
-  let max = state.eMarks[start]
-
-  if (pos + 2 > max)
-    return false
-  if (state.src.slice(pos, pos + 2) !== '$$')
-    return false
-
-  pos += 2
-  firstLine = state.src.slice(pos, max)
-
-  if (silent)
-    return true
-  if (firstLine.trim().slice(-2) === '$$') {
-    // Single line expression
-    firstLine = firstLine.trim().slice(0, -2)
-    found = true
-  }
-
-  for (next = start; !found;) {
-    next++
-
-    if (next >= end)
-      break
-
-    pos = state.bMarks[next] + state.tShift[next]
-    max = state.eMarks[next]
-
-    if (pos < max && state.tShift[next] < state.blkIndent) {
-      // non-empty line with negative indent should stop the list:
-      break
-    }
-
-    if (state.src.slice(pos, max).trim().slice(-2) === '$$') {
-      lastPos = state.src.slice(0, max).lastIndexOf('$$')
-      lastLine = state.src.slice(pos, lastPos)
-      found = true
-    }
-  }
-
-  state.line = next + 1
-
-  const token = state.push('math_block', 'math', 0)
-  token.block = true
-  token.content = (firstLine && firstLine.trim() ? `${firstLine}\n` : '')
-    + state.getLines(start + 1, next, state.tShift[start], true)
-    + (lastLine && lastLine.trim() ? lastLine : '')
-  token.map = [start, state.line]
-  token.markup = '$$'
-  return true
-}
-
-export default function math_plugin(md: any, options: KatexOptions) {
-  // Default options
-
-  options = options || {}
-
-  // set KaTeX as the renderer for markdown-it-simplemath
-  const katexInline = function (latex: string) {
-    options.displayMode = false
-    try {
-      return katex.renderToString(latex, options)
-    }
-    catch (error) {
-      if (options.throwOnError)
-
-        console.warn(error)
-      return latex
-    }
-  }
-
-  const inlineRenderer = function (tokens: any, idx: number) {
-    return katexInline(tokens[idx].content)
-  }
-
-  const katexBlock = function (latex: string) {
-    options.displayMode = true
-    try {
-      return `<p>${katex.renderToString(latex, options)}</p>`
-    }
-    catch (error) {
-      if (options.throwOnError)
-
-        console.warn(error)
-      return latex
-    }
-  }
-
-  const blockRenderer = function (tokens: any, idx: number) {
-    return `${katexBlock(tokens[idx].content)}\n`
-  }
-
-  md.inline.ruler.after('escape', 'math_inline', math_inline)
-  md.block.ruler.after('blockquote', 'math_block', math_block, {
-    alt: ['paragraph', 'reference', 'blockquote', 'list'],
-  })
-  md.renderer.rules.math_inline = inlineRenderer
-  md.renderer.rules.math_block = blockRenderer
-}

package/node/markdown/markdown-it/parseHeader.ts

@@ -1,72 +0,0 @@
-// ref vitepress
-
-// Since VuePress needs to extract the header from the markdown source
-// file and display it in the sidebar or title (#238), this file simply
-// removes some unnecessary elements to make header displays well at
-// sidebar or title.
-//
-// But header's parsing in the markdown content is done by the markdown
-// loader based on markdown-it. markdown-it parser will will always keep
-// HTML in headers, so in VuePress, after being parsed by the markdown
-// loader, the raw HTML in headers will finally be parsed by Vue-loader.
-// so that we can write HTML/Vue in the header. One exception is the HTML
-// wrapped by <code>(markdown token: '`') tag.
-import emojiData from 'markdown-it-emoji/lib/data/full.json'
-
-const parseEmojis = (str: string) => {
-  return str.replace(
-    /:(.+?):/g,
-    (placeholder, key) => (emojiData as any)[key] || placeholder,
-  )
-}
-
-const unescapeHtml = (html: string) =>
-  html
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, '\'')
-    .replace(/&#x3A;/g, ':')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-
-const removeMarkdownTokens = (str: string) =>
-  str
-    .replace(/(\[(.[^\]]+)\]\((.[^)]+)\))/g, '$2') // []()
-    .replace(/(`|\*{1,3}|_)(.*?[^\\])\1/g, '$2') // `{t}` | *{t}* | **{t}** | ***{t}*** | _{t}_
-    .replace(/(\\)(\*|_|`|\!|<|\$)/g, '$2') // remove escape char '\'
-
-const remvoeCustomAnchor = (str: string) =>
-  str.replace(/\{#([a-z0-9\-_]+?)\}\s*$/, '') // {#custom-header}
-
-const trim = (str: string) => str.trim()
-
-// This method remove the raw HTML but reserve the HTML wrapped by `<code>`.
-// e.g.
-// Input: "<a> b",   Output: "b"
-// Input: "`<a>` b", Output: "`<a>` b"
-export const removeNonCodeWrappedHTML = (str: string) => {
-  return String(str).replace(/(^|[^><`\\])<.*>([^><`]|$)/g, '$1$2')
-}
-
-const compose = (...processors: ((str: string) => string)[]) => {
-  if (processors.length === 0)
-    return (input: string) => input
-  if (processors.length === 1)
-    return processors[0]
-  return processors.reduce((prev, next) => {
-    return str => next(prev(str))
-  })
-}
-
-// Unescape html, parse emojis and remove some md tokens.
-export const parseHeader = compose(
-  unescapeHtml,
-  parseEmojis,
-  remvoeCustomAnchor,
-  removeMarkdownTokens,
-  trim,
-)
-
-// Also clean the html that isn't wrapped by code.
-// Because we want to support using VUE components in headers.
-// e.g. https://vuepress.vuejs.org/guide/using-vue.html#badge
-export const deeplyParseHeader = compose(removeNonCodeWrappedHTML, parseHeader)

package/node/markdown/markdownToVue.ts

@@ -1,275 +0,0 @@
-// copy from vitepress
-import fs from 'fs'
-import path from 'path'
-import c from 'picocolors'
-import matter from 'gray-matter'
-import LRUCache from 'lru-cache'
-import _debug from 'debug'
-import { getGitTimestamp, slash, transformObject } from '../utils'
-import { EXTERNAL_URL_RE } from '../../shared'
-import type { HeadConfig, PageData } from '../../types'
-import { deeplyParseHeader } from './markdown-it/parseHeader'
-import { createMarkdownRenderer } from '.'
-import type { MarkdownOptions } from '.'
-
-const debug = _debug('vitepress:md')
-const cache = new LRUCache<string, MarkdownCompileResult>({ max: 1024 })
-const includesRE = /<!--\s*@include:\s*(.*?)\s*-->/g
-
-export interface MarkdownCompileResult {
-  vueSrc: string
-  pageData: PageData
-  deadLinks: string[]
-  includes: string[]
-}
-
-const inferTitle = (frontmatter: Record<string, any>, content: string) => {
-  if (frontmatter.title)
-    return deeplyParseHeader(frontmatter.title)
-
-  const match = content.match(/^\s*#+\s+(.*)/m)
-
-  if (match)
-    return deeplyParseHeader(match[1].trim())
-
-  return ''
-}
-
-const getHeadMetaContent = (
-  head: HeadConfig[],
-  name: string,
-): string | undefined => {
-  if (!head || !head.length)
-    return undefined
-
-  const meta = head.find(([tag, attrs = {}]) => {
-    return tag === 'meta' && attrs.name === name && attrs.content
-  })
-
-  return meta && meta[1].content
-}
-
-const inferDescription = (frontmatter: Record<string, any>) => {
-  const { description, head } = frontmatter
-
-  if (description !== undefined)
-    return description
-
-  return (head && getHeadMetaContent(head, 'description')) || ''
-}
-
-export async function createMarkdownToVueRenderFn(
-  srcDir: string,
-  options: MarkdownOptions = {},
-  pages: string[],
-  userDefines: Record<string, any> | undefined,
-  isBuild = false,
-  base = '/',
-  includeLastUpdatedData = false,
-) {
-  const md = await createMarkdownRenderer(srcDir, options, base)
-
-  pages = pages.map(p => slash(p.replace(/\.md$/, '')))
-
-  const userDefineRegex = userDefines
-    ? new RegExp(
-        `\\b(${Object.keys(userDefines)
-          .map(key => key.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&'))
-          .join('|')})`,
-        'g',
-    )
-    : null
-
-  return async (
-    src: string,
-    file: string,
-    publicDir: string,
-  ): Promise<MarkdownCompileResult> => {
-    const relativePath = slash(path.relative(srcDir, file))
-    const dir = path.dirname(file)
-
-    const cached = cache.get(src)
-    if (cached) {
-      debug(`[cache hit] ${relativePath}`)
-      return cached
-    }
-
-    const start = Date.now()
-
-    // resolve includes
-    const includes: string[] = []
-    src = src.replace(includesRE, (_, m1) => {
-      const includePath = path.join(dir, m1)
-      const content = fs.readFileSync(includePath, 'utf-8')
-      includes.push(slash(includePath))
-      return content
-    })
-
-    const { content, data: frontmatter } = matter(src)
-
-    // reset state before render
-    md.__path = file
-    md.__relativePath = relativePath
-
-    let html = md.render(content)
-    const data = md.__data
-
-    if (isBuild) {
-      // avoid env variables being replaced by vite
-      html = html
-        .replace(/\bimport\.meta/g, 'import.<wbr/>meta')
-        .replace(/\bprocess\.env/g, 'process.<wbr/>env')
-
-      // also avoid replacing vite user defines
-      if (userDefineRegex) {
-        html = html.replace(
-          userDefineRegex,
-          _ => `${_[0]}<wbr/>${_.slice(1)}`,
-        )
-      }
-    }
-
-    // validate data.links
-    const deadLinks: string[] = []
-    const recordDeadLink = (url: string) => {
-      console.warn(
-        c.yellow(
-          `\n(!) Found dead link ${c.cyan(url)} in file ${c.white(c.dim(file))}`,
-        ),
-      )
-      deadLinks.push(url)
-    }
-
-    if (data.links) {
-      const dir = path.dirname(file)
-      for (let url of data.links) {
-        if (/\.(?!html|md)\w+($|\?)/i.test(url))
-          continue
-
-        if (url.replace(EXTERNAL_URL_RE, '').startsWith('//localhost:')) {
-          recordDeadLink(url)
-          continue
-        }
-
-        url = url.replace(/[?#].*$/, '').replace(/\.(html|md)$/, '')
-        if (url.endsWith('/'))
-          url += 'index'
-        const resolved = decodeURIComponent(
-          slash(
-            url.startsWith('/')
-              ? url.slice(1)
-              : path.relative(srcDir, path.resolve(dir, url)),
-          ),
-        )
-        if (
-          !pages.includes(resolved)
-          && !fs.existsSync(path.resolve(dir, publicDir, `${resolved}.html`))
-        )
-          recordDeadLink(url)
-      }
-    }
-
-    const pageData: PageData = {
-      title: inferTitle(frontmatter, content),
-      titleTemplate: frontmatter.titleTemplate,
-      description: inferDescription(frontmatter),
-      frontmatter,
-      headers: data.headers || [],
-      relativePath,
-      path: path.join(srcDir, relativePath),
-    }
-
-    if (includeLastUpdatedData)
-      pageData.lastUpdated = await getGitTimestamp(file)
-
-    const pageComponent = 'ValaxyMain'
-
-    function generateSlots() {
-      const slots = [
-        'main-header',
-        'main-header-after',
-        'main-nav',
-        'main-content',
-        'main-content-after',
-        'footer',
-        'aside',
-        'aside-custom',
-      ]
-      const slotsText = slots.map(s => `<template #${s}><slot name="${s}" /></template>`).join('')
-      return slotsText
-    }
-    const vueSrc
-      = `${genPageDataCode(data.hoistedTags || [], pageData).join('\n')
-      }\n<template><${pageComponent} :frontmatter="frontmatter" :data="data">
-        <template #main-content-md>${html}</template>
-        ${generateSlots()}
-        <slot />
-      </${pageComponent}></template>`
-
-    debug(`[render] ${file} in ${Date.now() - start}ms.`)
-
-    const result = {
-      vueSrc,
-      pageData,
-      deadLinks,
-      includes,
-    }
-    cache.set(src, result)
-    return result
-  }
-}
-
-const scriptRE = /<\/script>/
-const scriptLangTsRE = /<\s*script[^>]*\blang=['"]ts['"][^>]*/
-const scriptSetupRE = /<\s*script[^>]*\bsetup\b[^>]*/
-const scriptClientRE = /<\s*script[^>]*\bclient\b[^>]*/
-const defaultExportRE = /((?:^|\n|;)\s*)export(\s*)default/
-const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)as(\s*)default/
-
-function genPageDataCode(tags: string[], data: PageData) {
-  const code = ''
-
-  const existingScriptIndex = tags.findIndex((tag) => {
-    return (
-      scriptRE.test(tag)
-      && !scriptSetupRE.test(tag)
-      && !scriptClientRE.test(tag)
-    )
-  })
-
-  const isUsingTS = tags.findIndex(tag => scriptLangTsRE.test(tag)) > -1
-
-  const exportScript = `
-  export default {
-    name:'${data.relativePath}',
-    data() {
-      return {
-        frontmatter:${transformObject(data.frontmatter)},
-        data: ${transformObject(data)}
-      }
-    }
-  }`
-
-  if (existingScriptIndex > -1) {
-    const tagSrc = tags[existingScriptIndex]
-    // user has <script> tag inside markdown
-    // if it doesn't have export default it will error out on build
-    const hasDefaultExport
-      = defaultExportRE.test(tagSrc) || namedDefaultExportRE.test(tagSrc)
-    tags[existingScriptIndex] = tagSrc.replace(
-      scriptRE,
-      `${code
-        + (hasDefaultExport
-          ? ''
-          : `\n${exportScript}`)
-        }</script>`,
-    )
-  }
-  else {
-    tags.unshift(
-      `<script ${isUsingTS ? 'lang="ts"' : ''}>${code}\n${exportScript}</script>`,
-    )
-  }
-
-  return tags
-}

package/node/markdown/slugify.ts

@@ -1,24 +0,0 @@
-// ref vitepress
-import { remove as removeDiacritics } from 'diacritics'
-// eslint-disable-next-line no-control-regex
-const rControl = /[\u0000-\u001F]/g
-// add '…'
-const rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'<>,.…?/]+/g
-
-export const slugify = (str: string): string => {
-  return (
-    removeDiacritics(str)
-      // Remove control characters
-      .replace(rControl, '')
-      // Replace special characters
-      .replace(rSpecial, '-')
-      // Remove continuous separators
-      .replace(/\-{2,}/g, '-')
-      // Remove prefixing and trailing separators
-      .replace(/^\-+|\-+$/g, '')
-      // ensure it doesn't start with a number (#121)
-      .replace(/^(\d)/, '_$1')
-      // lowercase
-      .toLowerCase()
-  )
-}

package/node/options.ts

@@ -1,108 +0,0 @@
-import { dirname, resolve } from 'path'
-import _debug from 'debug'
-import fg from 'fast-glob'
-import type { ValaxyConfig } from '../types'
-import { resolveConfig } from './config'
-import { resolveImportPath } from './utils'
-
-const debug = _debug('valaxy:options')
-
-// for cli entry
-export interface ValaxyEntryOptions {
-  /**
-   * theme name
-   */
-  theme?: string
-  userRoot?: string
-}
-
-export interface ResolvedValaxyOptions {
-  mode: 'dev' | 'build'
-  /**
-   * Client root path
-   * @default 'valaxy/src/client'
-   */
-  clientRoot: string
-  /**
-   * User root path
-   * @default process.cwd()
-   */
-  userRoot: string
-  /**
-   * Theme root path
-   */
-  themeRoot: string
-  /**
-   * Theme name
-   */
-  theme: string
-  /**
-   * Valaxy Config
-   */
-  config: ValaxyConfig
-  /**
-   * config file path
-   */
-  configFile: string
-  pages: string[]
-}
-
-export interface ValaxyServerOptions {
-  onConfigReload?: (newConfig: ValaxyConfig, config: ValaxyConfig) => void
-}
-
-export function isPath(name: string) {
-  return name.startsWith('/') || /^\.\.?[\/\\]/.test(name)
-}
-
-/**
- * get theme roots
- * @param name
- * @param entry
- * @returns
- */
-export function getThemeRoot(name: string, entry: string) {
-  if (!name)
-    return ''
-
-  if (isPath(name))
-    return resolve(dirname(entry), name)
-  else
-    return dirname(resolveImportPath(`valaxy-theme-${name}/package.json`) || '')
-}
-
-// for cli options
-export async function resolveOptions(options: ValaxyEntryOptions, mode: ResolvedValaxyOptions['mode'] = 'dev') {
-  const clientRoot = resolve(dirname(resolveImportPath('valaxy/package.json', true)), 'client')
-  const userRoot = resolve(options.userRoot || process.cwd())
-
-  const { config: valaxyConfig, configFile, theme } = await resolveConfig(options)
-  const themeRoot = getThemeRoot(theme, userRoot)
-
-  // Important: fast-glob doesn't guarantee order of the returned files.
-  // We must sort the pages so the input list to rollup is stable across
-  // builds - otherwise different input order could result in different exports
-  // order in shared chunks which in turns invalidates the hash of every chunk!
-  // JavaScript built-in sort() is mandated to be stable as of ES2019 and
-  // supported in Node 12+, which is required by Vite.
-  const pages = (
-    await fg(['**.md'], {
-      cwd: userRoot,
-      ignore: ['**/node_modules'],
-    })
-  ).sort()
-
-  const valaxyOptions: ResolvedValaxyOptions = {
-    mode,
-    clientRoot,
-    userRoot,
-    themeRoot,
-    theme,
-    config: valaxyConfig,
-    configFile: configFile || '',
-    pages,
-  }
-  debug(valaxyOptions)
-
-  return valaxyOptions
-}