solid-mds 0.3.2 → 0.4.0

package/README.md

@@ -1,23 +1,26 @@
 # solid-mds
 
-A SolidJS library for parsing and rendering MDS (Markdown Steps) format — an
-extended Markdown syntax designed for step-based content like slide decks,
-tutorials, and wizards.
+A SolidJS library for transforming MDS (Markdown Steps) HAST to Solid components.
+
+This package works with [hast-mds](https://www.npmjs.com/package/hast-mds) to render step-based Markdown content in SolidJS applications.
 
 ## Installation
 
 ```bash
-npm install solid-mds
+npm install solid-mds hast-mds
 # or
-pnpm add solid-mds
+pnpm add solid-mds hast-mds
 ```
 
-**Peer dependency:** This library requires SolidJS ^1.9.0
+**Peer dependencies:**
+- `solid-js` ^1.9.0
+- `hast-mds` ^0.1.0
 
 ## Quick Start
 
 ```tsx
-import { parse } from "solid-mds";
+import { parse } from "hast-mds";
+import { transform } from "solid-mds";
 
 const markdown = `
 # Hello World
@@ -26,238 +29,106 @@ This is **bold** and *italic* text.
 `;
 
 function App() {
-  const result = parse(markdown);
-  return <div>{result.steps.default.body}</div>;
-}
-```
-
-## Opinionated Plugin Configuration
-
-solid-mds comes pre-configured with an opinionated set of remark/rehype plugins:
-
-- **[remark-gfm](https://github.com/remarkjs/remark-gfm)** — GitHub Flavored
-  Markdown (tables, strikethrough, autolinks, task lists)
-- **[remark-math](https://github.com/remarkjs/remark-math)** +
-  **[rehype-katex](https://github.com/remarkjs/rehype-katex)** — LaTeX math
-  rendering
-
-These plugins are always enabled and cannot be configured. This ensures
-consistent rendering across all use cases.
-
-**Note:** To display math properly, include the KaTeX CSS in your app:
-
-```html
-<link
-  rel="stylesheet"
-  href="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/katex.min.css"
-/>
-```
-
-## Supported Markdown Features
-
-### Standard Markdown
-
-```markdown
-# Heading 1
-
-## Heading 2
-
-### Heading 3
-
-**bold** and _italic_ and ~~strikethrough~~
-
-- Unordered list
-- Another item
-
-1. Ordered list
-2. Second item
-
-> Blockquotes
-
-`inline code`
-
-[Links](https://example.com)
-
-![Images](image.png)
-```
-
-### GFM Extensions
-
-#### Tables
-
-```markdown
-| Header 1 | Header 2 |
-| -------- | -------- |
-| Cell 1   | Cell 2   |
-| Cell 3   | Cell 4   |
-```
+  const parsed = parse(markdown);
+  const result = transform(parsed);
 
-#### Task Lists
-
-```markdown
-- [x] Completed task
-- [ ] Incomplete task
+  return <div>{result.steps.default.Body()}</div>;
+}
 ```
 
-#### Autolinks
+## Architecture
 
-```markdown
-Visit https://example.com automatically linked.
-```
+solid-mds is designed as a thin transformation layer:
 
-### Math (LaTeX)
+1. **hast-mds** parses your MDS content into HAST (Hypertext Abstract Syntax Tree)
+2. **solid-mds** transforms HAST into renderable Solid components
 
-#### Inline Math
+This separation allows:
+- Framework-agnostic parsing (use hast-mds with React, Vue, etc.)
+- Optimized Solid rendering with SSR support
 
-```markdown
-The equation $E = mc^2$ is famous.
-```
+## MDS Format
 
-#### Block Math
+MDS (Markdown Steps) extends Markdown with step-based structure.
 
-```markdown
-$$
-\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}
-$$
-```
-
-## MDS Format: Steps
-
-MDS extends Markdown with a step-based structure using `+++stepId` separators:
+### Step Separators
 
 ```markdown
 +++intro
 # Welcome
 
-This is the introduction step.
-
-+++
-
-main
+This is the introduction.
 
++++main
 # Main Content
 
-This is the main step.
-
 +++conclusion
-
 # Summary
-
-This is the conclusion.
 ```
 
-### Parsing Steps
-
-```tsx
-import { parse } from "solid-mds";
-
-const result = parse(markdown);
-
-// result.first → "intro" (first step ID)
-// result.count → 3 (number of steps)
-// result.steps.intro.body → JSX.Element
-// result.steps.intro.next → "main"
-// result.steps.main.prev → "intro"
-// result.steps.main.next → "conclusion"
-// result.steps.conclusion.prev → "main"
-// result.steps.conclusion.next → null
-```
+### Metadata Blocks
 
-### Step Object Structure
+#### Global Metadata
 
-Each step contains:
+```markdown
+\`\`\`yaml @@
+title: My Presentation
+author: Jane Doe
+\`\`\`
 
-```ts
-interface Step {
-  id: string; // Step identifier
-  body: JSX.Element; // Rendered markdown content
-  local: object; // Local metadata (see below)
-  prev: string | null; // Previous step ID
-  next: string | null; // Next step ID
-  current: number; // 1-based position
-}
++++intro
+# Content
 ```
 
-## Metadata Blocks
-
-### Local Metadata (per step)
+Access via `result.global.title`.
 
-Use ` ```@| ` blocks to define key-value metadata for a step:
+#### Global Markdown Blocks
 
-````markdown
-+++slide1
+```markdown
+\`\`\`md @@/footer
+Made with **love**
+\`\`\`
 
-```@|
-title: Introduction
-speaker: John Doe
++++intro
+# Content
 ```
 
-# Welcome to the Presentation
-````
-
-Access via `result.steps.slide1.local.title`.
-
-### Local Markdown Blocks
+Access via `result.global.footer` (returns Solid component).
 
-Use ` ```@/name ` to define named markdown content within a step:
+#### Local Metadata (per step)
 
-````markdown
+```markdown
 +++slide1
+\`\`\`yaml @
+layout: centered
+transition: fade
+\`\`\`
 
-```@/notes
-These are speaker notes with **formatting**.
-```
-
-# Main Slide Content
-````
-
-Access via `result.steps.slide1.local.notes` (returns `JSX.Element`).
-
-### Global Metadata
-
-Use ` ```@@| ` for document-wide metadata:
-
-````markdown
-```@@|
-author: Jane Smith
-version: 1.0
+# Slide Content
 ```
 
-+++first
-
-# First Step
-````
-
-Access via `result.global.author`.
+Access via `result.steps.slide1.local.layout`.
 
-### Global Markdown Blocks
+#### Local Markdown Blocks
 
-Use ` ```@@/name ` for global named markdown content:
+```markdown
++++slide1
+\`\`\`md @/notes
+Speaker **notes** here.
+\`\`\`
 
-````markdown
-```@@/footer
-Made with ❤️ by **Our Team**
+# Main Content
 ```
 
-+++first
-
-# Content
-````
-
-Access via `result.global.footer` (returns `JSX.Element`).
+Access via `result.steps.slide1.local.notes` (returns Solid component).
 
 ## Custom Components
 
-Override default HTML elements or create custom block components:
-
 ### Override Standard Elements
 
 ```tsx
-import {
-  parse,
-  ComponentMap,
-  StandardComponentProps,
-} from "solid-mds";
+import { parse } from "hast-mds";
+import { transform, ComponentMap, StandardComponentProps } from "solid-mds";
 
 const CustomHeading = (props: StandardComponentProps) => (
   <h1 class="text-4xl font-bold text-blue-600">{props.children}</h1>
@@ -267,17 +138,18 @@ const components: ComponentMap = {
   h1: CustomHeading,
 };
 
-const result = parse(markdown, components);
+const parsed = parse(markdown);
+const result = transform(parsed, components);
 ```
 
-### Custom Blocks
+### Custom Block Components
 
-Create custom components that receive special props from code blocks:
+Create custom components using `yaml componentName` or `md componentName/path` syntax:
 
 ```tsx
-import { parse, ComponentMap, CustomBlockProps } from "solid-mds";
+import { parse } from "hast-mds";
+import { transform, ComponentMap, CustomBlockProps } from "solid-mds";
 
-// Define a custom component
 const Alert = (props: CustomBlockProps) => (
   <div class={`alert alert-${props.payload[0] || "info"}`}>
     {props.children}
@@ -289,25 +161,17 @@ const components: ComponentMap = {
 };
 
 const markdown = `
-\`\`\`alert/warning
+\`\`\`md alert/warning
 This is a **warning** message!
 \`\`\`
 `;
 
-const result = parse(markdown, components);
+// Register component names when parsing
+const parsed = parse(markdown, new Set(["alert"]));
+const result = transform(parsed, components);
 ```
 
-The code block ` ```slert/warning ` will render using your `Alert` component
-with:
-
-- `props.payload` → `["warning"]` (path segments after component name)
-- `props.raw` → `"This is a **warning** message!"` (raw content as string if you
-  need it)
-- `props.children` → Rendered markdown as JSX
-
-### Custom Blocks with Data
-
-Use the `|` suffix for YAML data instead of markdown content:
+### Custom Blocks with YAML Data
 
 ```tsx
 const Card = (props: CustomBlockProps) => (
@@ -317,30 +181,25 @@ const Card = (props: CustomBlockProps) => (
   </div>
 );
 
-const components: ComponentMap = { Card };
+const components: ComponentMap = { card: Card };
 
 const markdown = `
-\`\`\`Card|
-title: My Card Title
-description: This is the card description
+\`\`\`yaml card
+title: My Card
+description: Card content here
 \`\`\`
 `;
 
-const result = parse(markdown, components);
+const parsed = parse(markdown, new Set(["card"]));
+const result = transform(parsed, components);
 ```
 
-With ` ```Card| `, the content is parsed as YAML and available via `props.data`.
-
 ## Complete Example
 
 ```tsx
-import { createSignal, Show, For } from "solid-js";
-import {
-  parse,
-  ComponentMap,
-  CustomBlockProps,
-  StandardComponentProps,
-} from "solid-mds";
+import { createSignal, Show } from "solid-js";
+import { parse } from "hast-mds";
+import { transform, ComponentMap, CustomBlockProps, StandardComponentProps } from "solid-mds";
 
 // Custom components
 const Slide = (props: CustomBlockProps) => (
@@ -356,19 +215,18 @@ const Code = (props: StandardComponentProps) => (
 );
 
 const components: ComponentMap = {
-  Slide,
+  slide: Slide,
   code: Code,
 };
 
-// Markdown content
 const content = `
-\`\`\`@@|
+\`\`\`yaml @@
 title: My Presentation
 author: Developer
 \`\`\`
 
 +++intro
-\`\`\`@|
+\`\`\`yaml @
 transition: fade
 \`\`\`
 
@@ -377,24 +235,19 @@ transition: fade
 Introduction slide content.
 
 +++demo
-\`\`\`Slide/centered
+\`\`\`md slide/centered
 # Demo Time
 
-Check out this code:
-
-\`\`\`js
-console.log("Hello!");
-\`\`\`
+Check out this code!
 \`\`\`
 
 +++end
 # Thank You!
-
-Questions?
 `;
 
 function Presentation() {
-  const result = parse(content, components);
+  const parsed = parse(content, new Set(["slide"]));
+  const result = transform(parsed, components);
   const [currentId, setCurrentId] = createSignal(result.first);
 
   const currentStep = () => result.steps[currentId()!];
@@ -417,7 +270,9 @@ function Presentation() {
       </header>
 
       <main>
-        <Show when={currentStep()}>{currentStep().body}</Show>
+        <Show when={currentStep()}>
+          {currentStep().Body()}
+        </Show>
       </main>
 
       <footer>
@@ -438,24 +293,32 @@ function Presentation() {
 
 ## API Reference
 
-### `parse<TGlobal, TLocal>(input: string, components?: ComponentMap): ParseResult`
+### `transform<TGlobal, TLocal>(parsed, components?): ParseResult`
 
-Parses MDS content and returns a structured result. Please provide proper types
-for your global and local scope to receive a properly typed result.
+Transforms parsed MDS content (HAST) into Solid components.
 
 **Parameters:**
 
-- `input` — The MDS/Markdown string to parse
-- `components` — Optional map of custom components
+- `parsed` — Result from `hast-mds` parse() function
+- `components` — Optional map of custom Solid components
 
 **Returns:**
 
 ```ts
 interface ParseResult<TGlobal, TLocal> {
-  first: string | null; // First step ID
+  first: string | null;              // First step ID
   steps: Record<string, Step<TLocal>>; // All steps by ID
-  count: number; // Total number of steps
-  global: TGlobal | null; // Global metadata
+  count: number;                     // Total number of steps
+  global: TGlobal | null;            // Global metadata
+}
+
+interface Step<TLocal> {
+  id: string;
+  local: TLocal;
+  Body: Component;      // Call as Body() to render
+  prev: string | null;
+  next: string | null;
+  current: number;
 }
 ```
 
@@ -468,9 +331,68 @@ import type {
   StandardComponentProps,
   ParseResult,
   Step,
+  // Re-exported from hast-mds
+  HastParseResult,
+  HastStep,
+  HastBody,
+  CustomComponents,
 } from "solid-mds";
 ```
 
+## Migration from v0.3.x
+
+### Breaking Changes
+
+1. **New API**: `parse()` is replaced by `transform()`
+2. **Requires hast-mds**: Install and use `hast-mds` for parsing
+3. **Syntax changes**: Old block syntax is no longer supported
+
+### Before (v0.3.x)
+
+```tsx
+import { parse } from "solid-mds";
+
+const result = parse(markdown, components);
+```
+
+### After (v0.4.0)
+
+```tsx
+import { parse } from "hast-mds";
+import { transform } from "solid-mds";
+
+const parsed = parse(markdown, new Set(Object.keys(components)));
+const result = transform(parsed, components);
+```
+
+### Syntax Changes
+
+| Old Syntax | New Syntax |
+|------------|------------|
+| ` ```@@\| ` | ` ```yaml @@ ` |
+| ` ```@\| ` | ` ```yaml @ ` |
+| ` ```@@/name ` | ` ```md @@/name ` |
+| ` ```@/name ` | ` ```md @/name ` |
+| ` ```componentName\| ` | ` ```yaml componentName ` |
+| ` ```componentName/path ` | ` ```md componentName/path ` |
+
+## Markdown Features
+
+solid-mds (via hast-mds) supports:
+
+- **Standard Markdown**: Headings, bold, italic, links, images, lists, blockquotes, code
+- **GFM**: Tables, task lists, strikethrough, autolinks
+- **Math**: LaTeX via KaTeX (`$inline$` and `$$block$$`)
+
+For math rendering, include KaTeX CSS:
+
+```html
+<link
+  rel="stylesheet"
+  href="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/katex.min.css"
+/>
+```
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { HastParseResult } from 'hast-mds';
+export { CustomComponents, HastBody, HastParseResult, HastStep } from 'hast-mds';
 import { Component, JSX } from 'solid-js';
 
 /**
@@ -24,27 +26,73 @@ type ComponentMap = {
     [tagName: string]: Component<CustomBlockProps> | Component<StandardComponentProps>;
 };
 
+/**
+ * Base interface for step-local metadata.
+ * Users can extend this with their own types.
+ */
 interface StepLocalBase {
     [key: string]: unknown;
 }
+/**
+ * Base interface for global metadata.
+ * Users can extend this with their own types.
+ */
 interface GlobalMetaBase {
     [key: string]: unknown;
 }
+/**
+ * A single step in the MDS document with Solid components.
+ */
 interface Step<TLocal = StepLocalBase> {
+    /** Unique identifier for the step */
     id: string;
+    /** Step-specific metadata (YAML values and markdown blocks as Components) */
     local: TLocal;
     /** Component function that renders the step body. Call it to get JSX: {step.Body()} */
     Body: Component;
+    /** ID of the previous step, or null if first */
     prev: string | null;
+    /** ID of the next step, or null if last */
     next: string | null;
+    /** 1-based position of this step */
     current: number;
 }
+/**
+ * Result of transforming an MDS document to Solid components.
+ */
 interface ParseResult<TGlobal = GlobalMetaBase, TLocal = StepLocalBase> {
+    /** ID of the first step, or null if no steps */
     first: string | null;
+    /** Map of step IDs to step objects */
     steps: Record<string, Step<TLocal>>;
+    /** Total number of steps */
     count: number;
+    /** Global metadata (YAML values and markdown blocks as Components) */
     global: TGlobal | null;
 }
-declare function parse<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(input: string, components?: ComponentMap): ParseResult<TGlobal, TLocal>;
 
-export { type ComponentMap, type CustomBlockProps, type GlobalMetaBase, type ParseResult, type StandardComponentProps, type Step, type StepLocalBase, parse };
+/**
+ * Transform a parsed MDS document (HAST) into Solid components.
+ *
+ * This function takes the output from `hast-mds` parse() and converts all
+ * HAST trees into renderable Solid components.
+ *
+ * @example
+ * ```typescript
+ * import { parse } from "hast-mds";
+ * import { transform } from "solid-mds";
+ *
+ * const parsed = parse(mdsString, new Set(["quiz", "card"]));
+ * const result = transform(parsed, { quiz: QuizComponent, card: CardComponent });
+ *
+ * // Use in Solid component:
+ * <div>{result.steps.intro.Body()}</div>
+ * ```
+ *
+ * @param parsed - The result from hast-mds parse() function
+ * @param components - Optional map of custom Solid components
+ * @returns ParseResult with Solid components
+ */
+declare function transform<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(parsed: HastParseResult<TGlobal, TLocal>, components?: ComponentMap): ParseResult<TGlobal, TLocal>;
+
+export { type ComponentMap, type CustomBlockProps, type GlobalMetaBase, type ParseResult, type StandardComponentProps, type Step, type StepLocalBase, transform };

package/dist/index.jsx

@@ -1,12 +1,3 @@
-// src/index.tsx
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm from "remark-gfm";
-import remarkMath from "remark-math";
-import remarkRehype from "remark-rehype";
-import rehypeKatex from "rehype-katex";
-import { parse as parseYaml2 } from "yaml";
-
 // src/hast-to-solid.tsx
 function convertProperties(properties) {
   if (!properties) return {};
@@ -196,207 +187,48 @@ function hastToSolidComponent(hastTree, components = {}) {
   };
 }
 
-// src/remark-custom-blocks.ts
-import { visit } from "unist-util-visit";
-import { parse as parseYaml } from "yaml";
-function remarkCustomBlocks(options) {
-  const { components, processor } = options;
-  return (tree) => {
-    visit(tree, "code", (node, index, parent) => {
-      if (!parent || index === void 0) return;
-      const lang = node.lang;
-      if (!lang) return;
-      const isDataBlock = lang.endsWith("|");
-      const cleanLang = isDataBlock ? lang.slice(0, -1) : lang;
-      const segments = cleanLang.split("/");
-      const componentName = segments[0];
-      const raw = node.value;
-      if (!components.has(componentName)) return;
-      const payload = segments.slice(1);
-      if (isDataBlock) {
-        const data = parseYaml(raw);
-        const customNode2 = {
-          type: "customBlock",
-          data: {
-            hName: componentName,
-            hProperties: {
-              payload: JSON.stringify(payload),
-              raw,
-              data: JSON.stringify(data)
-            }
-          },
-          children: []
-        };
-        parent.children[index] = customNode2;
-        return;
-      }
-      const contentMdast = processor.parse(raw);
-      const customNode = {
-        type: "customBlock",
-        data: {
-          hName: componentName,
-          hProperties: {
-            payload: JSON.stringify(payload),
-            raw
-          }
-        },
-        children: contentMdast.children
-      };
-      parent.children[index] = customNode;
-    });
-  };
-}
-
 // src/index.tsx
-function parseLocalMeta(content, processor, components) {
-  const metaPattern = /```@\|\s*\n([\s\S]*?)```\s*\n?/g;
-  let match;
-  let local = {};
-  let body = content;
-  while ((match = metaPattern.exec(content)) !== null) {
-    const parsed = parseYaml2(match[1]);
-    local = { ...local, ...parsed };
-  }
-  body = content.replace(metaPattern, "").trim();
-  const localMdPattern = /```@\/(\w+)\s*\n([\s\S]*?)```\s*\n?/g;
-  const localMdBlocks = {};
-  while ((match = localMdPattern.exec(body)) !== null) {
-    const name = match[1];
-    const content2 = match[2].trim();
-    if (localMdBlocks[name]) {
-      localMdBlocks[name] += "\n\n" + content2;
-    } else {
-      localMdBlocks[name] = content2;
-    }
-  }
-  body = body.replace(localMdPattern, "").trim();
-  for (const [name, mdContent] of Object.entries(localMdBlocks)) {
-    const mdast = processor.parse(mdContent);
-    const hastTree = processor.runSync(mdast);
-    local[name] = hastToSolidComponent(hastTree, components);
-  }
-  return { local, body };
+function isHastBody(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "hast" && "node" in value;
 }
-function parseGlobalMeta(input, processor, components) {
-  const globalDataPattern = /```@@\|\s*\n([\s\S]*?)```/g;
-  let match;
-  let global = {};
-  while ((match = globalDataPattern.exec(input)) !== null) {
-    const parsed = parseYaml2(match[1]);
-    global = { ...global, ...parsed };
-  }
-  const globalMdPattern = /```@@\/(\w+)\s*\n([\s\S]*?)```/g;
-  const globalMdBlocks = {};
-  while ((match = globalMdPattern.exec(input)) !== null) {
-    const name = match[1];
-    const content = match[2].trim();
-    if (globalMdBlocks[name]) {
-      globalMdBlocks[name] += "\n\n" + content;
+function transformMetadata(metadata, components) {
+  if (metadata === null) return null;
+  const result = {};
+  for (const [key, value] of Object.entries(
+    metadata
+  )) {
+    if (isHastBody(value)) {
+      result[key] = hastToSolidComponent(value.node, components);
     } else {
-      globalMdBlocks[name] = content;
+      result[key] = value;
     }
   }
-  for (const [name, mdContent] of Object.entries(globalMdBlocks)) {
-    const mdast = processor.parse(mdContent);
-    const hastTree = processor.runSync(mdast);
-    global[name] = hastToSolidComponent(hastTree, components);
-  }
-  return Object.keys(global).length > 0 ? global : null;
-}
-function isInsideCodeBlock(input, position) {
-  const beforeText = input.slice(0, position);
-  const fencePattern = /^```/gm;
-  let fenceCount = 0;
-  let match;
-  while ((match = fencePattern.exec(beforeText)) !== null) {
-    fenceCount++;
-  }
-  return fenceCount % 2 === 1;
-}
-var VALID_ID_PATTERN = /^[a-z0-9-]+$/;
-function validateStepId(id, lineNumber) {
-  if (!VALID_ID_PATTERN.test(id)) {
-    throw new Error(
-      `Invalid step ID "${id}" at line ${lineNumber}. Step IDs must only contain lowercase letters (a-z), numbers (0-9), and hyphens (-).`
-    );
-  }
+  return result;
 }
-function parse(input, components = {}) {
-  const stepPattern = /^\+\+\+(.+)$/gm;
+function transform(parsed, components = {}) {
   const steps = {};
-  const componentNames = new Set(Object.keys(components));
-  const baseProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkMath);
-  const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMath).use(remarkCustomBlocks, {
-    components: componentNames,
-    processor: baseProcessor
-  }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeKatex);
-  const global = parseGlobalMeta(input, processor, components);
-  let match;
-  const matches = [];
-  while ((match = stepPattern.exec(input)) !== null) {
-    if (!isInsideCodeBlock(input, match.index)) {
-      const id = match[1].trim();
-      const lineNumber = input.slice(0, match.index).split("\n").length;
-      validateStepId(id, lineNumber);
-      matches.push({ id, index: match.index });
-    }
-  }
-  if (matches.length === 0) {
-    const { local, body: markdown } = parseLocalMeta(
-      input.trim(),
-      processor,
-      components
-    );
-    const mdast = processor.parse(markdown);
-    const hastTree = processor.runSync(mdast);
-    const Body = hastToSolidComponent(hastTree, components);
-    steps["default"] = {
-      id: "default",
-      local,
-      Body,
-      prev: null,
-      next: null,
-      current: 1
-    };
-    return {
-      first: "default",
-      steps,
-      count: 1,
-      global
-    };
-  }
-  for (let i = 0; i < matches.length; i++) {
-    const current = matches[i];
-    const nextMatch = matches[i + 1];
-    const prevMatch = matches[i - 1];
-    const startIndex = current.index + `+++${current.id}`.length;
-    const endIndex = nextMatch ? nextMatch.index : input.length;
-    const rawContent = input.slice(startIndex, endIndex).trim();
-    const { local, body: markdown } = parseLocalMeta(
-      rawContent,
-      processor,
-      components
-    );
-    const mdast = processor.parse(markdown);
-    const hastTree = processor.runSync(mdast);
-    const Body = hastToSolidComponent(hastTree, components);
-    steps[current.id] = {
-      id: current.id,
-      local,
+  for (const id of Object.keys(parsed.steps)) {
+    const hastStep = parsed.steps[id];
+    const Body = hastToSolidComponent(hastStep.body.node, components);
+    const transformedLocal = transformMetadata(hastStep.local, components);
+    steps[id] = {
+      id: hastStep.id,
+      local: transformedLocal,
       Body,
-      prev: prevMatch ? prevMatch.id : null,
-      next: nextMatch ? nextMatch.id : null,
-      current: i + 1
+      prev: hastStep.prev,
+      next: hastStep.next,
+      current: hastStep.current
     };
   }
+  const transformedGlobal = transformMetadata(parsed.global, components);
   return {
-    first: matches.length > 0 ? matches[0].id : null,
+    first: parsed.first,
     steps,
-    count: matches.length,
-    global
+    count: parsed.count,
+    global: transformedGlobal
   };
 }
 export {
-  parse
+  transform
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.tsx", "../src/hast-to-solid.tsx", "../src/remark-custom-blocks.ts"],
  "sourcesContent": ["import { Component, JSX } from \"solid-js\";\nimport { unified, type Processor } from \"unified\";\nimport remarkParse from \"remark-parse\";\nimport remarkGfm from \"remark-gfm\";\nimport remarkMath from \"remark-math\";\nimport remarkRehype from \"remark-rehype\";\nimport rehypeKatex from \"rehype-katex\";\nimport { parse as parseYaml } from \"yaml\";\nimport type { Root } from \"hast\";\nimport {\n  hastToSolidJsx,\n  hastToSolidComponent,\n  ComponentMap,\n} from \"./hast-to-solid\";\nimport { remarkCustomBlocks } from \"./remark-custom-blocks\";\n\nexport type {\n  ComponentMap,\n  CustomBlockProps,\n  StandardComponentProps,\n} from \"./hast-to-solid\";\n\nexport interface StepLocalBase {\n  [key: string]: unknown;\n}\n\nexport interface GlobalMetaBase {\n  [key: string]: unknown;\n}\n\nexport interface Step<TLocal = StepLocalBase> {\n  id: string;\n  local: TLocal;\n  /** Component function that renders the step body. Call it to get JSX: {step.Body()} */\n  Body: Component;\n  prev: string | null;\n  next: string | null;\n  current: number;\n}\n\nexport interface ParseResult<TGlobal = GlobalMetaBase, TLocal = StepLocalBase> {\n  first: string | null;\n  steps: Record<string, Step<TLocal>>;\n  count: number;\n  global: TGlobal | null;\n}\n\n\nfunction parseLocalMeta(\n  content: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>,\n  components: ComponentMap,\n): { local: StepLocalBase; body: string } {\n  // Match all local metadata blocks: ```@| ... ```\n  // Multiple blocks are merged, later values override earlier ones\n  const metaPattern = /```@\\|\\s*\\n([\\s\\S]*?)```\\s*\\n?/g;\n  let match: RegExpExecArray | null;\n  let local: StepLocalBase = {};\n  let body = content;\n\n  while ((match = metaPattern.exec(content)) !== null) {\n    const parsed = parseYaml(match[1]);\n    local = { ...local, ...parsed };\n  }\n\n  // Remove all metadata blocks from body\n  body = content.replace(metaPattern, \"\").trim();\n\n  // Match local md blocks: ```@/name ... ```\n  // These are markdown blocks that get rendered and stored in local[name]\n  const localMdPattern = /```@\\/(\\w+)\\s*\\n([\\s\\S]*?)```\\s*\\n?/g;\n  const localMdBlocks: Record<string, string> = {};\n\n  while ((match = localMdPattern.exec(body)) !== null) {\n    const name = match[1];\n    const content = match[2].trim();\n    // Concatenate if multiple blocks with same name\n    if (localMdBlocks[name]) {\n      localMdBlocks[name] += \"\\n\\n\" + content;\n    } else {\n      localMdBlocks[name] = content;\n    }\n  }\n\n  // Remove all local md blocks from body\n  body = body.replace(localMdPattern, \"\").trim();\n\n  // Convert all local md blocks to JSX\n  for (const [name, mdContent] of Object.entries(localMdBlocks)) {\n    const mdast = processor.parse(mdContent);\n    const hastTree = processor.runSync(mdast) as Root;\n    local[name] = hastToSolidComponent(hastTree, components);\n  }\n\n  return { local, body };\n}\n\nfunction parseGlobalMeta(\n  input: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>,\n  components: ComponentMap,\n): GlobalMetaBase | null {\n  // Match global data blocks: ```@@| ... ```\n  // Can appear anywhere in the document, may have multiple blocks\n  const globalDataPattern = /```@@\\|\\s*\\n([\\s\\S]*?)```/g;\n  let match: RegExpExecArray | null;\n  let global: GlobalMetaBase = {};\n\n  while ((match = globalDataPattern.exec(input)) !== null) {\n    const parsed = parseYaml(match[1]);\n    global = { ...global, ...parsed };\n  }\n\n  // Match global md blocks: ```@@/name ... ```\n  // These are markdown blocks that get rendered and stored in global[name]\n  const globalMdPattern = /```@@\\/(\\w+)\\s*\\n([\\s\\S]*?)```/g;\n  const globalMdBlocks: Record<string, string> = {};\n\n  while ((match = globalMdPattern.exec(input)) !== null) {\n    const name = match[1];\n    const content = match[2].trim();\n    // Concatenate if multiple blocks with same name\n    if (globalMdBlocks[name]) {\n      globalMdBlocks[name] += \"\\n\\n\" + content;\n    } else {\n      globalMdBlocks[name] = content;\n    }\n  }\n\n  // Convert all global md blocks to Components\n  for (const [name, mdContent] of Object.entries(globalMdBlocks)) {\n    const mdast = processor.parse(mdContent);\n    const hastTree = processor.runSync(mdast) as Root;\n    global[name] = hastToSolidComponent(hastTree, components);\n  }\n\n  return Object.keys(global).length > 0 ? global : null;\n}\n\nfunction isInsideCodeBlock(input: string, position: number): boolean {\n  // Find all code block fences before this position\n  const beforeText = input.slice(0, position);\n  const fencePattern = /^```/gm;\n  let fenceCount = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = fencePattern.exec(beforeText)) !== null) {\n    fenceCount++;\n  }\n\n  // If odd number of fences, we're inside a code block\n  return fenceCount % 2 === 1;\n}\n\nconst VALID_ID_PATTERN = /^[a-z0-9-]+$/;\n\nfunction validateStepId(id: string, lineNumber: number): void {\n  if (!VALID_ID_PATTERN.test(id)) {\n    throw new Error(\n      `Invalid step ID \"${id}\" at line ${lineNumber}. ` +\n        `Step IDs must only contain lowercase letters (a-z), numbers (0-9), and hyphens (-).`,\n    );\n  }\n}\n\nexport function parse<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(\n  input: string,\n  components: ComponentMap = {},\n): ParseResult<TGlobal, TLocal> {\n  // Capture everything after +++ until end of line\n  const stepPattern = /^\\+\\+\\+(.+)$/gm;\n  const steps: Record<string, Step<TLocal>> = {};\n  const componentNames = new Set(Object.keys(components));\n  const baseProcessor = unified()\n    .use(remarkParse)\n    .use(remarkGfm)\n    .use(remarkMath);\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkGfm)\n    .use(remarkMath)\n    .use(remarkCustomBlocks, {\n      components: componentNames,\n      processor: baseProcessor,\n    })\n    .use(remarkRehype, { allowDangerousHtml: true })\n    .use(rehypeKatex);\n  const global = parseGlobalMeta(input, processor, components);\n\n  let match: RegExpExecArray | null;\n  const matches: { id: string; index: number }[] = [];\n\n  while ((match = stepPattern.exec(input)) !== null) {\n    // Skip this match if it's inside a code block\n    if (!isInsideCodeBlock(input, match.index)) {\n      const id = match[1].trim();\n      // Calculate line number for error messages\n      const lineNumber = input.slice(0, match.index).split(\"\\n\").length;\n      validateStepId(id, lineNumber);\n      matches.push({ id, index: match.index });\n    }\n  }\n\n  // If no separators found, treat the entire input as a single \"default\" step\n  if (matches.length === 0) {\n    const { local, body: markdown } = parseLocalMeta(\n      input.trim(),\n      processor,\n      components,\n    );\n\n    const mdast = processor.parse(markdown);\n    const hastTree = processor.runSync(mdast) as Root;\n    const Body = hastToSolidComponent(hastTree, components);\n\n    steps[\"default\"] = {\n      id: \"default\",\n      local: local as TLocal,\n      Body,\n      prev: null,\n      next: null,\n      current: 1,\n    };\n\n    return {\n      first: \"default\",\n      steps,\n      count: 1,\n      global: global as TGlobal | null,\n    };\n  }\n\n  for (let i = 0; i < matches.length; i++) {\n    const current = matches[i];\n    const nextMatch = matches[i + 1];\n    const prevMatch = matches[i - 1];\n\n    const startIndex = current.index + `+++${current.id}`.length;\n    const endIndex = nextMatch ? nextMatch.index : input.length;\n\n    const rawContent = input.slice(startIndex, endIndex).trim();\n    const { local, body: markdown } = parseLocalMeta(\n      rawContent,\n      processor,\n      components,\n    );\n\n    const mdast = processor.parse(markdown);\n    const hastTree = processor.runSync(mdast) as Root;\n    const Body = hastToSolidComponent(hastTree, components);\n\n    steps[current.id] = {\n      id: current.id,\n      local: local as TLocal,\n      Body,\n      prev: prevMatch ? prevMatch.id : null,\n      next: nextMatch ? nextMatch.id : null,\n      current: i + 1,\n    };\n  }\n\n  return {\n    first: matches.length > 0 ? matches[0].id : null,\n    steps,\n    count: matches.length,\n    global: global as TGlobal | null,\n  };\n}\n", "import { JSX, Component, children as resolveChildren } from \"solid-js\";\nimport type { Root, Element, Text, RootContent } from \"hast\";\n\n/**\n * Props for custom block components (code blocks with name/sub/path syntax)\n */\nexport interface CustomBlockProps {\n  /** The path segments after the component name, e.g. ['substructure', 'subsub'] */\n  payload: string[];\n  /** The raw content of the code block as plain text */\n  raw: string;\n  /** Parsed YAML data when using componentName| syntax */\n  data?: Record<string, string | string[]>;\n  /** The markdown-rendered content as children */\n  children?: JSX.Element;\n}\n\n/**\n * Standard component props for regular HTML elements\n */\nexport interface StandardComponentProps {\n  children?: JSX.Element;\n  [key: string]: unknown;\n}\n\nexport type ComponentMap = {\n  [tagName: string]: Component<CustomBlockProps> | Component<StandardComponentProps>;\n};\n\nfunction convertProperties(\n  properties: Record<string, unknown> | undefined\n): Record<string, unknown> {\n  if (!properties) return {};\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(properties)) {\n    if (key === \"className\") {\n      result.class = value;\n    } else if (key === \"class\") {\n      result.class = Array.isArray(value) ? value.join(\" \") : value;\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\nfunction renderElement(\n  tagName: string,\n  props: Record<string, unknown>,\n  children: JSX.Element\n): JSX.Element {\n  switch (tagName) {\n    case \"p\":\n      return <p {...props}>{children}</p>;\n    case \"h1\":\n      return <h1 {...props}>{children}</h1>;\n    case \"h2\":\n      return <h2 {...props}>{children}</h2>;\n    case \"h3\":\n      return <h3 {...props}>{children}</h3>;\n    case \"h4\":\n      return <h4 {...props}>{children}</h4>;\n    case \"h5\":\n      return <h5 {...props}>{children}</h5>;\n    case \"h6\":\n      return <h6 {...props}>{children}</h6>;\n    case \"div\":\n      return <div {...props}>{children}</div>;\n    case \"span\":\n      return <span {...props}>{children}</span>;\n    case \"a\":\n      return <a {...props}>{children}</a>;\n    case \"strong\":\n      return <strong {...props}>{children}</strong>;\n    case \"b\":\n      return <b {...props}>{children}</b>;\n    case \"em\":\n      return <em {...props}>{children}</em>;\n    case \"i\":\n      return <i {...props}>{children}</i>;\n    case \"code\":\n      return <code {...props}>{children}</code>;\n    case \"pre\":\n      return <pre {...props}>{children}</pre>;\n    case \"blockquote\":\n      return <blockquote {...props}>{children}</blockquote>;\n    case \"ul\":\n      return <ul {...props}>{children}</ul>;\n    case \"ol\":\n      return <ol {...props}>{children}</ol>;\n    case \"li\":\n      return <li {...props}>{children}</li>;\n    case \"hr\":\n      return <hr {...props} />;\n    case \"br\":\n      return <br {...props} />;\n    case \"img\":\n      return <img {...props} />;\n    case \"table\":\n      return <table {...props}>{children}</table>;\n    case \"thead\":\n      return <thead {...props}>{children}</thead>;\n    case \"tbody\":\n      return <tbody {...props}>{children}</tbody>;\n    case \"tr\":\n      return <tr {...props}>{children}</tr>;\n    case \"th\":\n      return <th {...props}>{children}</th>;\n    case \"td\":\n      return <td {...props}>{children}</td>;\n    case \"del\":\n      return <del {...props}>{children}</del>;\n    case \"sup\":\n      return <sup {...props}>{children}</sup>;\n    case \"sub\":\n      return <sub {...props}>{children}</sub>;\n    // GFM elements\n    case \"input\":\n      return <input {...props} />;\n    case \"section\":\n      return <section {...props}>{children}</section>;\n    // KaTeX math elements\n    case \"math\":\n      return <math {...props}>{children}</math>;\n    case \"semantics\":\n      return <semantics {...props}>{children}</semantics>;\n    case \"mrow\":\n      return <mrow {...props}>{children}</mrow>;\n    case \"mi\":\n      return <mi {...props}>{children}</mi>;\n    case \"mo\":\n      return <mo {...props}>{children}</mo>;\n    case \"mn\":\n      return <mn {...props}>{children}</mn>;\n    case \"mfrac\":\n      return <mfrac {...props}>{children}</mfrac>;\n    case \"msup\":\n      return <msup {...props}>{children}</msup>;\n    case \"msub\":\n      return <msub {...props}>{children}</msub>;\n    case \"msubsup\":\n      return <msubsup {...props}>{children}</msubsup>;\n    case \"msqrt\":\n      return <msqrt {...props}>{children}</msqrt>;\n    case \"mroot\":\n      return <mroot {...props}>{children}</mroot>;\n    case \"munder\":\n      return <munder {...props}>{children}</munder>;\n    case \"mover\":\n      return <mover {...props}>{children}</mover>;\n    case \"munderover\":\n      return <munderover {...props}>{children}</munderover>;\n    case \"mtable\":\n      return <mtable {...props}>{children}</mtable>;\n    case \"mtr\":\n      return <mtr {...props}>{children}</mtr>;\n    case \"mtd\":\n      return <mtd {...props}>{children}</mtd>;\n    case \"mtext\":\n      return <mtext {...props}>{children}</mtext>;\n    case \"mspace\":\n      return <mspace {...props}>{children}</mspace>;\n    case \"annotation\":\n      return <annotation {...props}>{children}</annotation>;\n    case \"svg\":\n      return <svg {...props}>{children}</svg>;\n    case \"path\":\n      return <path {...props} />;\n    case \"line\":\n      return <line {...props} />;\n    case \"rect\":\n      return <rect {...props} />;\n    case \"circle\":\n      return <circle {...props} />;\n    case \"g\":\n      return <g {...props}>{children}</g>;\n    case \"defs\":\n      return <defs {...props}>{children}</defs>;\n    case \"clipPath\":\n      return <clipPath {...props}>{children}</clipPath>;\n    case \"use\":\n      return <use {...props} />;\n    default:\n      return <div {...props}>{children}</div>;\n  }\n}\n\nfunction renderNode(\n  node: RootContent,\n  components: ComponentMap\n): JSX.Element | string | null {\n  if (node.type === \"text\") {\n    return (node as Text).value;\n  }\n\n  if (node.type === \"element\") {\n    const element = node as Element;\n    const tagName = element.tagName;\n    const rawProps = convertProperties(element.properties);\n    const CustomComponent = components[tagName];\n\n    const childElements =\n      element.children.length > 0\n        ? element.children.map((child) => renderNode(child, components))\n        : null;\n\n    if (CustomComponent) {\n      // Check if this is a custom block component (has payload and raw props)\n      if (typeof rawProps.payload === \"string\" && typeof rawProps.raw === \"string\") {\n        // Deserialize payload from JSON string\n        const customBlockProps: CustomBlockProps = {\n          payload: JSON.parse(rawProps.payload as string),\n          raw: rawProps.raw as string,\n        };\n        // Add data if present (for componentName| syntax)\n        if (typeof rawProps.data === \"string\") {\n          customBlockProps.data = JSON.parse(rawProps.data as string);\n        }\n        const Comp = CustomComponent as Component<CustomBlockProps>;\n        return <Comp {...customBlockProps}>{childElements}</Comp>;\n      }\n      const Comp = CustomComponent as Component<StandardComponentProps>;\n      return <Comp {...rawProps}>{childElements}</Comp>;\n    }\n\n    return renderElement(tagName, rawProps, childElements as JSX.Element);\n  }\n\n  return null;\n}\n\nexport function hastToSolidJsx(\n  hastTree: Root,\n  components: ComponentMap = {}\n): JSX.Element {\n  const elements = hastTree.children.map((node) => renderNode(node, components));\n  return <>{elements}</>;\n}\n\n/**\n * Returns a component function that renders the HAST tree when called.\n * This defers JSX element creation until render time, which is important\n * for SSR hydration to work correctly.\n *\n * We serialize the HAST tree and components info so that the exact same\n * rendering logic runs on both server and client.\n */\nexport function hastToSolidComponent(\n  hastTree: Root,\n  components: ComponentMap = {}\n): () => JSX.Element {\n  // Store the tree data, not pre-rendered elements\n  const treeData = hastTree;\n  const componentMap = components;\n\n  return function HastBody() {\n    const elements = treeData.children.map((node) => renderNode(node, componentMap));\n    return <>{elements}</>;\n  };\n}\n", "import type { Root, Code, Parent, RootContent } from \"mdast\";\nimport type { Processor } from \"unified\";\nimport { visit } from \"unist-util-visit\";\nimport { parse as parseYaml } from \"yaml\";\n\n/**\n * Component that receives custom block props\n */\nexport interface CustomBlockComponentProps {\n  /** The path segments after the component name, e.g. ['substructure', 'subsub'] */\n  payload: string[];\n  /** The raw content of the code block as plain text */\n  raw: string;\n  /** Parsed YAML data when using componentName| syntax */\n  data?: Record<string, unknown>;\n  /** The markdown-rendered content as children */\n  children?: unknown;\n}\n\n/**\n * Set of component names that are available\n */\nexport type CustomBlockComponents = Set<string>;\n\nexport interface RemarkCustomBlocksOptions {\n  /** Set of component names that are available */\n  components: CustomBlockComponents;\n  /** The processor to use for parsing nested markdown */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  processor: Processor<any, any, any, any, any>;\n}\n\n\n/**\n * A remark plugin that transforms code blocks with `name/path/segments` syntax\n * into custom block nodes that render with the specified component.\n *\n * Code blocks like:\n * ```componentName/sub/path\n * content here\n * ```\n *\n * Will be transformed to use the component if it exists in the components set,\n * otherwise they remain as regular code blocks.\n */\nexport function remarkCustomBlocks(options: RemarkCustomBlocksOptions) {\n  const { components, processor } = options;\n\n  return (tree: Root) => {\n    visit(tree, \"code\", (node: Code, index, parent: Parent | undefined) => {\n      if (!parent || index === undefined) return;\n\n      const lang = node.lang;\n      if (!lang) return;\n\n      // Check if this is a data block (lang ends with |)\n      const isDataBlock = lang.endsWith(\"|\");\n      const cleanLang = isDataBlock ? lang.slice(0, -1) : lang;\n\n      const segments = cleanLang.split(\"/\");\n      const componentName = segments[0];\n      const raw = node.value;\n\n      // If the component doesn't exist, leave it as a regular code block\n      if (!components.has(componentName)) return;\n\n      const payload = segments.slice(1);\n\n      // For data blocks, parse YAML instead of markdown\n      if (isDataBlock) {\n        const data = parseYaml(raw) as Record<string, unknown>;\n\n        const customNode = {\n          type: \"customBlock\",\n          data: {\n            hName: componentName,\n            hProperties: {\n              payload: JSON.stringify(payload),\n              raw,\n              data: JSON.stringify(data),\n            },\n          },\n          children: [],\n        };\n\n        parent.children[index] = customNode as unknown as RootContent;\n        return;\n      }\n\n      // Parse the content as markdown to get its AST\n      const contentMdast = processor.parse(raw) as Root;\n\n      // Create a custom element that will be converted to hast\n      // We use a custom node type that remark-rehype will handle\n      const customNode = {\n        type: \"customBlock\",\n        data: {\n          hName: componentName,\n          hProperties: {\n            payload: JSON.stringify(payload),\n            raw,\n          },\n        },\n        children: contentMdast.children,\n      };\n\n      // Replace the code node with our custom block\n      parent.children[index] = customNode as unknown as RootContent;\n    });\n  };\n}\n"],
  "mappings": "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",
  "names": ["parseYaml", "Comp", "customNode", "parseYaml", "content"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/hast-to-solid.tsx", "../src/index.tsx"],
  "sourcesContent": ["import { JSX, Component, children as resolveChildren } from \"solid-js\";\nimport type { Root, Element, Text, RootContent } from \"hast\";\n\n/**\n * Props for custom block components (code blocks with name/sub/path syntax)\n */\nexport interface CustomBlockProps {\n  /** The path segments after the component name, e.g. ['substructure', 'subsub'] */\n  payload: string[];\n  /** The raw content of the code block as plain text */\n  raw: string;\n  /** Parsed YAML data when using componentName| syntax */\n  data?: Record<string, string | string[]>;\n  /** The markdown-rendered content as children */\n  children?: JSX.Element;\n}\n\n/**\n * Standard component props for regular HTML elements\n */\nexport interface StandardComponentProps {\n  children?: JSX.Element;\n  [key: string]: unknown;\n}\n\nexport type ComponentMap = {\n  [tagName: string]: Component<CustomBlockProps> | Component<StandardComponentProps>;\n};\n\nfunction convertProperties(\n  properties: Record<string, unknown> | undefined\n): Record<string, unknown> {\n  if (!properties) return {};\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(properties)) {\n    if (key === \"className\") {\n      result.class = value;\n    } else if (key === \"class\") {\n      result.class = Array.isArray(value) ? value.join(\" \") : value;\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\nfunction renderElement(\n  tagName: string,\n  props: Record<string, unknown>,\n  children: JSX.Element\n): JSX.Element {\n  switch (tagName) {\n    case \"p\":\n      return <p {...props}>{children}</p>;\n    case \"h1\":\n      return <h1 {...props}>{children}</h1>;\n    case \"h2\":\n      return <h2 {...props}>{children}</h2>;\n    case \"h3\":\n      return <h3 {...props}>{children}</h3>;\n    case \"h4\":\n      return <h4 {...props}>{children}</h4>;\n    case \"h5\":\n      return <h5 {...props}>{children}</h5>;\n    case \"h6\":\n      return <h6 {...props}>{children}</h6>;\n    case \"div\":\n      return <div {...props}>{children}</div>;\n    case \"span\":\n      return <span {...props}>{children}</span>;\n    case \"a\":\n      return <a {...props}>{children}</a>;\n    case \"strong\":\n      return <strong {...props}>{children}</strong>;\n    case \"b\":\n      return <b {...props}>{children}</b>;\n    case \"em\":\n      return <em {...props}>{children}</em>;\n    case \"i\":\n      return <i {...props}>{children}</i>;\n    case \"code\":\n      return <code {...props}>{children}</code>;\n    case \"pre\":\n      return <pre {...props}>{children}</pre>;\n    case \"blockquote\":\n      return <blockquote {...props}>{children}</blockquote>;\n    case \"ul\":\n      return <ul {...props}>{children}</ul>;\n    case \"ol\":\n      return <ol {...props}>{children}</ol>;\n    case \"li\":\n      return <li {...props}>{children}</li>;\n    case \"hr\":\n      return <hr {...props} />;\n    case \"br\":\n      return <br {...props} />;\n    case \"img\":\n      return <img {...props} />;\n    case \"table\":\n      return <table {...props}>{children}</table>;\n    case \"thead\":\n      return <thead {...props}>{children}</thead>;\n    case \"tbody\":\n      return <tbody {...props}>{children}</tbody>;\n    case \"tr\":\n      return <tr {...props}>{children}</tr>;\n    case \"th\":\n      return <th {...props}>{children}</th>;\n    case \"td\":\n      return <td {...props}>{children}</td>;\n    case \"del\":\n      return <del {...props}>{children}</del>;\n    case \"sup\":\n      return <sup {...props}>{children}</sup>;\n    case \"sub\":\n      return <sub {...props}>{children}</sub>;\n    // GFM elements\n    case \"input\":\n      return <input {...props} />;\n    case \"section\":\n      return <section {...props}>{children}</section>;\n    // KaTeX math elements\n    case \"math\":\n      return <math {...props}>{children}</math>;\n    case \"semantics\":\n      return <semantics {...props}>{children}</semantics>;\n    case \"mrow\":\n      return <mrow {...props}>{children}</mrow>;\n    case \"mi\":\n      return <mi {...props}>{children}</mi>;\n    case \"mo\":\n      return <mo {...props}>{children}</mo>;\n    case \"mn\":\n      return <mn {...props}>{children}</mn>;\n    case \"mfrac\":\n      return <mfrac {...props}>{children}</mfrac>;\n    case \"msup\":\n      return <msup {...props}>{children}</msup>;\n    case \"msub\":\n      return <msub {...props}>{children}</msub>;\n    case \"msubsup\":\n      return <msubsup {...props}>{children}</msubsup>;\n    case \"msqrt\":\n      return <msqrt {...props}>{children}</msqrt>;\n    case \"mroot\":\n      return <mroot {...props}>{children}</mroot>;\n    case \"munder\":\n      return <munder {...props}>{children}</munder>;\n    case \"mover\":\n      return <mover {...props}>{children}</mover>;\n    case \"munderover\":\n      return <munderover {...props}>{children}</munderover>;\n    case \"mtable\":\n      return <mtable {...props}>{children}</mtable>;\n    case \"mtr\":\n      return <mtr {...props}>{children}</mtr>;\n    case \"mtd\":\n      return <mtd {...props}>{children}</mtd>;\n    case \"mtext\":\n      return <mtext {...props}>{children}</mtext>;\n    case \"mspace\":\n      return <mspace {...props}>{children}</mspace>;\n    case \"annotation\":\n      return <annotation {...props}>{children}</annotation>;\n    case \"svg\":\n      return <svg {...props}>{children}</svg>;\n    case \"path\":\n      return <path {...props} />;\n    case \"line\":\n      return <line {...props} />;\n    case \"rect\":\n      return <rect {...props} />;\n    case \"circle\":\n      return <circle {...props} />;\n    case \"g\":\n      return <g {...props}>{children}</g>;\n    case \"defs\":\n      return <defs {...props}>{children}</defs>;\n    case \"clipPath\":\n      return <clipPath {...props}>{children}</clipPath>;\n    case \"use\":\n      return <use {...props} />;\n    default:\n      return <div {...props}>{children}</div>;\n  }\n}\n\nfunction renderNode(\n  node: RootContent,\n  components: ComponentMap\n): JSX.Element | string | null {\n  if (node.type === \"text\") {\n    return (node as Text).value;\n  }\n\n  if (node.type === \"element\") {\n    const element = node as Element;\n    const tagName = element.tagName;\n    const rawProps = convertProperties(element.properties);\n    const CustomComponent = components[tagName];\n\n    const childElements =\n      element.children.length > 0\n        ? element.children.map((child) => renderNode(child, components))\n        : null;\n\n    if (CustomComponent) {\n      // Check if this is a custom block component (has payload and raw props)\n      if (typeof rawProps.payload === \"string\" && typeof rawProps.raw === \"string\") {\n        // Deserialize payload from JSON string\n        const customBlockProps: CustomBlockProps = {\n          payload: JSON.parse(rawProps.payload as string),\n          raw: rawProps.raw as string,\n        };\n        // Add data if present (for componentName| syntax)\n        if (typeof rawProps.data === \"string\") {\n          customBlockProps.data = JSON.parse(rawProps.data as string);\n        }\n        const Comp = CustomComponent as Component<CustomBlockProps>;\n        return <Comp {...customBlockProps}>{childElements}</Comp>;\n      }\n      const Comp = CustomComponent as Component<StandardComponentProps>;\n      return <Comp {...rawProps}>{childElements}</Comp>;\n    }\n\n    return renderElement(tagName, rawProps, childElements as JSX.Element);\n  }\n\n  return null;\n}\n\nexport function hastToSolidJsx(\n  hastTree: Root,\n  components: ComponentMap = {}\n): JSX.Element {\n  const elements = hastTree.children.map((node) => renderNode(node, components));\n  return <>{elements}</>;\n}\n\n/**\n * Returns a component function that renders the HAST tree when called.\n * This defers JSX element creation until render time, which is important\n * for SSR hydration to work correctly.\n *\n * We serialize the HAST tree and components info so that the exact same\n * rendering logic runs on both server and client.\n */\nexport function hastToSolidComponent(\n  hastTree: Root,\n  components: ComponentMap = {}\n): () => JSX.Element {\n  // Store the tree data, not pre-rendered elements\n  const treeData = hastTree;\n  const componentMap = components;\n\n  return function HastBody() {\n    const elements = treeData.children.map((node) => renderNode(node, componentMap));\n    return <>{elements}</>;\n  };\n}\n", "import type { HastParseResult, HastBody, HastStep } from \"hast-mds\";\nimport { hastToSolidComponent, ComponentMap } from \"./hast-to-solid\";\nimport type { Step, ParseResult, StepLocalBase, GlobalMetaBase } from \"./types\";\n\n// Re-export types from hast-to-solid\nexport type {\n  ComponentMap,\n  CustomBlockProps,\n  StandardComponentProps,\n} from \"./hast-to-solid\";\n\n// Re-export types from types.ts\nexport type { Step, ParseResult, StepLocalBase, GlobalMetaBase } from \"./types\";\n\n// Re-export hast-mds types for convenience\nexport type {\n  HastParseResult,\n  HastStep,\n  HastBody,\n  CustomComponents,\n} from \"hast-mds\";\n\n/**\n * Type guard to check if a value is a HastBody\n */\nfunction isHastBody(value: unknown): value is HastBody {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"type\" in value &&\n    (value as HastBody).type === \"hast\" &&\n    \"node\" in value\n  );\n}\n\n/**\n * Recursively transform metadata objects, converting HastBody to Solid components\n */\nfunction transformMetadata<T>(\n  metadata: T | null,\n  components: ComponentMap,\n): T | null {\n  if (metadata === null) return null;\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(\n    metadata as Record<string, unknown>,\n  )) {\n    if (isHastBody(value)) {\n      // Convert HastBody to Solid component\n      result[key] = hastToSolidComponent(value.node, components);\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result as T;\n}\n\n/**\n * Transform a parsed MDS document (HAST) into Solid components.\n *\n * This function takes the output from `hast-mds` parse() and converts all\n * HAST trees into renderable Solid components.\n *\n * @example\n * ```typescript\n * import { parse } from \"hast-mds\";\n * import { transform } from \"solid-mds\";\n *\n * const parsed = parse(mdsString, new Set([\"quiz\", \"card\"]));\n * const result = transform(parsed, { quiz: QuizComponent, card: CardComponent });\n *\n * // Use in Solid component:\n * <div>{result.steps.intro.Body()}</div>\n * ```\n *\n * @param parsed - The result from hast-mds parse() function\n * @param components - Optional map of custom Solid components\n * @returns ParseResult with Solid components\n */\nexport function transform<TGlobal = GlobalMetaBase, TLocal = StepLocalBase>(\n  parsed: HastParseResult<TGlobal, TLocal>,\n  components: ComponentMap = {},\n): ParseResult<TGlobal, TLocal> {\n  const steps: Record<string, Step<TLocal>> = {};\n\n  for (const id of Object.keys(parsed.steps)) {\n    const hastStep: HastStep<TLocal> = parsed.steps[id];\n    const Body = hastToSolidComponent(hastStep.body.node, components);\n    const transformedLocal = transformMetadata(hastStep.local, components);\n\n    steps[id] = {\n      id: hastStep.id,\n      local: transformedLocal as TLocal,\n      Body,\n      prev: hastStep.prev,\n      next: hastStep.next,\n      current: hastStep.current,\n    };\n  }\n\n  const transformedGlobal = transformMetadata(parsed.global, components);\n\n  return {\n    first: parsed.first,\n    steps,\n    count: parsed.count,\n    global: transformedGlobal as TGlobal | null,\n  };\n}\n"],
  "mappings": "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",
  "names": ["Comp"]
}


package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "solid-mds",
-  "version": "0.3.2",
-  "description": "A SolidJS library for parsing and rendering MDS (Markdown Steps) format",
+  "version": "0.4.0",
+  "description": "A SolidJS library for transforming MDS (Markdown Steps) HAST to Solid components",
   "license": "MIT",
   "author": "Matthias Reis",
   "keywords": [
     "solid",
     "solidjs",
     "markdown",
-    "parser",
+    "hast",
     "slides",
-    "presentation",
-    "remark",
-    "rehype"
+    "presentation"
   ],
   "type": "module",
   "main": "./dist/index.jsx",
@@ -37,21 +35,10 @@
     "prepublishOnly": "pnpm run build",
     "release": "bash ../../scripts/release.sh"
   },
-  "dependencies": {
-    "yaml": "^2.7.0",
-    "rehype-katex": "^7.0.0",
-    "rehype-stringify": "^10.0.1",
-    "remark-gfm": "^4.0.0",
-    "remark-math": "^6.0.0",
-    "remark-parse": "^11.0.0",
-    "remark-rehype": "^11.1.1",
-    "unified": "^11.0.5",
-    "unist-util-visit": "^5.0.0"
-  },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.0",
     "@types/hast": "^3.0.4",
-    "@types/mdast": "^4.0.4",
+    "hast-mds": "workspace:*",
     "jsdom": "^26.0.0",
     "tsup": "^8.3.5",
     "tsup-preset-solid": "^2.2.0",
@@ -60,7 +47,8 @@
     "vitest": "^3.0.0"
   },
   "peerDependencies": {
-    "solid-js": "^1.9.0"
+    "solid-js": "^1.9.0",
+    "hast-mds": "^0.1.0"
   },
   "typesVersions": {}
 }