markopress 0.0.2 → 0.0.4

package/dist/markdown/preserve-tags.js

@@ -1,233 +1 @@
-/**
- * Markdown-it plugin to preserve Marko tags (kebab-case) during markdown processing
- *
- * This plugin detects Marko component tags and preserves them verbatim,
- * allowing Marko's runtime to handle component discovery and rendering.
- *
- * - Preserves self-closing tags: <my-tag prop="value"/>
- * - Preserves tags with content: <my-tag>content</my-tag>
- * - Converts markdown→HTML inside tags that don't contain Marko syntax
- * - Preserves Marko template content as-is (nested components, slots)
- */
-// Standard HTML5 elements that should NOT be preserved
-const HTML_ELEMENTS = new Set([
-    'div', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'blockquote', 'pre', 'figure', 'figcaption',
-    'span', 'a', 'strong', 'em', 'b', 'i', 'u', 's', 'sub', 'sup', 'code', 'small',
-    'ul', 'ol', 'li', 'dl', 'dt', 'dd',
-    'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td', 'caption', 'col', 'colgroup',
-    'form', 'input', 'button', 'select', 'datalist', 'optgroup', 'option', 'textarea',
-    'label', 'fieldset', 'legend',
-    'img', 'video', 'audio', 'source', 'track', 'canvas', 'map', 'area',
-    'script', 'style', 'link', 'meta', 'noscript',
-    'html', 'head', 'body', 'title', 'base', 'section', 'article', 'aside', 'header', 'footer', 'nav', 'main', 'address',
-    'details', 'summary', 'dialog',
-    'iframe', 'object', 'param', 'embed',
-]);
-/**
- * Create placeholder for a detected Marko component
- */
-function createPlaceholder(id) {
-    return `<div data-marko-tag="${id}"></div>`;
-}
-/**
- * Restore Marko components from placeholders
- */
-function restoreComponents(html, components) {
-    let result = html;
-    // Restore in reverse order to preserve positions
-    for (let i = components.length - 1; i >= 0; i--) {
-        const comp = components[i];
-        const placeholder = createPlaceholder(comp.id);
-        result = result.replace(placeholder, comp.processedTag);
-    }
-    return result;
-}
-/**
- * Check if content contains Marko syntax (nested components or named slots)
- */
-function hasMarkoSyntax(content) {
-    // Check for nested Marko components (kebab-case tags)
-    const nestedComponentRegex = /<[a-z][a-z0-9-]*(?:\s[^>]*?)?>/;
-    // Check for named slots (@slot-name)
-    const namedSlotRegex = /<@[\w-]+/;
-    return nestedComponentRegex.test(content) || namedSlotRegex.test(content);
-}
-/**
- * Process component content - convert markdown to HTML if no Marko syntax present
- */
-function processComponentContent(content, md) {
-    if (!content || !content.trim()) {
-        return '';
-    }
-    if (hasMarkoSyntax(content)) {
-        // Content is a Marko template - preserve as-is
-        return content;
-    }
-    // Content is plain markdown - convert to HTML
-    let html = md.render(content);
-    // Unwrap <p> tags if markdown-it wrapped the content
-    // (markdown-it wraps plain text in <p> tags)
-    const trimmed = html.trim();
-    if (trimmed.startsWith('<p>') && trimmed.endsWith('</p>')) {
-        const inner = trimmed.slice(3, -4);
-        // Check if there are no other block elements, then unwrap
-        if (!inner.includes('</div>') && !inner.includes('<pre>')) {
-            html = inner;
-        }
-    }
-    return html;
-}
-function parseOpeningTag(markdown, pos) {
-    const tagRegex = /<([a-z][a-z0-9-]*)(\s[^>]*?)?(\/)?>/g;
-    tagRegex.lastIndex = pos;
-    const match = tagRegex.exec(markdown);
-    if (!match) {
-        return null;
-    }
-    return {
-        name: match[1],
-        attrs: match[2] || '',
-        selfClosing: match[3] === '/',
-        end: match.index + match[0].length
-    };
-}
-/**
- * Extract full Marko component with content
- */
-function extractComponent(markdown, startPos, md, onTagDetected, getLineNumber) {
-    const openingTag = parseOpeningTag(markdown, startPos);
-    if (!openingTag) {
-        return null;
-    }
-    const tagName = openingTag.name;
-    // Skip if it's a standard HTML element
-    if (HTML_ELEMENTS.has(tagName)) {
-        return null;
-    }
-    // Notify callback for validation
-    if (onTagDetected && getLineNumber) {
-        const lineNumber = getLineNumber(markdown, startPos);
-        onTagDetected(tagName, lineNumber);
-    }
-    // If self-closing, return immediately
-    if (openingTag.selfClosing) {
-        return {
-            id: 0,
-            start: startPos,
-            end: openingTag.end,
-            originalTag: markdown.slice(startPos, openingTag.end),
-            content: '',
-            processedTag: markdown.slice(startPos, openingTag.end)
-        };
-    }
-    // Find matching closing tag (handle nesting)
-    let pos = openingTag.end;
-    let depth = 1;
-    const closeTagStart = `</${tagName}`;
-    const closeTagFull = `</${tagName}>`;
-    while (pos < markdown.length && depth > 0) {
-        const nextOpen = markdown.indexOf(`<${tagName}`, pos);
-        const nextClose = markdown.indexOf(closeTagFull, pos);
-        if (nextClose === -1) {
-            // No closing tag found - treat what we have
-            break;
-        }
-        if (nextOpen !== -1 && nextOpen < nextClose) {
-            // Found opening tag before closing
-            const potentialTag = parseOpeningTag(markdown, nextOpen);
-            if (potentialTag && potentialTag.name === tagName) {
-                depth++;
-                pos = potentialTag.end;
-                continue;
-            }
-        }
-        // Found closing tag
-        depth--;
-        if (depth === 0) {
-            const endPos = nextClose + closeTagFull.length;
-            const content = markdown.slice(openingTag.end, nextClose);
-            // Process content (convert markdown or preserve Marko)
-            const processedContent = processComponentContent(content, md);
-            return {
-                id: 0,
-                start: startPos,
-                end: endPos,
-                originalTag: markdown.slice(startPos, endPos),
-                content,
-                processedTag: `<${tagName}${openingTag.attrs}>${processedContent}</${tagName}>`
-            };
-        }
-        pos = nextClose + closeTagFull.length;
-    }
-    // No matching closing tag found - treat as self-closing
-    return {
-        id: 0,
-        start: startPos,
-        end: openingTag.end,
-        originalTag: markdown.slice(startPos, openingTag.end),
-        content: '',
-        processedTag: `<${tagName}${openingTag.attrs}/>`
-    };
-}
-/**
- * Extract all Marko components from markdown
- */
-function extractComponents(markdown, md, onTagDetected, getLineNumber) {
-    const components = [];
-    let pos = 0;
-    let id = 0;
-    while (pos < markdown.length) {
-        // Find next potential tag
-        const tagStart = markdown.indexOf('<', pos);
-        if (tagStart === -1) {
-            break;
-        }
-        const component = extractComponent(markdown, tagStart, md, onTagDetected, getLineNumber);
-        if (component) {
-            component.id = id++;
-            components.push(component);
-            pos = component.end;
-        }
-        else {
-            pos = tagStart + 1;
-        }
-    }
-    return components;
-}
-/**
- * Get line number from position in text
- */
-function getLineNumber(text, position) {
-    const before = text.substring(0, position);
-    return before.split('\n').length;
-}
-/**
- * Main plugin function
- */
-export function preserveTagsPlugin(md, options) {
-    const { onTagDetected } = options || {};
-    // Wrap the render method
-    const originalRender = md.render.bind(md);
-    md.render = (src, env) => {
-        // Extract all Marko components (with content processing)
-        const components = extractComponents(src, md, onTagDetected, getLineNumber);
-        // Replace with placeholders
-        let processedSrc = src;
-        let offset = 0;
-        for (const comp of components) {
-            const placeholder = createPlaceholder(comp.id);
-            const adjustedStart = comp.start + offset;
-            const adjustedEnd = comp.end + offset;
-            processedSrc = processedSrc.substring(0, adjustedStart) +
-                placeholder +
-                processedSrc.substring(adjustedEnd);
-            offset += placeholder.length - (comp.end - comp.start);
-        }
-        // Render with placeholders
-        const result = originalRender(processedSrc, env);
-        // Restore Marko components (with processed content)
-        const restored = restoreComponents(String(result), components);
-        return restored;
-    };
-}
-//# sourceMappingURL=preserve-tags.js.map
+const t=new Set(["div","p","h1","h2","h3","h4","h5","h6","hr","blockquote","pre","figure","figcaption","span","a","strong","em","b","i","u","s","sub","sup","code","small","ul","ol","li","dl","dt","dd","table","thead","tbody","tfoot","tr","th","td","caption","col","colgroup","form","input","button","select","datalist","optgroup","option","textarea","label","fieldset","legend","img","video","audio","source","track","canvas","map","area","script","style","link","meta","noscript","html","head","body","title","base","section","article","aside","header","footer","nav","main","address","details","summary","dialog","iframe","object","param","embed"]);function e(t){return`<div data-marko-tag="${t}"></div>`}function n(t,e){if(!t||!t.trim())return"";if(function(t){return/<[a-z][a-z0-9-]*(?:\s[^>]*?)?>/.test(t)||/<@[\w-]+/.test(t)}(t))return t;let n=e.render(t);const r=n.trim();if(r.startsWith("<p>")&&r.endsWith("</p>")){const t=r.slice(3,-4);t.includes("</div>")||t.includes("<pre>")||(n=t)}return n}function r(t,e){const n=/<([a-z][a-z0-9-]*)(\s[^>]*?)?(\/)?>/g;n.lastIndex=e;const r=n.exec(t);return r?{name:r[1],attrs:r[2]||"",selfClosing:"/"===r[3],end:r.index+r[0].length}:null}function s(e,s,i,o,a){const d=r(e,s);if(!d)return null;const c=d.name;if(t.has(c))return null;if(o&&a&&o(c,a(e,s)),d.selfClosing)return{id:0,start:s,end:d.end,originalTag:e.slice(s,d.end),content:"",processedTag:e.slice(s,d.end)};let l=d.end,u=1;const f=`</${c}>`;for(;l<e.length&&u>0;){const t=e.indexOf("<"+c,l),o=e.indexOf(f,l);if(-1===o)break;if(-1!==t&&t<o){const n=r(e,t);if(n&&n.name===c){u++,l=n.end;continue}}if(u--,0===u){const t=o+f.length,r=e.slice(d.end,o),a=n(r,i);return{id:0,start:s,end:t,originalTag:e.slice(s,t),content:r,processedTag:`<${c}${d.attrs}>${a}</${c}>`}}l=o+f.length}return{id:0,start:s,end:d.end,originalTag:e.slice(s,d.end),content:"",processedTag:`<${c}${d.attrs}/>`}}function i(t,e){return t.substring(0,e).split("\n").length}export function preserveTagsPlugin(t,n){const{onTagDetected:r}=n||{},o=t.render.bind(t);t.render=(n,a)=>{const d=function(t,e,n,r){const i=[];let o=0,a=0;for(;o<t.length;){const d=t.indexOf("<",o);if(-1===d)break;const c=s(t,d,e,n,r);c?(c.id=a++,i.push(c),o=c.end):o=d+1}return i}(n,t,r,i);let c=n,l=0;for(const t of d){const n=e(t.id),r=t.start+l,s=t.end+l;c=c.substring(0,r)+n+c.substring(s),l+=n.length-(t.end-t.start)}const u=function(t,n){let r=t;for(let t=n.length-1;t>=0;t--){const s=n[t],i=e(s.id);r=r.replace(i,s.processedTag)}return r}(o(c,a)+"",d);return u}}

