pd-markdown 1.0.0 → 1.1.0

package/packages/utils/__tests__/traverse.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { traverseAst, traverseAstWithCallbacks } from '../src/ast/traverse'
-import type { Root, Paragraph, Text, Heading } from 'mdast'
-
-describe('traverseAst', () => {
-  const createSimpleAst = (): Root => ({
-    type: 'root',
-    children: [
-      {
-        type: 'heading',
-        depth: 1,
-        children: [{ type: 'text', value: 'Title' }],
-      } as Heading,
-      {
-        type: 'paragraph',
-        children: [{ type: 'text', value: 'Content' }],
-      } as Paragraph,
-    ],
-  })
-
-  it('should visit all nodes in depth-first order', () => {
-    const ast = createSimpleAst()
-    const visited: string[] = []
-
-    traverseAst(ast, (node) => {
-      visited.push(node.type)
-    })
-
-    expect(visited).toEqual(['root', 'heading', 'text', 'paragraph', 'text'])
-  })
-
-  it('should skip children when visitor returns false', () => {
-    const ast = createSimpleAst()
-    const visited: string[] = []
-
-    traverseAst(ast, (node) => {
-      visited.push(node.type)
-      if (node.type === 'heading') {
-        return false // Skip children of heading
-      }
-    })
-
-    expect(visited).toEqual(['root', 'heading', 'paragraph', 'text'])
-  })
-
-  it('should provide correct index and parent', () => {
-    const ast = createSimpleAst()
-    const visitor = vi.fn()
-
-    traverseAst(ast, visitor)
-
-    // Root has no index and no parent
-    expect(visitor).toHaveBeenNthCalledWith(1, ast, undefined, undefined)
-
-    // Heading is at index 0 with root as parent
-    expect(visitor).toHaveBeenNthCalledWith(2, ast.children[0], 0, ast)
-  })
-
-  it('should handle empty children', () => {
-    const ast: Root = {
-      type: 'root',
-      children: [],
-    }
-    const visited: string[] = []
-
-    traverseAst(ast, (node) => {
-      visited.push(node.type)
-    })
-
-    expect(visited).toEqual(['root'])
-  })
-})
-
-describe('traverseAstWithCallbacks', () => {
-  const createSimpleAst = (): Root => ({
-    type: 'root',
-    children: [
-      {
-        type: 'paragraph',
-        children: [{ type: 'text', value: 'Hello' }],
-      } as Paragraph,
-    ],
-  })
-
-  it('should call enter and leave in correct order', () => {
-    const ast = createSimpleAst()
-    const events: string[] = []
-
-    traverseAstWithCallbacks(ast, {
-      enter: (node) => {
-        events.push(`enter:${node.type}`)
-      },
-      leave: (node) => {
-        events.push(`leave:${node.type}`)
-      },
-    })
-
-    expect(events).toEqual([
-      'enter:root',
-      'enter:paragraph',
-      'enter:text',
-      'leave:text',
-      'leave:paragraph',
-      'leave:root',
-    ])
-  })
-
-  it('should skip children when enter returns false', () => {
-    const ast = createSimpleAst()
-    const events: string[] = []
-
-    traverseAstWithCallbacks(ast, {
-      enter: (node) => {
-        events.push(`enter:${node.type}`)
-        if (node.type === 'paragraph') {
-          return false
-        }
-      },
-      leave: (node) => {
-        events.push(`leave:${node.type}`)
-      },
-    })
-
-    expect(events).toEqual([
-      'enter:root',
-      'enter:paragraph',
-      'leave:paragraph',
-      'leave:root',
-    ])
-  })
-})

package/packages/utils/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "@pd-markdown/utils",
-  "version": "0.1.0",
-  "description": "Utility functions and types for pd-markdown",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "files": ["dist"],
-  "scripts": {
-    "build": "rollup -c rollup.config.ts --configPlugin typescript",
-    "clean": "rm -rf dist *.tsbuildinfo"
-  },
-  "devDependencies": {
-    "@types/mdast": "^4.0.4",
-    "@types/unist": "^3.0.3"
-  },
-  "sideEffects": false,
-  "license": "MIT"
-}

package/packages/utils/rollup.config.ts

