@vmz/plugin-markdown-it 0.0.0 → 0.0.2

package/README.md

@@ -1,3 +1,3 @@
 # @vmz/plugin-markdown-it
 
-Placeholder package (0.0.0). Reserved for the VMZ project.
+VMZ package 0.0.2.

package/components/MarkdownIt.vmz

@@ -0,0 +1,19 @@
+<template>
+  <div class="markdown-host" html={format(source)}></div>
+</template>
+
+<script client>
+import { renderMarkdown } from '@vmz/plugin-markdown-it/runtime';
+
+function format(source) {
+  try {
+    return renderMarkdown(source ?? '');
+  } catch {
+    return '';
+  }
+}
+
+export default class MarkdownIt {
+  public source: string = '';
+}
+</script>

package/package.json

@@ -1,10 +1,37 @@
 {
   "name": "@vmz/plugin-markdown-it",
-  "version": "0.0.0",
-  "description": "VMZ placeholder — not for production use.",
+  "version": "0.0.2",
+  "type": "module",
+  "description": "VMZ markdown-it adapter — MarkdownIt + engines.markdown registration",
   "license": "MIT",
-  "private": false,
-  "files": [
-    "README.md"
-  ]
+  "main": "./vmz.plugin.ts",
+  "types": "./vmz.plugin.ts",
+  "exports": {
+    ".": {
+      "types": "./vmz.plugin.ts",
+      "default": "./vmz.plugin.ts"
+    },
+    "./runtime": {
+      "types": "./runtime.ts",
+      "default": "./runtime.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@vmz/plugin": "0.0.2",
+    "markdown-it": "^14.1.0"
+  },
+  "keywords": [
+    "vmz",
+    "plugin",
+    "markdown",
+    "markdown-it"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doki-land/vmz-framework.git"
+  }
 }

package/runtime.ts

@@ -0,0 +1,104 @@
+/**
+ * Deterministic CommonMark-ish subset for documents + `<Markdown>` (D1).
+ * HTML / JS / MDX disabled — see 规划设计/vmz/19 §3.
+ */
+import MarkdownIt from 'markdown-it';
+
+/** @type {import('markdown-it').default | null} */
+let cached = null;
+
+function createMd() {
+    if (cached) return cached;
+    cached = new MarkdownIt({
+        html: false,
+        linkify: true,
+        typographer: false,
+        breaks: false,
+    });
+    return cached;
+}
+
+/**
+ * @param {string} source
+ * @returns {string} HTML fragment (no wrapping document)
+ */
+export function renderMarkdown(source) {
+    const md = createMd();
+    return md.render(String(source ?? ''));
+}
+
+/**
+ * @param {string} source
+ * @returns {{
+ *   html: string,
+ *   headings: Array<{ level: number, id: string, text: string }>,
+ *   links: Array<{ href: string, text: string }>,
+ *   fences: Array<{ lang: string, info: string, content: string, lineStart: number, lineEnd: number }>
+ * }}
+ */
+export function analyzeMarkdown(source) {
+    const md = createMd();
+    const tokens = md.parse(String(source ?? ''), {});
+    /** @type {Array<{ level: number, id: string, text: string }>} */
+    const headings = [];
+    /** @type {Array<{ href: string, text: string }>} */
+    const links = [];
+    /** @type {Array<{ lang: string, info: string, content: string, lineStart: number, lineEnd: number }>} */
+    const fences = [];
+    const seenIds = new Set();
+
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.type === 'heading_open') {
+            const level = Number(String(t.tag || 'h1').slice(1)) || 1;
+            const inline = tokens[i + 1];
+            const text = inline && inline.type === 'inline' ? inline.content : '';
+            let id = slugify(text);
+            if (seenIds.has(id)) {
+                let n = 2;
+                while (seenIds.has(`${id}-${n}`)) n++;
+                id = `${id}-${n}`;
+            }
+            seenIds.add(id);
+            headings.push({ level, id, text });
+            // Inject id into open token attrs for render.
+            t.attrSet('id', id);
+        }
+        if (t.type === 'fence') {
+            const info = String(t.info || '').trim();
+            const lang = (info.split(/\s+/)[0] || '').toLowerCase();
+            const map = Array.isArray(t.map) ? t.map : [0, 0];
+            fences.push({
+                lang,
+                info,
+                content: String(t.content || ''),
+                lineStart: map[0] + 1,
+                lineEnd: map[1],
+            });
+        }
+        if (t.type === 'inline' && Array.isArray(t.children)) {
+            for (const c of t.children) {
+                if (c.type === 'link_open') {
+                    const href = c.attrGet('href') || '';
+                    links.push({ href, text: '' });
+                }
+            }
+        }
+    }
+
+    const html = md.renderer.render(tokens, md.options, {});
+    return { html, headings, links, fences };
+}
+
+/** @param {string} text */
+export function slugify(text) {
+    return (
+        String(text || '')
+            .trim()
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}\s_-]/gu, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '') || 'section'
+    );
+}

package/vmz.plugin.ts

@@ -0,0 +1,50 @@
+import { definePlugin, loadPluginSource } from '@vmz/plugin';
+
+const source = loadPluginSource(import.meta.url, 'components/MarkdownIt.vmz');
+
+export default definePlugin({
+    name: '@vmz/plugin-markdown-it',
+    version: '0.1.0',
+    protocol: '0.1.0',
+    stages: ['workspace_resolve', 'analyzer'],
+    deterministic: true,
+    async contribute(ctx) {
+        if (ctx.stage === 'workspace_resolve') {
+            return {
+                stage: 'workspace_resolve',
+                cacheKey: `@vmz/plugin-markdown-it:MarkdownIt.vmz:${source.contentHash.slice(0, 12)}`,
+                items: [
+                    {
+                        id: 'component-markdown-it',
+                        kind: 'source',
+                        path: 'src/components/MarkdownIt.vmz',
+                        content: source.content,
+                        contentHash: source.contentHash,
+                        materialize: true,
+                        engine: 'markdown-it',
+                        engineKind: 'markdown',
+                    },
+                ],
+            };
+        }
+        if (ctx.stage === 'analyzer') {
+            return {
+                stage: 'analyzer',
+                cacheKey: '@vmz/plugin-markdown-it:analyzer',
+                items: [
+                    {
+                        id: 'engine-markdown-it',
+                        kind: 'analyzer',
+                        path: 'src/components/MarkdownIt.vmz',
+                        severity: 'advice',
+                        message: 'markdown engine markdown-it online',
+                        code: 'vmz.engine.markdown-it',
+                        engine: 'markdown-it',
+                        engineKind: 'markdown',
+                    },
+                ],
+            };
+        }
+        return { stage: ctx.stage, items: [] };
+    },
+});