@piqit/resolvers 0.0.2 → 0.0.3

package/src/index.ts

@@ -1,65 +0,0 @@
-/**
- * @piqit/resolvers - Resolver implementations for piq v2
- *
- * Provides resolvers for querying structured content:
- * - fileMarkdown: Query markdown files from filesystem (Node.js/Bun)
- * - staticContent: Query pre-compiled content (Edge/Workers)
- *
- * @packageDocumentation
- */
-
-// =============================================================================
-// Filesystem Resolver (Node.js/Bun only)
-// =============================================================================
-
-export { fileMarkdown } from "./file-markdown"
-export type { FileMarkdownOptions, FileMarkdownResult } from "./file-markdown"
-
-// =============================================================================
-// Static Content Resolver (Edge/Workers compatible)
-// =============================================================================
-
-export { staticContent, staticResolver } from "./static"
-
-// =============================================================================
-// Path Pattern Utilities
-// =============================================================================
-
-export { compilePattern, createParamsSchema } from "./path-pattern"
-export type {
-  CompiledPattern,
-  ExtractParams,
-  PathParams,
-} from "./path-pattern"
-
-// =============================================================================
-// Frontmatter Utilities
-// =============================================================================
-
-export {
-  parseFrontmatter,
-  extractFrontmatterString,
-  getFrontmatterEndOffset,
-  readFrontmatter,
-  readFrontmatterWithOffset,
-} from "./frontmatter"
-
-// =============================================================================
-// Markdown Utilities
-// =============================================================================
-
-export {
-  parseMarkdownBody,
-  extractHeadings,
-  slugify,
-  markdownToHtml,
-  readMarkdownBody,
-  readParsedBody,
-} from "./markdown"
-
-export type {
-  BodyOptions,
-  BodyResult,
-  BodyShape,
-  Heading,
-} from "./markdown"

package/src/markdown.ts