@@ -1,26 +0,0 @@
-import typescript from '@rollup/plugin-typescript'
-import { defineConfig } from 'rollup'
-
-export default defineConfig({
-  input: 'src/index.ts',
-  output: [
-    {
-      file: 'dist/index.mjs',
-      format: 'esm',
-      sourcemap: true,
-    },
-    {
-      file: 'dist/index.cjs',
-      format: 'cjs',
-      sourcemap: true,
-    },
-  ],
-  plugins: [
-    typescript({
-      tsconfig: './tsconfig.json',
-      declaration: true,
-      declarationDir: './dist',
-    }),
-  ],
-  external: [],
-})

package/packages/utils/src/ast/query.ts

@@ -1,127 +0,0 @@
-import type { Node } from 'unist'
-import type { MdNode, Parent } from '../types'
-import { isParent } from '../types'
-
-/**
- * Find all nodes of a specific type in the AST
- *
- * @param node - Root node to search from
- * @param type - Node type to find
- * @returns Array of matching nodes
- */
-export function findNodes<T extends Node = MdNode>(
-  node: Node,
-  type: string
-): T[] {
-  const results: T[] = []
-
-  function visit(current: Node): void {
-    if (current.type === type) {
-      results.push(current as T)
-    }
-
-    if (isParent(current)) {
-      for (const child of current.children) {
-        visit(child)
-      }
-    }
-  }
-
-  visit(node)
-  return results
-}
-
-/**
- * Find the first node of a specific type in the AST
- *
- * @param node - Root node to search from
- * @param type - Node type to find
- * @returns The first matching node or undefined
- */
-export function findNode<T extends Node = MdNode>(
-  node: Node,
-  type: string
-): T | undefined {
-  let result: T | undefined
-
-  function visit(current: Node): boolean {
-    if (current.type === type) {
-      result = current as T
-      return true // Found, stop searching
-    }
-
-    if (isParent(current)) {
-      for (const child of current.children) {
-        if (visit(child)) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  visit(node)
-  return result
-}
-
-/**
- * Find all nodes matching a predicate
- *
- * @param node - Root node to search from
- * @param predicate - Function to test each node
- * @returns Array of matching nodes
- */
-export function findNodesBy<T extends Node = MdNode>(
-  node: Node,
-  predicate: (node: Node) => boolean
-): T[] {
-  const results: T[] = []
-
-  function visit(current: Node): void {
-    if (predicate(current)) {
-      results.push(current as T)
-    }
-
-    if (isParent(current)) {
-      for (const child of current.children) {
-        visit(child)
-      }
-    }
-  }
-
-  visit(node)
-  return results
-}
-
-/**
- * Get the parent of a node in the AST
- * Note: This requires traversing from root, use sparingly
- *
- * @param root - Root node of the AST
- * @param target - Node to find parent of
- * @returns Parent node or undefined if not found or is root
- */
-export function findParent(root: Node, target: Node): Parent | undefined {
-  let result: Parent | undefined
-
-  function visit(current: Node, parent: Parent | undefined): boolean {
-    if (current === target) {
-      result = parent
-      return true
-    }
-
-    if (isParent(current)) {
-      for (const child of current.children) {
-        if (visit(child, current)) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  visit(root, undefined)
-  return result
-}

package/packages/utils/src/ast/traverse.ts

@@ -1,73 +0,0 @@
-import type { Node } from 'unist'
-import type { Parent, MdNode, Visitor } from '../types'
-import { isParent } from '../types'
-
-/**
- * Traverse AST in depth-first order
- *
- * @param node - Root node to start traversal
- * @param visitor - Visitor function called for each node
- *                  Return `false` to skip children of current node
- *                  Return `true` or `undefined` to continue
- */
-export function traverseAst<T extends Node = MdNode>(
-  node: T,
-  visitor: Visitor<T>
-): void {
-  function visit(
-    current: T,
-    index: number | undefined,
-    parent: Parent | undefined
-  ): void {
-    const result = visitor(current, index, parent)
-
-    // Skip children if visitor returns false
-    if (result === false) {
-      return
-    }
-
-    if (isParent(current)) {
-      const children = current.children as T[]
-      for (let i = 0; i < children.length; i++) {
-        visit(children[i], i, current as unknown as Parent)
-      }
-    }
-  }
-
-  visit(node, undefined, undefined)
-}
-
-/**
- * Traverse AST with enter and leave callbacks
- *
- * @param node - Root node to start traversal
- * @param callbacks - Object with optional enter and leave functions
- */
-export function traverseAstWithCallbacks<T extends Node = MdNode>(
-  node: T,
-  callbacks: {
-    enter?: Visitor<T>
-    leave?: Visitor<T>
-  }
-): void {
-  const { enter, leave } = callbacks
-
-  function visit(
-    current: T,
-    index: number | undefined,
-    parent: Parent | undefined
-  ): void {
-    const shouldSkipChildren = enter?.(current, index, parent) === false
-
-    if (!shouldSkipChildren && isParent(current)) {
-      const children = current.children as T[]
-      for (let i = 0; i < children.length; i++) {
-        visit(children[i], i, current as unknown as Parent)
-      }
-    }
-
-    leave?.(current, index, parent)
-  }
-
-  visit(node, undefined, undefined)
-}

package/packages/utils/src/index.ts

@@ -1,20 +0,0 @@
-// Types
-export type {
-  MdNode,
-  MdRoot,
-  Parent,
-  Literal,
-  Visitor,
-  PluginOptions,
-  Position,
-  Location,
-} from './types'
-export { isParent, isLiteral, isNodeType } from './types'
-
-// AST utilities
-export { traverseAst, traverseAstWithCallbacks } from './ast/traverse'
-export { findNodes, findNode, findNodesBy, findParent } from './ast/query'
-
-// String utilities
-export { slugify, uniqueSlugify } from './string/slugify'
-export { escapeHtml, sanitizeHtml, stripHtml } from './string/sanitize'

package/packages/utils/src/string/sanitize.ts

@@ -1,155 +0,0 @@
-/**
- * HTML entities that need escaping
- */
-const HTML_ESCAPE_MAP: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;',
-}
-
-/**
- * Escape HTML special characters
- *
- * @param text - Text to escape
- * @returns Escaped text safe for HTML insertion
- */
-export function escapeHtml(text: string): string {
-  return text.replace(/[&<>"']/g, (char) => HTML_ESCAPE_MAP[char] || char)
-}
-
-/**
- * Allowed HTML tags for sanitization
- */
-const ALLOWED_TAGS = new Set([
-  'a',
-  'abbr',
-  'b',
-  'blockquote',
-  'br',
-  'code',
-  'dd',
-  'del',
-  'div',
-  'dl',
-  'dt',
-  'em',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'hr',
-  'i',
-  'img',
-  'ins',
-  'kbd',
-  'li',
-  'ol',
-  'p',
-  'pre',
-  'q',
-  's',
-  'samp',
-  'small',
-  'span',
-  'strong',
-  'sub',
-  'sup',
-  'table',
-  'tbody',
-  'td',
-  'tfoot',
-  'th',
-  'thead',
-  'tr',
-  'u',
-  'ul',
-])
-
-/**
- * Allowed attributes for sanitization
- */
-const ALLOWED_ATTRS = new Set([
-  'href',
-  'src',
-  'alt',
-  'title',
-  'class',
-  'id',
-  'name',
-  'target',
-  'rel',
-  'width',
-  'height',
-  'align',
-  'colspan',
-  'rowspan',
-])
-
-/**
- * Sanitize HTML string by removing dangerous content
- *
- * @param html - HTML string to sanitize
- * @returns Sanitized HTML string
- */
-export function sanitizeHtml(html: string): string {
-  let result = html
-
-  // Remove script tags first
-  result = result.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-
-  // Remove event handlers
-  result = result.replace(/\s+on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]*)/gi, '')
-
-  // Remove disallowed tags (keep content) and sanitize attributes
-  result = result.replace(/<\/?(\w+)([^>]*)>/g, (match, tagName, attrs) => {
-    const tag = tagName.toLowerCase()
-    if (!ALLOWED_TAGS.has(tag)) {
-      return ''
-    }
-
-    // For closing tags, just return them
-    if (match.startsWith('</')) {
-      return `</${tag}>`
-    }
-
-    // Sanitize attributes
-    const sanitizedAttrs: string[] = []
-    const attrRegex = /\s+([\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/g
-    let attrMatch
-
-    while ((attrMatch = attrRegex.exec(attrs)) !== null) {
-      const [, attrName, v1, v2, v3] = attrMatch
-      const attr = attrName.toLowerCase()
-      
-      if (ALLOWED_ATTRS.has(attr)) {
-        let value = v1 ?? v2 ?? v3 ?? ''
-        
-        // Check for dangerous URLs in href/src
-        if ((attr === 'href' || attr === 'src') && /^\s*javascript\s*:/i.test(value)) {
-          value = ''
-        }
-        
-        sanitizedAttrs.push(`${attr}="${value}"`)
-      }
-    }
-
-    const attrStr = sanitizedAttrs.length > 0 ? ' ' + sanitizedAttrs.join(' ') : ''
-    return `<${tag}${attrStr}>`
-  })
-
-  return result
-}
-
-/**
- * Strip all HTML tags from a string
- *
- * @param html - HTML string to strip
- * @returns Plain text without HTML tags
- */
-export function stripHtml(html: string): string {
-  return html.replace(/<[^>]*>/g, '')
-}

package/packages/utils/src/string/slugify.ts

@@ -1,43 +0,0 @@
-/**
- * Convert text to URL-safe slug
- *
- * @param text - Text to slugify
- * @returns URL-safe slug
- */
-export function slugify(text: string): string {
-  return (
-    text
-      // Convert to lowercase
-      .toLowerCase()
-      // Replace Chinese characters with pinyin-like representation (keep as-is for simplicity)
-      // Replace spaces and special chars with hyphens
-      .replace(/[\s_]+/g, '-')
-      // Remove characters that aren't alphanumeric, hyphens, or common CJK
-      .replace(/[^\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff-]/g, '')
-      // Replace multiple consecutive hyphens with single hyphen
-      .replace(/-+/g, '-')
-      // Remove leading/trailing hyphens
-      .replace(/^-+|-+$/g, '')
-  )
-}
-
-/**
- * Generate unique slug with counter suffix for duplicates
- *
- * @param text - Text to slugify
- * @param existingSlugs - Set of existing slugs to check against
- * @returns Unique slug
- */
-export function uniqueSlugify(text: string, existingSlugs: Set<string>): string {
-  const baseSlug = slugify(text)
-  let slug = baseSlug
-  let counter = 1
-
-  while (existingSlugs.has(slug)) {
-    slug = `${baseSlug}-${counter}`
-    counter++
-  }
-
-  existingSlugs.add(slug)
-  return slug
-}

package/packages/utils/src/types/index.ts

@@ -1,72 +0,0 @@
-import type { Root, Content, Parent, Literal } from 'mdast'
-import type { Node as UnistNode } from 'unist'
-
-// Re-export mdast types
-export type { Root, Content, Parent, Literal }
-
-/**
- * All possible markdown node types
- */
-export type MdNode = Root | Content
-
-/**
- * Root node of markdown AST
- */
-export type MdRoot = Root
-
-/**
- * Visitor function for AST traversal
- */
-export type Visitor<T extends UnistNode = MdNode> = (
-  node: T,
-  index: number | undefined,
-  parent: Parent | undefined
-) => void | boolean
-
-/**
- * Plugin options base interface
- */
-export interface PluginOptions {
-  [key: string]: unknown
-}
-
-/**
- * Position information in source
- */
-export interface Position {
-  line: number
-  column: number
-  offset?: number
-}
-
-/**
- * Location in source
- */
-export interface Location {
-  start: Position
-  end: Position
-}
-
-/**
- * Type guard to check if node is a parent node
- */
-export function isParent(node: UnistNode): node is Parent {
-  return 'children' in node && Array.isArray((node as Parent).children)
-}
-
-/**
- * Type guard to check if node is a literal node
- */
-export function isLiteral(node: UnistNode): node is Literal {
-  return 'value' in node && typeof (node as Literal).value === 'string'
-}
-
-/**
- * Type guard to check if node has specific type
- */
-export function isNodeType<T extends MdNode>(
-  node: UnistNode,
-  type: T['type']
-): node is T {
-  return node.type === type
-}

package/packages/utils/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src"]
-}