package/dist/markdown/renderer.d.ts

@@ -25,4 +25,3 @@ export declare function resetRendererCache(): void;
  * Get the current MarkdownIt instance if initialized
  */
 export declare function getRendererInstance(): MarkdownIt | null;
-//# sourceMappingURL=renderer.d.ts.map

package/dist/markdown/renderer.js

@@ -1,146 +1 @@
-/**
- * Request-time markdown renderer
- * Lazy-loads MarkdownIt + Shiki on first use
- * Used by route handlers to render markdown on demand
- */
-import matter from 'gray-matter';
-import MarkdownIt from 'markdown-it';
-import { getMarkdownIt } from './loader.js';
-/**
- * Cached MarkdownIt instance (lazy-loaded on first use)
- */
-let mdInstance = null;
-let mdOptions;
-/**
- * Render markdown source to HTML at request time
- *
- * This function lazy-loads MarkdownIt + Shiki on first call,
- * then reuses the instance for subsequent renders.
- *
- * @param source - Raw markdown source with frontmatter
- * @param options - Markdown parsing options (only used on first call)
- * @returns Processed markdown with frontmatter, HTML, and headers
- */
-export async function renderMarkdown(source, options) {
-    // Lazy init MarkdownIt (one-time cost)
-    if (!mdInstance) {
-        // Always enable markoTags for component support
-        const opts = {
-            ...options,
-            markoTags: {
-                enabled: true,
-                ...options?.markoTags
-            }
-        };
-        mdInstance = await getMarkdownIt(opts);
-        mdOptions = opts;
-    }
-    // Parse frontmatter
-    const { data: frontmatter, content: rawContent, excerpt } = matter(source, {
-        excerpt: true,
-        excerpt_separator: '<!-- more -->',
-    });
-    // Render markdown to HTML
-    const html = mdInstance.render(rawContent);
-    // Extract headers for TOC
-    const headers = extractHeaders(rawContent);
-    return {
-        frontmatter,
-        content: rawContent,
-        html,
-        excerpt,
-        headers: buildHeaderTree(headers),
-    };
-}
-/**
- * Reset the cached MarkdownIt instance
- * Useful for testing or when options change
- */
-export function resetRendererCache() {
-    mdInstance = null;
-    mdOptions = undefined;
-}
-/**
- * Get the current MarkdownIt instance if initialized
- */
-export function getRendererInstance() {
-    return mdInstance;
-}
-/**
- * Strip markdown formatting from text for cleaner TOC entries
- */
-function stripMarkdownFormatting(text) {
-    return text
-        .replace(/`([^`]+)`/g, '$1')
-        .replace(/\*\*\*\+([^*]+)\*\*\+/g, '$1')
-        .replace(/___+([^_]+)___+/g, '$1')
-        .replace(/\*\*([^*]+)\*\*/g, '$1')
-        .replace(/__([^_]+)__/g, '$1')
-        .replace(/\*([^*]+)\*/g, '$1')
-        .replace(/_([^_]+)_/g, '$1')
-        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-        .replace(/\[([^\]]+)\]\[[^\]]+\]/g, '$1')
-        .trim();
-}
-/**
- * Extract headers from markdown content
- */
-function extractHeaders(content) {
-    const headers = [];
-    const withoutCodeBlocks = content
-        .replace(/```[\s\S]*?```/g, '')
-        .replace(/~~~[\s\S]*?~~~/g, '')
-        .replace(/^(\t| {4}).+$/gm, '');
-    const headerRegex = /^(#{1,6})\s+(.+)$/gm;
-    let match;
-    while ((match = headerRegex.exec(withoutCodeBlocks)) !== null) {
-        const level = match[1].length;
-        const rawTitle = match[2].trim();
-        const title = stripMarkdownFormatting(rawTitle);
-        const slug = slugify(rawTitle);
-        headers.push({ level, title, slug });
-    }
-    return headers;
-}
-/**
- * Build header tree from flat list
- */
-function buildHeaderTree(headers) {
-    const result = [];
-    const stack = [];
-    for (const header of headers) {
-        const node = {
-            level: header.level,
-            title: header.title,
-            slug: header.slug,
-            children: [],
-        };
-        while (stack.length > 0 && stack[stack.length - 1].level >= header.level) {
-            stack.pop();
-        }
-        if (stack.length === 0) {
-            result.push(node);
-        }
-        else {
-            stack[stack.length - 1].children.push(node);
-        }
-        stack.push(node);
-    }
-    return result;
-}
-/**
- * Slugify text for URL-safe IDs
- */
-function slugify(text) {
-    return text
-        .trim()
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/([0-9])([a-zA-Z])/g, '$1-$2')
-        .replace(/([a-zA-Z])([0-9])/g, '$1-$2')
-        .toLowerCase()
-        .replace(/\s+/g, '-')
-        .replace(/[^\w\u00A0-\uFFFF\-]+/g, '')
-        .replace(/^-+|-+$/g, '')
-        .replace(/-+/g, '-');
-}
-//# sourceMappingURL=renderer.js.map
+import e from"gray-matter";import r from"markdown-it";import{getMarkdownIt as t}from"./loader.js";let l,n=null;export async function renderMarkdown(r,p){if(!n){const e={...p,markoTags:{enabled:!0,...p?.markoTags}};n=await t(e),l=e}const{data:g,content:s,excerpt:u}=e(r,{excerpt:!0,excerpt_separator:"\x3c!-- more --\x3e"});return{frontmatter:g,content:s,html:n.render(s),excerpt:u,headers:a(function(e){const r=[],t=e.replace(/```[\s\S]*?```/g,"").replace(/~~~[\s\S]*?~~~/g,"").replace(/^(\t| {4}).+$/gm,""),l=/^(#{1,6})\s+(.+)$/gm;let n;for(;null!==(n=l.exec(t));){const e=n[1].length,t=n[2].trim(),l=c(t),a=o(t);r.push({level:e,title:l,slug:a})}return r}(s))}}export function resetRendererCache(){n=null,l=void 0}export function getRendererInstance(){return n}function c(e){return e.replace(/`([^`]+)`/g,"$1").replace(/\*\*\*\+([^*]+)\*\*\+/g,"$1").replace(/___+([^_]+)___+/g,"$1").replace(/\*\*([^*]+)\*\*/g,"$1").replace(/__([^_]+)__/g,"$1").replace(/\*([^*]+)\*/g,"$1").replace(/_([^_]+)_/g,"$1").replace(/\[([^\]]+)\]\([^)]+\)/g,"$1").replace(/\[([^\]]+)\]\[[^\]]+\]/g,"$1").trim()}function a(e){const r=[],t=[];for(const l of e){const e={level:l.level,title:l.title,slug:l.slug,children:[]};for(;t.length>0&&t[t.length-1].level>=l.level;)t.pop();0===t.length?r.push(e):t[t.length-1].children.push(e),t.push(e)}return r}function o(e){return e.trim().replace(/([a-z])([A-Z])/g,"$1-$2").replace(/([0-9])([a-zA-Z])/g,"$1-$2").replace(/([a-zA-Z])([0-9])/g,"$1-$2").toLowerCase().replace(/\s+/g,"-").replace(/[^\w\u00A0-\uFFFF\-]+/g,"").replace(/^-+|-+$/g,"").replace(/-+/g,"-")}