@@ -1,262 +0,0 @@
-/**
- * Markdown Body Parsing
- *
- * Parses markdown body content to extract:
- * - Raw markdown text
- * - HTML (basic conversion)
- * - Headings with slugs
- */
-
-import { getFrontmatterEndOffset } from "./frontmatter"
-
-// =============================================================================
-// Types
-// =============================================================================
-
-/**
- * Options for parsing markdown body.
- */
-export interface BodyOptions {
-  /** Include raw markdown text */
-  raw?: boolean
-  /** Include HTML conversion */
-  html?: boolean
-  /** Extract headings with depth and slugs */
-  headings?: boolean
-}
-
-/**
- * A heading extracted from markdown.
- */
-export interface Heading {
-  /** Heading depth (1-6) */
-  depth: number
-  /** Heading text content */
-  text: string
-  /** URL-safe slug */
-  slug: string
-}
-
-/**
- * Result of parsing markdown body.
- */
-export interface BodyResult {
-  /** Raw markdown text (if requested) */
-  raw?: string
-  /** HTML content (if requested) */
-  html?: string
-  /** Extracted headings (if requested) */
-  headings?: Heading[]
-}
-
-/**
- * Type-level shape of body result based on options.
- */
-export type BodyShape<T extends BodyOptions> = {
-  [K in keyof T as T[K] extends true ? K : never]: K extends "raw"
-    ? string
-    : K extends "html"
-      ? string
-      : K extends "headings"
-        ? Heading[]
-        : never
-}
-
-// =============================================================================
-// Markdown Parsing
-// =============================================================================
-
-/**
- * Parse markdown body content.
- *
- * @param content - The full file content (including frontmatter if present)
- * @param options - What to extract from the markdown
- * @returns The requested body parts
- */
-export function parseMarkdownBody(content: string, options: BodyOptions): BodyResult {
-  // Strip frontmatter if present
-  const bodyOffset = getFrontmatterEndOffset(content)
-  const rawBody = content.slice(bodyOffset).replace(/^[\r\n]+/, "")
-
-  const result: BodyResult = {}
-
-  if (options.raw) {
-    result.raw = rawBody
-  }
-
-  if (options.html) {
-    result.html = markdownToHtml(rawBody)
-  }
-
-  if (options.headings) {
-    result.headings = extractHeadings(rawBody)
-  }
-
-  return result
-}
-
-// =============================================================================
-// Heading Extraction
-// =============================================================================
-
-/**
- * Regex to match ATX-style headings (# Heading).
- */
-const HEADING_REGEX = /^(#{1,6})\s+(.+)$/gm
-
-/**
- * Extract headings from markdown text.
- *
- * @param markdown - The raw markdown content
- * @returns Array of headings with depth, text, and slug
- */
-export function extractHeadings(markdown: string): Heading[] {
-  const headings: Heading[] = []
-  let match: RegExpExecArray | null
-
-  const regex = new RegExp(HEADING_REGEX.source, "gm")
-  while ((match = regex.exec(markdown)) !== null) {
-    const depth = match[1].length
-    const text = match[2].trim()
-    const slug = slugify(text)
-
-    headings.push({ depth, text, slug })
-  }
-
-  return headings
-}
-
-/**
- * Convert text to a URL-safe slug.
- *
- * @param text - The text to slugify
- * @returns A URL-safe slug
- */
-export function slugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, "") // Remove non-word chars
-    .replace(/\s+/g, "-") // Replace spaces with dashes
-    .replace(/--+/g, "-") // Replace multiple dashes
-    .replace(/^-|-$/g, "") // Trim dashes from ends
-}
-
-// =============================================================================
-// Basic Markdown to HTML
-// =============================================================================
-
-/**
- * Convert markdown to HTML.
- *
- * This is a basic implementation that handles common patterns.
- * For production use, consider using a proper markdown parser.
- *
- * @param markdown - The raw markdown content
- * @returns HTML string
- */
-export function markdownToHtml(markdown: string): string {
-  let html = markdown
-
-  // Escape HTML entities first
-  html = html
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-
-  // Headings (must be on their own line)
-  html = html.replace(/^######\s+(.+)$/gm, "<h6>$1</h6>")
-  html = html.replace(/^#####\s+(.+)$/gm, "<h5>$1</h5>")
-  html = html.replace(/^####\s+(.+)$/gm, "<h4>$1</h4>")
-  html = html.replace(/^###\s+(.+)$/gm, "<h3>$1</h3>")
-  html = html.replace(/^##\s+(.+)$/gm, "<h2>$1</h2>")
-  html = html.replace(/^#\s+(.+)$/gm, "<h1>$1</h1>")
-
-  // Code blocks (fenced)
-  html = html.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, _lang, code) => {
-    return `<pre><code>${code.trim()}</code></pre>`
-  })
-
-  // Inline code
-  html = html.replace(/`([^`]+)`/g, "<code>$1</code>")
-
-  // Bold
-  html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
-  html = html.replace(/__([^_]+)__/g, "<strong>$1</strong>")
-
-  // Italic
-  html = html.replace(/\*([^*]+)\*/g, "<em>$1</em>")
-  html = html.replace(/_([^_]+)_/g, "<em>$1</em>")
-
-  // Links
-  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
-
-  // Images
-  html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">')
-
-  // Horizontal rules
-  html = html.replace(/^---+$/gm, "<hr>")
-  html = html.replace(/^\*\*\*+$/gm, "<hr>")
-
-  // Unordered lists (simplified)
-  html = html.replace(/^[-*+]\s+(.+)$/gm, "<li>$1</li>")
-
-  // Ordered lists (simplified)
-  html = html.replace(/^\d+\.\s+(.+)$/gm, "<li>$1</li>")
-
-  // Wrap consecutive <li> in <ul> or <ol>
-  html = html.replace(/((?:<li>.*<\/li>\n?)+)/g, "<ul>\n$1</ul>\n")
-
-  // Blockquotes
-  html = html.replace(/^>\s+(.+)$/gm, "<blockquote>$1</blockquote>")
-
-  // Paragraphs (wrap remaining text blocks)
-  // Split by double newlines and wrap non-block elements
-  const blocks = html.split(/\n\n+/)
-  html = blocks
-    .map((block) => {
-      const trimmed = block.trim()
-      if (!trimmed) return ""
-      // Don't wrap if already a block element
-      if (
-        /^<(h[1-6]|ul|ol|li|pre|blockquote|hr|p)/.test(trimmed) ||
-        /^<\/?(h[1-6]|ul|ol|li|pre|blockquote)>$/.test(trimmed)
-      ) {
-        return trimmed
-      }
-      return `<p>${trimmed.replace(/\n/g, "<br>")}</p>`
-    })
-    .filter(Boolean)
-    .join("\n")
-
-  return html
-}
-
-// =============================================================================
-// File Reading Utilities
-// =============================================================================
-
-/**
- * Read just the markdown body from a file (skipping frontmatter).
- *
- * @param path - Path to the markdown file
- * @returns The raw markdown body
- */
-export async function readMarkdownBody(path: string): Promise<string> {
-  const file = Bun.file(path)
-  const content = await file.text()
-  const bodyOffset = getFrontmatterEndOffset(content)
-  return content.slice(bodyOffset).replace(/^\r?\n/, "")
-}
-
-/**
- * Read and parse markdown body from a file.
- *
- * @param path - Path to the markdown file
- * @param options - What to extract from the markdown
- * @returns The requested body parts
- */
-export async function readParsedBody(path: string, options: BodyOptions): Promise<BodyResult> {
-  const file = Bun.file(path)
-  const content = await file.text()
-  return parseMarkdownBody(content, options)
-}

package/src/path-pattern.ts

@@ -1,226 +0,0 @@
-/**
- * Path Pattern Parsing and Matching
- *
- * Parses patterns like `{year}/{slug}.md` and provides:
- * - Type-level extraction of parameters
- * - Glob pattern generation
- * - Path matching to extract params
- * - Path building from params
- */
-
-// =============================================================================
-// Type-level Parameter Extraction
-// =============================================================================
-
-/**
- * Extract params from a path pattern string at the type level.
- *
- * @example
- * type Params = ExtractParams<'{year}/{slug}.md'>
- * // = { year: string } & { slug: string }
- */
-export type ExtractParams<P extends string> = P extends `${string}{${infer Param}}${infer Rest}`
-  ? { [K in Param]: string } & ExtractParams<Rest>
-  : {}
-
-/**
- * Simplify a type by flattening intersections.
- * Converts { a: string } & { b: string } to { a: string; b: string }
- */
-export type Simplify<T> = { [K in keyof T]: T[K] }
-
-/**
- * Extract and simplify params from a path pattern.
- */
-export type PathParams<P extends string> = Simplify<ExtractParams<P>>
-
-// =============================================================================
-// Compiled Pattern Interface
-// =============================================================================
-
-/**
- * A compiled path pattern that can match paths and generate globs.
- */
-export interface CompiledPattern {
-  /**
-   * The original pattern string.
-   */
-  pattern: string
-
-  /**
-   * The extracted parameter names.
-   */
-  paramNames: string[]
-
-  /**
-   * Generate a glob pattern, optionally constraining specific params.
-   *
-   * @param constraints - Optional param values to use instead of wildcards
-   * @returns A glob pattern string
-   *
-   * @example
-   * pattern.toGlob()  // '** / *.md' (with {year}/{slug}.md)
-   * pattern.toGlob({ year: '2024' })  // '2024/*.md'
-   */
-  toGlob(constraints?: Record<string, unknown>): string
-
-  /**
-   * Match a path against this pattern and extract params.
-   *
-   * @param path - The file path to match (relative to base)
-   * @returns The extracted params, or null if no match
-   *
-   * @example
-   * pattern.match('2024/hello-world.md')  // { year: '2024', slug: 'hello-world' }
-   * pattern.match('invalid')  // null
-   */
-  match(path: string): Record<string, string> | null
-
-  /**
-   * Build a path from params.
-   *
-   * @param params - The param values
-   * @returns The constructed path
-   *
-   * @example
-   * pattern.build({ year: '2024', slug: 'hello' })  // '2024/hello.md'
-   */
-  build(params: Record<string, string>): string
-}
-
-// =============================================================================
-// Pattern Parsing
-// =============================================================================
-
-/**
- * Regex to match parameter placeholders in patterns.
- * Matches {paramName} where paramName is alphanumeric + underscores.
- */
-const PARAM_REGEX = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g
-
-/**
- * Characters that need escaping in regex.
- */
-const REGEX_ESCAPE = /[.*+?^${}()|[\]\\]/g
-
-/**
- * Compile a path pattern string into a usable pattern object.
- *
- * @param pattern - The pattern string like '{year}/{slug}.md'
- * @returns A CompiledPattern instance
- *
- * @example
- * const pattern = compilePattern('{year}/{slug}.md')
- * pattern.toGlob()  // '** / *.md'
- * pattern.match('2024/hello.md')  // { year: '2024', slug: 'hello' }
- */
-export function compilePattern(pattern: string): CompiledPattern {
-  // Extract all parameter names in order
-  const paramNames: string[] = []
-  let match: RegExpExecArray | null
-  const regex = new RegExp(PARAM_REGEX.source, "g")
-  while ((match = regex.exec(pattern)) !== null) {
-    paramNames.push(match[1])
-  }
-
-  // Build the match regex by replacing {param} with capturing groups
-  // Each param can match anything except path separators
-  const regexPattern = pattern
-    .replace(REGEX_ESCAPE, (char) => {
-      // Don't escape our param placeholders - we'll handle them separately
-      if (char === "{" || char === "}") return char
-      return "\\" + char
-    })
-    .replace(PARAM_REGEX, "([^/]+)")
-
-  const matchRegex = new RegExp(`^${regexPattern}$`)
-
-  return {
-    pattern,
-    paramNames,
-
-    toGlob(constraints?: Record<string, unknown>): string {
-      let glob = pattern
-
-      // Replace each param with either its constrained value or a wildcard
-      for (const name of paramNames) {
-        const value = constraints?.[name]
-        if (value !== undefined && value !== null) {
-          // Use the constrained value
-          glob = glob.replace(`{${name}}`, String(value))
-        } else {
-          // Use a wildcard - * matches anything except /
-          glob = glob.replace(`{${name}}`, "*")
-        }
-      }
-
-      return glob
-    },
-
-    match(path: string): Record<string, string> | null {
-      const result = matchRegex.exec(path)
-      if (!result) return null
-
-      const params: Record<string, string> = {}
-      for (let i = 0; i < paramNames.length; i++) {
-        params[paramNames[i]] = result[i + 1]
-      }
-      return params
-    },
-
-    build(params: Record<string, string>): string {
-      let result = pattern
-      for (const name of paramNames) {
-        const value = params[name]
-        if (value === undefined) {
-          throw new Error(`Missing required param: ${name}`)
-        }
-        result = result.replace(`{${name}}`, value)
-      }
-      return result
-    },
-  }
-}
-
-// =============================================================================
-// Schema for Path Params
-// =============================================================================
-
-/**
- * Create a StandardSchema for path params extracted from a pattern.
- * This is used by the resolver to expose scanParams to piq core.
- *
- * @param pattern - The compiled pattern
- * @returns A StandardSchema that validates param objects
- */
-export function createParamsSchema(
-  pattern: CompiledPattern
-): import("piqit").StandardSchema<Record<string, string>> {
-  return {
-    "~standard": {
-      version: 1,
-      vendor: "piqit/resolvers",
-      validate(value: unknown) {
-        if (value === null || typeof value !== "object") {
-          return {
-            issues: [{ message: "Expected object" }],
-          }
-        }
-
-        const obj = value as Record<string, unknown>
-
-        // All params should be strings if present
-        for (const name of pattern.paramNames) {
-          const val = obj[name]
-          if (val !== undefined && typeof val !== "string") {
-            return {
-              issues: [{ message: `Param ${name} must be a string`, path: [name] }],
-            }
-          }
-        }
-
-        return { value: obj as Record<string, string> }
-      },
-    },
-  }
-}