@mdfriday/foundry 26.4.20 → 26.5.1

package/dist/types/internal/domain/markdown/factory/it/util/slugger-fallback.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Slug generator matching github-slugger v2.0.0 behavior
+ * Used for anchor slugs (heading IDs) - this DOES lowercase
+ *
+ * Note: This is different from Quartz's sluggify() which preserves case
+ */
 export declare function slug(text: string): string;
 export { slug as slugAnchor };

package/dist/types/internal/domain/markdown/type.d.ts

@@ -4,14 +4,22 @@ export interface FrontMatterData {
     format: 'yaml' | 'toml' | 'json' | 'org';
 }
 export interface Shortcode {
+    /** Shortcode name */
     name: string;
+    /** Parameters */
     params: string[] | Record<string, any> | null;
+    /** Position in source */
     pos: number;
+    /** Length in source */
     length: number;
     rawContent: string;
+    /** Placeholder for shortcode in content */
     placeholder: string;
+    /** Whether it's inline */
     inline: boolean;
+    /** Whether it's closed */
     closed: boolean;
+    /** Inner content for paired shortcodes */
     inner?: string | any[];
     ordinal: number;
     indentation?: string;
@@ -25,12 +33,23 @@ export interface ParsedContentResult {
     wordCount: number;
     readingTime: number;
 }
+/**
+ * Shortcode renderer function type for external use
+ */
 export type ShortcodeRendererFunc = (shortcode: Shortcode) => Promise<string> | string;
+/**
+ * Simplified content result interface for external use
+ */
 export interface ContentResult {
+    /** Front matter data */
     frontMatter?: Record<string, any>;
+    /** Final rendered HTML content */
     renderedContent: string;
+    /** Content summary */
     summary?: string;
+    /** Word count */
     wordCount: number;
+    /** Reading time in minutes */
     readingTime: number;
 }
 export interface RenderableDocument {
@@ -38,9 +57,15 @@ export interface RenderableDocument {
     toc(): TocFragments;
     render(options: ParseAndRenderOptions): Promise<ContentResult>;
 }
+/**
+ * Parse and render options
+ */
 export interface ParseAndRenderOptions {
+    /** Shortcode renderer function */
     shortcodeRenderer?: ShortcodeRendererFunc;
+    /** Maximum summary length */
     maxSummaryLength?: number;
+    /** Words per minute for reading time calculation */
     wordsPerMinute?: number;
 }
 export interface Markdown extends Highlighter {
@@ -49,115 +74,228 @@ export interface Markdown extends Highlighter {
     parseAndRenderContent(source: Uint8Array, options?: ParseAndRenderOptions): Promise<ContentResult>;
     prepareRender(source: Uint8Array): Promise<RenderableDocument>;
 }
+/**
+ * Result represents the minimum returned from Convert.
+ */
 export interface Result extends RenderingResult, ParsingResult {
 }
+/**
+ * ParsingResult interface
+ */
 export interface ParsingResult {
     headers(): Header[];
     tableOfContents(): TocFragments;
 }
+/**
+ * RenderingResult interface
+ */
 export interface RenderingResult {
     bytes(): Uint8Array;
 }
+/**
+ * Highlighter interface for code highlighting
+ */
 export interface Highlighter extends CodeBlockRenderer, IsDefaultCodeBlockRendererProvider {
     highlight(code: string, lang: string, opts?: any): Promise<string>;
     highlightCodeBlock(ctx: CodeblockContext, opts?: any): Promise<HighlightResult>;
 }
+/**
+ * HighlightResult interface
+ */
 export interface HighlightResult {
     wrapped(): string;
     inner(): string;
 }
+/**
+ * AttributesOptionsSliceProvider interface
+ */
 export interface AttributesOptionsSliceProvider {
     attributesSlice(): Attribute[];
     optionsSlice(): Attribute[];
 }
+/**
+ * Attribute interface
+ */
 export interface Attribute {
     name(): string;
     value(): any;
     valueString(): string;
 }
+/**
+ * RenderContext holds contextual information about the content to render.
+ */
 export interface RenderContext {
+    /** Context for the current Page render */
     ctx: any;
+    /** Content to render */
     src: Uint8Array;
+    /** Whether to render TableOfContents */
     renderTOC: boolean;
+    /** Provides hook renderers on demand */
     getRenderer: GetRendererFunc;
 }
+/**
+ * DocumentContext holds contextual information about the document to convert.
+ */
 export interface DocumentContext {
+    /** May be null. Usually a page.Page */
     document: any | null;
     documentID: string;
     documentName: string;
     filename: string;
 }
+/**
+ * Renderer types enum
+ */
 export declare enum RendererType {
     LinkRendererType = 1,
     ImageRendererType = 2,
     HeadingRendererType = 3,
     CodeBlockRendererType = 4
 }
+/**
+ * GetRendererFunc type
+ */
 export type GetRendererFunc = (t: RendererType, id?: any) => any | null;
+/**
+ * Default renderer function
+ */
 export declare const DefaultRendererFunc: GetRendererFunc;
+/**
+ * ContextData interface
+ */
 export interface ContextData {
     renderContext(): RenderContext;
     documentContext(): DocumentContext;
 }
+/**
+ * TableOfContentsProvider interface
+ */
 export interface TableOfContentsProvider {
     tableOfContents(): TocFragments;
 }
+/**
+ * TocFragments interface
+ */
 export interface TocFragments {
     toHTML(startLevel: number, stopLevel: number, ordered: boolean): string;
 }
+/**
+ * LinkContext is the context passed to a link render hook.
+ */
 export interface LinkContext {
+    /** The Page being rendered */
     page(): any;
+    /** The link URL */
     destination(): string;
+    /** The link title attribute */
     title(): string;
+    /** The rendered (HTML) text */
     text(): RenderedString;
+    /** The plain variant of Text */
     plainText(): string;
 }
+/**
+ * LinkRenderer interface
+ */
 export interface LinkRenderer {
     renderLink(cctx: any, w: FlexiWriter, ctx: LinkContext): Promise<void>;
 }
+/**
+ * AttributesProvider interface
+ */
 export interface AttributesProvider {
+    /** Attributes passed in from Markdown (e.g. { attrName1=attrValue1 attrName2="attr Value 2" }) */
     attributes(): Record<string, any>;
 }
+/**
+ * HeadingContext contains accessors to all attributes that a HeadingRenderer
+ * can use to render a heading.
+ */
 export interface HeadingContext extends AttributesProvider {
+    /** Page is the page containing the heading */
     page(): any;
+    /** Level is the level of the header (i.e. 1 for top-level, 2 for sub-level, etc.) */
     level(): number;
+    /** Anchor is the HTML id assigned to the heading */
     anchor(): string;
+    /** Text is the rendered (HTML) heading text, excluding the heading marker */
     text(): RenderedString;
+    /** PlainText is the unrendered version of Text */
     plainText(): string;
 }
+/**
+ * HeadingRenderer describes a uniquely identifiable rendering hook.
+ */
 export interface HeadingRenderer {
+    /** RenderHeading writes the rendered content to w using the data in ctx */
     renderHeading(cctx: any, w: FlexiWriter, ctx: HeadingContext): Promise<void>;
 }
+/**
+ * IsDefaultCodeBlockRendererProvider interface
+ */
 export interface IsDefaultCodeBlockRendererProvider {
     isDefaultCodeBlockRenderer(): boolean;
 }
+/**
+ * ElementPositionResolver provides a way to resolve the start Position
+ * of a markdown element in the original source document.
+ * This may be both slow and approximate, so should only be
+ * used for error logging.
+ */
 export interface ElementPositionResolver {
     resolvePosition(ctx: any): Position;
 }
+/**
+ * Position interface for text positioning
+ */
 export interface Position {
     line: number;
     column: number;
     offset: number;
 }
+/**
+ * CodeblockContext is the context passed to a code block render hook.
+ */
 export interface CodeblockContext extends AttributesProvider, AttributesOptionsSliceProvider, Positioner {
+    /** Chroma highlighting processing options. This will only be filled if Type is a known Chroma Lexer */
     options(): Record<string, any>;
+    /** The type of code block. This will be the programming language, e.g. bash, when doing code highlighting */
     type(): string;
+    /** The text between the code fences */
     inner(): string;
+    /** Zero-based ordinal for all code blocks in the current document */
     ordinal(): number;
+    /** The owning Page */
     page(): any;
 }
+/**
+ * Positioner interface
+ */
 export interface Positioner {
     position(): Position;
 }
+/**
+ * CodeBlockRenderer interface
+ */
 export interface CodeBlockRenderer {
     renderCodeblock(cctx: any, w: FlexiWriter, ctx: CodeblockContext): Promise<void>;
 }
+/**
+ * FlexiWriter interface - flexible writer for different output types
+ */
 export interface FlexiWriter {
     write(data: Uint8Array): Promise<void>;
     writeString(str: string): Promise<void>;
     writeByte(b: number): Promise<void>;
 }
+/**
+ * RenderedString type - represents rendered HTML string
+ */
 export type RenderedString = string;
+/**
+ * Header interface
+ */
 export interface Header {
     name(): string;
     level(): number;
@@ -165,25 +303,46 @@ export interface Header {
     paragraphs(): Paragraph[];
     listParagraphs(): Paragraph[];
 }
+/**
+ * Link interface
+ */
 export interface Link {
     text(): string;
     url(): string;
 }
+/**
+ * Paragraph interface
+ */
 export interface Paragraph {
     text(): string;
 }
+/**
+ * Markdown renderer interface - allows for external markdown renderers
+ */
 export interface MarkdownRenderer {
     render(source: string): Promise<string>;
     parse(source: string): Promise<ParsingResult>;
 }
+/**
+ * Markdown configuration interface
+ */
 export interface MarkdownConfig {
     renderer?: MarkdownRenderer;
     extensions?: MarkdownExtension[];
     options?: Record<string, any>;
 }
+/**
+ * Markdown extension interface
+ */
 export interface MarkdownExtension {
     name: string;
     extend(md: any): void;
 }
+/**
+ * Basic markdown rendering function type - for environments where we only have access to render functions
+ */
 export type BasicMarkdownRenderFunc = (source: string) => Promise<string> | string;
+/**
+ * Basic markdown parsing function type - for environments where we only have access to parse functions
+ */
 export type BasicMarkdownParseFunc = (source: string) => Promise<any> | any;

package/dist/types/internal/domain/markdown/vo/config.d.ts

@@ -1,9 +1,15 @@
+/**
+ * Auto heading ID types
+ */
 export declare const AutoHeadingIDType: {
     readonly GitHub: "github";
     readonly GitHubAscii: "github-ascii";
     readonly Blackfriday: "blackfriday";
 };
 export type AutoHeadingIDType = typeof AutoHeadingIDType[keyof typeof AutoHeadingIDType];
+/**
+ * Typographer configuration
+ */
 export interface TypographerConfig {
     disable: boolean;
     leftSingleQuote: string;
@@ -17,20 +23,32 @@ export interface TypographerConfig {
     rightAngleQuote: string;
     apostrophe: string;
 }
+/**
+ * CJK configuration
+ */
 export interface CJKConfig {
     enable: boolean;
     eastAsianLineBreaks: boolean;
     eastAsianLineBreaksStyle: string;
     escapedSpace: boolean;
 }
+/**
+ * Delimiters configuration
+ */
 export interface DelimitersConfig {
     inline: string[][];
     block: string[][];
 }
+/**
+ * Passthrough configuration
+ */
 export interface PassthroughConfig {
     enable: boolean;
     delimiters: DelimitersConfig;
 }
+/**
+ * Highlight configuration
+ */
 export interface HighlightConfig {
     style: string;
     lineNos: boolean;
@@ -43,19 +61,31 @@ export interface HighlightConfig {
     guessSyntax: boolean;
     tabWidth: number;
 }
+/**
+ * Parser attribute configuration
+ */
 export interface ParserAttributeConfig {
     title: boolean;
     block: boolean;
 }
+/**
+ * Parser configuration
+ */
 export interface ParserConfig {
     autoHeadingID: boolean;
     autoHeadingIDType: AutoHeadingIDType;
     wrapStandAloneImageWithinParagraph: boolean;
     attribute: ParserAttributeConfig;
 }
+/**
+ * Renderer configuration
+ */
 export interface RendererConfig {
     unsafe: boolean;
 }
+/**
+ * Extensions configuration
+ */
 export interface ExtensionsConfig {
     typographer: TypographerConfig;
     footnote: boolean;
@@ -69,16 +99,28 @@ export interface ExtensionsConfig {
     passthrough: PassthroughConfig;
     highlight: HighlightConfig;
 }
+/**
+ * Image render hook configuration
+ */
 export interface ImageRenderHookConfig {
     enableDefault: boolean;
 }
+/**
+ * Link render hook configuration
+ */
 export interface LinkRenderHookConfig {
     enableDefault: boolean;
 }
+/**
+ * Render hooks configuration
+ */
 export interface RenderHooksConfig {
     image: ImageRenderHookConfig;
     link: LinkRenderHookConfig;
 }
+/**
+ * Main Markdown configuration
+ */
 export interface DomainMarkdownConfig {
     renderer: RendererConfig;
     parser: ParserConfig;
@@ -86,5 +128,11 @@ export interface DomainMarkdownConfig {
     duplicateResourceFiles: boolean;
     renderHooks: RenderHooksConfig;
 }
+/**
+ * Default highlight configuration
+ */
 export declare const DefaultHighlightConfig: HighlightConfig;
+/**
+ * Default markdown configuration
+ */
 export declare const DefaultMarkdownConfig: DomainMarkdownConfig;

package/dist/types/internal/domain/markdown/vo/content.d.ts

@@ -1,13 +1,27 @@
 import { Item } from '@pkg/md/parser/item';
 import { MarkdownRenderer, Shortcode } from "@internal/domain/markdown";
 import { MediaType } from '@pkg/media/type';
+/**
+ * Content replacement item
+ */
 export interface ContentReplacement {
+    /** Replacement value */
     val: Uint8Array;
+    /** Source item */
     source: Item;
 }
+/**
+ * Content item type - can be Item, Shortcode, or ContentReplacement
+ */
 export type ContentItem = Item | Shortcode | ContentReplacement;
+/**
+ * Summary divider constants
+ */
 export declare const INTERNAL_SUMMARY_DIVIDER_BASE = "HUGOMORE42";
 export declare const INTERNAL_SUMMARY_DIVIDER_PRE: NodeJS.NonSharedUint8Array;
+/**
+ * Content class - manages parsed content with shortcodes and replacements
+ */
 export declare class Content {
     private hasSummaryDivider;
     private summaryTruncated;
@@ -15,37 +29,115 @@ export declare class Content {
     private items;
     private renderer;
     constructor(source: Uint8Array, renderer: MarkdownRenderer);
+    /**
+     * Check if content is empty
+     */
     isEmpty(): boolean;
+    /**
+     * Set summary divider flag
+     */
     setSummaryDivider(): void;
+    /**
+     * Check if content has summary divider
+     */
     getHasSummaryDivider(): boolean;
+    /**
+     * Set summary truncated flag
+     */
     setSummaryTruncated(): void;
+    /**
+     * Check if summary is truncated
+     */
     getTruncated(): boolean;
+    /**
+     * Add replacement item
+     */
     addReplacement(val: Uint8Array, source: Item): void;
+    /**
+     * Add shortcode
+     */
     addShortcode(shortcode: Shortcode): void;
+    /**
+     * Add parsed item
+     */
     addItem(item: Item): void;
+    /**
+     * Add multiple items
+     */
     addItems(...items: Item[]): void;
+    /**
+     * Get raw content as string
+     */
     rawContent(): string;
+    /**
+     * Get pure content (with replacements and shortcodes processed)
+     */
     pureContent(): string;
     pureContentWithoutPlaceholder(): string;
+    /**
+     * Get content with shortcodes rendered
+     */
     renderedContent(shortcodeRenderer?: (shortcode: Shortcode) => string): string;
+    /**
+     * Get content with shortcodes rendered (async version)
+     */
     renderedContentAsync(shortcodeRenderer?: (shortcode: Shortcode) => Promise<string> | string): Promise<string>;
+    /**
+     * Get all items
+     */
     getItems(): ContentItem[];
+    /**
+     * Get shortcodes only
+     */
     getShortcodes(): Shortcode[];
+    /**
+     * Get regular items only
+     */
     getTextItems(): Item[];
+    /**
+     * Get content replacements only
+     */
     getReplacements(): ContentReplacement[];
+    /**
+     * Extract summary automatically when summary is empty
+     */
     extractSummary(input: Uint8Array, mediaType: MediaType): {
         summary: string;
         truncated: boolean;
     };
+    /**
+     * Extract summary from HTML content
+     */
     private extractSummaryFromHTML;
+    /**
+     * Check if string contains CJK characters
+     */
     private containsCJK;
+    /**
+     * Check if a word is probably an HTML token
+     */
     private isProbablyHTMLToken;
+    /**
+     * Strip HTML tags from string
+     */
     private stripHTML;
+    /**
+     * Trim short HTML content (remove single p tags if they wrap the entire content)
+     */
     private trimShortHTML;
     cleanDividerPlaceholders(htmlContent: string): string;
+    /**
+     * Get content summary (up to summary divider)
+     */
     getDividedSummary(htmlContent: string): string;
     getRenderedSummary(htmlContent?: string, maxLength?: number): Promise<string>;
+    /**
+     * Get word count
+     */
     getWordCount(): number;
+    /**
+     * Get reading time estimate (words per minute)
+     */
     getReadingTime(wordsPerMinute?: number): number;
     private isItem;
     private isShortcode;

package/dist/types/internal/domain/markdown/vo/context.d.ts

@@ -1,4 +1,7 @@
 import { RenderContext, DocumentContext, ContextData, FlexiWriter } from '../type';
+/**
+ * BufWriter implements FlexiWriter using a buffer
+ */
 export declare class BufWriter implements FlexiWriter {
     private buffer;
     private position;
@@ -12,6 +15,9 @@ export declare class BufWriter implements FlexiWriter {
     truncate(size: number): void;
     private ensureCapacity;
 }
+/**
+ * RenderContextDataHolder holds render and document context
+ */
 export declare class RenderContextDataHolder implements ContextData {
     private rctx;
     private dctx;
@@ -19,6 +25,9 @@ export declare class RenderContextDataHolder implements ContextData {
     renderContext(): RenderContext;
     documentContext(): DocumentContext;
 }
+/**
+ * Context combines BufWriter and ContextData
+ */
 export declare class Context implements FlexiWriter, ContextData {
     private bufWriter;
     private contextData;

package/dist/types/internal/domain/markdown/vo/highlight.d.ts

@@ -1,5 +1,8 @@
 import { Highlighter, HighlightResult, CodeblockContext, FlexiWriter } from '../type';
 import { HighlightConfig } from './config';
+/**
+ * HighlightResultImpl implements HighlightResult
+ */
 export declare class HighlightResultImpl implements HighlightResult {
     private wrappedContent;
     private innerContent;
@@ -7,6 +10,9 @@ export declare class HighlightResultImpl implements HighlightResult {
     wrapped(): string;
     inner(): string;
 }
+/**
+ * Default highlighter using highlight.js or prism.js
+ */
 export declare class DefaultHighlighter implements Highlighter {
     private config;
     constructor(config: HighlightConfig);
@@ -17,6 +23,9 @@ export declare class DefaultHighlighter implements Highlighter {
     private escapeHTML;
     private addLineNumbers;
 }
+/**
+ * External highlighter adapter - allows using external highlight libraries
+ */
 export declare class ExternalHighlighter implements Highlighter {
     private highlightFn;
     private config;
@@ -26,5 +35,11 @@ export declare class ExternalHighlighter implements Highlighter {
     renderCodeblock(cctx: any, w: FlexiWriter, ctx: CodeblockContext): Promise<void>;
     isDefaultCodeBlockRenderer(): boolean;
 }
+/**
+ * Factory function to create default highlighter
+ */
 export declare function createDefaultHighlighter(config?: Partial<HighlightConfig>): DefaultHighlighter;
+/**
+ * Factory function to create external highlighter
+ */
 export declare function createExternalHighlighter(highlightFn: (code: string, lang: string) => Promise<string>, config?: Partial<HighlightConfig>): ExternalHighlighter;

package/dist/types/internal/domain/markdown/vo/pageparser.d.ts

@@ -1,7 +1,16 @@
 import { Items } from "@pkg/md/parser/item";
 import { Config } from "@pkg/md/parser/pagelexer";
+/**
+ * Parse bytes into items
+ */
 export declare function parseBytes(input: Uint8Array, config?: Config): Items;
+/**
+ * Create position from input and offset
+ */
 export declare function posFromInput(filename: string, input: string | Uint8Array, offset: number): Position;
+/**
+ * Position interface
+ */
 export interface Position {
     filename: string;
     line: number;