package/dist/markdown/tag-validator.d.ts

@@ -61,4 +61,3 @@ export declare function formatValidationError(missingTags: DetectedTag[]): strin
  * Create a global validator instance
  */
 export declare const globalTagValidator: TagValidator;
-//# sourceMappingURL=tag-validator.d.ts.map

package/dist/markdown/tag-validator.js

@@ -1,118 +1 @@
-/**
- * Tag Validator for Marko components in markdown
- *
- * Tracks all detected Marko tags during the build process,
- * scans the tags/ directory for available components,
- * and validates that all detected tags have corresponding component files.
- */
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-export class TagValidator {
-    detectedTags = new Map();
-    availableTags = new Set();
-    /**
-     * Add a detected tag for tracking
-     */
-    addDetectedTag(tagName, fileName, lineNumber) {
-        const normalized = tagName.toLowerCase();
-        if (!this.detectedTags.has(normalized)) {
-            this.detectedTags.set(normalized, []);
-        }
-        this.detectedTags.get(normalized).push({
-            tagName: normalized,
-            fileName,
-            lineNumber,
-        });
-    }
-    /**
-     * Scan tags directory to find all available Marko components
-     */
-    async loadAvailableTags(tagsDir) {
-        try {
-            await fs.access(tagsDir);
-        }
-        catch {
-            // Directory doesn't exist, that's OK (no tags available)
-            console.warn(`Warning: tags directory not found at ${tagsDir}`);
-            return;
-        }
-        const files = await fs.readdir(tagsDir);
-        for (const file of files) {
-            if (file.endsWith('.marko')) {
-                const tagName = file.replace('.marko', '');
-                this.availableTags.add(tagName);
-            }
-        }
-    }
-    /**
-     * Get count of available tags
-     */
-    getAvailableTagsCount() {
-        return this.availableTags.size;
-    }
-    /**
-     * Get list of available tags
-     */
-    getAvailableTags() {
-        return Array.from(this.availableTags).sort();
-    }
-    /**
-     * Get all detected tags (grouped by tag name)
-     */
-    getDetectedTags() {
-        return this.detectedTags;
-    }
-    /**
-     * Validate that all detected tags exist in the tags directory
-     *
-     * @returns Validation result with success flag and list of missing tags
-     */
-    validate() {
-        const missingTags = [];
-        // Check each detected tag
-        for (const [tagName, occurrences] of this.detectedTags) {
-            if (!this.availableTags.has(tagName)) {
-                // Tag is missing - add all occurrences
-                missingTags.push(...occurrences);
-            }
-        }
-        return {
-            success: missingTags.length === 0,
-            missingTags,
-        };
-    }
-    /**
-     * Clear state for new build
-     */
-    reset() {
-        this.detectedTags.clear();
-        this.availableTags.clear();
-    }
-}
-/**
- * Format validation error message
- */
-export function formatValidationError(missingTags) {
-    // Group by tag name
-    const uniqueTags = new Map();
-    for (const tag of missingTags) {
-        if (!uniqueTags.has(tag.tagName)) {
-            uniqueTags.set(tag.tagName, []);
-        }
-        uniqueTags.get(tag.tagName).push(tag);
-    }
-    let output = '\n❌ Marko tags not found:\n';
-    for (const [tagName, occurrences] of uniqueTags) {
-        output += `\n  <${tagName}> used in:\n`;
-        for (const occ of occurrences) {
-            output += `    ${occ.fileName}:${occ.lineNumber}\n`;
-        }
-    }
-    output += '\nCreate missing files in tags/ directory or remove tags from markdown.\n';
-    return output;
-}
-/**
- * Create a global validator instance
- */
-export const globalTagValidator = new TagValidator();
-//# sourceMappingURL=tag-validator.js.map
+import{promises as a}from"node:fs";import e from"node:path";export class TagValidator{detectedTags=new Map;availableTags=new Set;addDetectedTag(a,e,t){const s=a.toLowerCase();this.detectedTags.has(s)||this.detectedTags.set(s,[]),this.detectedTags.get(s).push({tagName:s,fileName:e,lineNumber:t})}async loadAvailableTags(e){try{await a.access(e)}catch{return void console.warn("Warning: tags directory not found at "+e)}const t=await a.readdir(e);for(const a of t)if(a.endsWith(".marko")){const e=a.replace(".marko","");this.availableTags.add(e)}}getAvailableTagsCount(){return this.availableTags.size}getAvailableTags(){return Array.from(this.availableTags).sort()}getDetectedTags(){return this.detectedTags}validate(){const a=[];for(const[e,t]of this.detectedTags)this.availableTags.has(e)||a.push(...t);return{success:0===a.length,missingTags:a}}reset(){this.detectedTags.clear(),this.availableTags.clear()}}export function formatValidationError(a){const e=new Map;for(const t of a)e.has(t.tagName)||e.set(t.tagName,[]),e.get(t.tagName).push(t);let t="\n❌ Marko tags not found:\n";for(const[a,s]of e){t+=`\n  <${a}> used in:\n`;for(const a of s)t+=`    ${a.fileName}:${a.lineNumber}\n`}return t+="\nCreate missing files in tags/ directory or remove tags from markdown.\n",t}export const globalTagValidator=new TagValidator;

package/dist/markdown/types.d.ts

@@ -16,6 +16,8 @@ export interface MarkdownOptions {
         /** Directory containing Marko component files (default: 'tags/') */
         tagsDir?: string;
     };
+    /** Base path for link rewriting (e.g., '/markopress'). Links are rewritten only when this is non-root. */
+    base?: string;
 }
 export interface MarkdownProcessor {
     process(src: string, filePath?: string): Promise<ProcessedMarkdown>;
@@ -41,4 +43,3 @@ export interface MarkdownEnv {
     /** Enable TOC extraction for this file (default: false) */
     extractToc?: boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/markdown/types.js

@@ -1,5 +1 @@
-/**
- * Markdown processing types
- */
-export {};
-//# sourceMappingURL=types.js.map
+export{};

package/dist/plugin/compat.d.ts

@@ -11,4 +11,3 @@ export declare function wrapLegacyPlugin(plugin: any): MarkoPressPlugin;
  * Check if plugin is using legacy signature
  */
 export declare function isLegacyPlugin(plugin: any): boolean;
-//# sourceMappingURL=compat.d.ts.map

package/dist/plugin/compat.js

@@ -1,78 +1 @@
-/**
- * Backward compatibility utilities for plugins
- */
-/**
- * Wrap legacy plugin to support new hooks
- * Ensures old plugins work without modification
- */
-export function wrapLegacyPlugin(plugin) {
-    // If plugin already has new hooks, return as-is
-    if (plugin.loadContent || plugin.allContentLoaded || plugin.postBuild) {
-        return plugin;
-    }
-    // Wrap old contentLoaded signature
-    const originalContentLoaded = plugin.contentLoaded;
-    if (originalContentLoaded) {
-        plugin.contentLoaded = function (ctx) {
-            // Old signature: contentLoaded(ctx: ContentContext)
-            // New signature: contentLoaded(ctx: { content, allContent, actions })
-            // Check if using old signature (has addPage, addPost but no allContent)
-            if (ctx.addPage && ctx.addPost && !ctx.allContent) {
-                // Old plugin - provide backward compatible context
-                return originalContentLoaded.call(this, ctx);
-            }
-            else {
-                // New signature - call as-is
-                return originalContentLoaded.call(this, ctx);
-            }
-        };
-    }
-    // Convert beforeBuild to allContentLoaded (for migration)
-    if (plugin.beforeBuild && !plugin.allContentLoaded) {
-        const originalBeforeBuild = plugin.beforeBuild;
-        plugin.allContentLoaded = function (ctx) {
-            // Map old beforeBuild context to new allContentLoaded context
-            const oldContext = {
-                content: ctx.allContent,
-                routes: ctx.routes,
-                config: ctx.config,
-            };
-            return originalBeforeBuild.call(this, oldContext);
-        };
-    }
-    // Convert afterBuild to postBuild (for migration)
-    if (plugin.afterBuild && !plugin.postBuild) {
-        const originalAfterBuild = plugin.afterBuild;
-        plugin.postBuild = function (ctx) {
-            // Map old afterBuild context to new postBuild context
-            const oldContext = {
-                outDir: ctx.outDir,
-                routes: ctx.routes,
-                content: ctx.allContent,
-            };
-            return originalAfterBuild.call(this, oldContext);
-        };
-    }
-    return plugin;
-}
-/**
- * Check if plugin is using legacy signature
- */
-export function isLegacyPlugin(plugin) {
-    // Check if plugin has old contentLoaded signature but not new one
-    if (plugin.contentLoaded) {
-        // Can't determine without checking the function signature
-        // We'll detect at runtime
-        return false;
-    }
-    // Has beforeBuild but not allContentLoaded -> likely legacy
-    if (plugin.beforeBuild && !plugin.allContentLoaded) {
-        return true;
-    }
-    // Has afterBuild but not postBuild -> likely legacy
-    if (plugin.afterBuild && !plugin.postBuild) {
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=compat.js.map
+export function wrapLegacyPlugin(t){if(t.loadContent||t.allContentLoaded||t.postBuild)return t;const n=t.contentLoaded;if(n&&(t.contentLoaded=function(t){return t.addPage&&t.addPost&&t.allContent,n.call(this,t)}),t.beforeBuild&&!t.allContentLoaded){const n=t.beforeBuild;t.allContentLoaded=function(t){const o={content:t.allContent,routes:t.routes,config:t.config};return n.call(this,o)}}if(t.afterBuild&&!t.postBuild){const n=t.afterBuild;t.postBuild=function(t){const o={outDir:t.outDir,routes:t.routes,content:t.allContent};return n.call(this,o)}}return t}export function isLegacyPlugin(t){return!(t.contentLoaded||(!t.beforeBuild||t.allContentLoaded)&&(!t.afterBuild||t.postBuild))}

package/dist/plugin/context.d.ts

@@ -35,4 +35,3 @@ export declare class ContentActionsImpl implements ContentActions {
     getData(): Map<string, unknown>;
     clear(): void;
 }
-//# sourceMappingURL=context.d.ts.map