@mdfriday/foundry 26.4.20 → 26.5.1

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

@@ -1,26 +1,62 @@
 import { Item, Items } from "@pkg/md/parser/item";
 import { Iterator } from '@pkg/md/parser/pagelexer';
+/**
+ * Handler function types
+ */
 export type ItemHandler = (item: Item) => Promise<void> | void;
 export type IterHandler = (item: Item, iter: Iterator) => Promise<void> | void;
+/**
+ * Source handlers interface - defines all the handlers needed for parsing
+ */
 export interface SourceHandlers {
     frontMatterHandler(): ItemHandler;
     summaryHandler(): IterHandler;
     bytesHandler(): ItemHandler;
     shortcodeHandler(): IterHandler;
 }
+/**
+ * Source parse info - contains parsing state and handlers
+ */
 export declare class SourceParseInfo {
     private source;
     private posMainContent;
     private itemsStep1;
     private handlers;
     constructor(source: Uint8Array, handlers: SourceHandlers);
+    /**
+     * Validate that all required handlers are provided
+     */
     private validateHandlers;
+    /**
+     * Check if parsing result is empty
+     */
     isEmpty(): boolean;
+    /**
+     * Parse the source into items
+     */
     parse(): Promise<void>;
+    /**
+     * Handle the parsed items using the provided handlers
+     */
     handle(): Promise<void>;
+    /**
+     * Get the main content position
+     */
     getMainContentPosition(): number;
+    /**
+     * Get the parsed items
+     */
     getItems(): Items;
+    /**
+     * Get the source
+     */
     getSource(): Uint8Array;
+    /**
+     * Create error with position information
+     */
     private createError;
 }
+/**
+ * Factory function to create a new SourceParseInfo
+ */
 export declare function createSourceParseInfo(source: Uint8Array, handlers: SourceHandlers): SourceParseInfo;

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

@@ -1,11 +1,17 @@
 import { ParsingResult, Header, TocFragments, RenderingResult } from '../type';
 import { BufWriter } from './context';
+/**
+ * RenderingResultImpl implements RenderingResult
+ */
 export declare class RenderingResultImpl implements RenderingResult {
     private buffer;
     constructor(buffer: BufWriter);
     bytes(): Uint8Array;
     toString(): string;
 }
+/**
+ * Result implementation combining parsing and rendering results
+ */
 export declare class ResultImpl implements ParsingResult, RenderingResult {
     private parsingResult;
     private renderingResult;

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

@@ -20,6 +20,9 @@ export declare class ShortcodeImpl implements Shortcode {
     constructor(ordinal?: number, name?: string, params?: string[] | Record<string, any> | null, pos?: number, length?: number, inline?: boolean, closed?: boolean);
     needsInner(): boolean;
 }
+/**
+ * Simple shortcode parser
+ */
 export declare class ShortcodeParser {
     private shortcodes;
     private nameSet;
@@ -29,13 +32,40 @@ export declare class ShortcodeParser {
     private openShortcodes;
     private paramElements;
     constructor(source: Uint8Array, pid?: number);
+    /**
+     * Parse shortcode from iterator
+     */
     parseItem(item: Item, iter: Iterator): Shortcode;
+    /**
+     * Extract shortcode from iterator (following Go version logic exactly)
+     */
     private extractShortcode;
+    /**
+     * Get all parsed shortcodes
+     */
     getShortcodes(): Shortcode[];
+    /**
+     * Get shortcode names
+     */
     getNames(): string[];
 }
-export declare const TOC_SHORTCODE_PLACEHOLDER: string;
+/**
+ * Constants for shortcode placeholders
+ */
 export declare const SHORTCODE_PLACEHOLDER_PREFIX = "HAHAHUGOSHORTCODE";
+/**
+ * Create shortcode placeholder
+ */
 export declare function createShortcodePlaceholder(id: string, sid: number, ordinal: number): string;
+/**
+ * TOC shortcode placeholder
+ */
+export declare const TOC_SHORTCODE_PLACEHOLDER: string;
+/**
+ * Check if string contains shortcode placeholder
+ */
 export declare function hasShortcodePlaceholder(content: string): boolean;
+/**
+ * Replace shortcode placeholders in content
+ */
 export declare function replaceShortcodePlaceholders(content: string, shortcodes: Shortcode[], renderer: (shortcode: Shortcode) => string): string;

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

@@ -1,10 +1,16 @@
 import { TocFragments, Header, Link, Paragraph } from '../type';
+/**
+ * Fragment represents a single TOC entry
+ */
 export interface Fragment {
     id: string;
     text: string;
     level: number;
     children?: Fragment[];
 }
+/**
+ * TableOfContentsImpl implements TocFragments
+ */
 export declare class TableOfContentsImpl implements TocFragments {
     private fragments;
     constructor(fragments?: Fragment[]);
@@ -15,6 +21,9 @@ export declare class TableOfContentsImpl implements TocFragments {
     addFragment(fragment: Fragment): void;
     getFragments(): Fragment[];
 }
+/**
+ * HeaderImpl implements Header interface
+ */
 export declare class HeaderImpl implements Header {
     private _name;
     private _level;
@@ -31,6 +40,9 @@ export declare class HeaderImpl implements Header {
     addParagraph(paragraph: Paragraph): void;
     addListParagraph(paragraph: Paragraph): void;
 }
+/**
+ * LinkImpl implements Link interface
+ */
 export declare class LinkImpl implements Link {
     private _text;
     private _url;
@@ -38,11 +50,17 @@ export declare class LinkImpl implements Link {
     text(): string;
     url(): string;
 }
+/**
+ * ParagraphImpl implements Paragraph interface
+ */
 export declare class ParagraphImpl implements Paragraph {
     private _text;
     constructor(_text: string);
     text(): string;
 }
+/**
+ * TOC Builder utility class
+ */
 export declare class TOCBuilder {
     private fragments;
     private stack;
@@ -50,6 +68,9 @@ export declare class TOCBuilder {
     build(): TableOfContentsImpl;
     reset(): void;
 }
+/**
+ * Auto ID generation utilities
+ */
 export declare class AutoIDGenerator {
     private usedIds;
     generateID(text: string, type?: 'github' | 'github-ascii' | 'blackfriday'): string;

package/dist/types/internal/domain/module/entity/lang.d.ts

@@ -1,7 +1,19 @@
 import { Module } from '../type';
+/**
+ * Lang entity that manages source-to-language mappings
+ * TypeScript version of Go's Lang entity
+ */
 export declare class Lang {
     private sourceLangMap;
     constructor(modules: Module[]);
+    /**
+     * Get source language
+     * Returns a tuple of [language, exists] to match Go's return pattern
+     */
     getSourceLang(source: string): [string, boolean];
 }
+/**
+ * Creates a new Lang instance
+ * Factory function to match Go's NewLang function
+ */
 export declare function newLang(modules: Module[]): Lang;

package/dist/types/internal/domain/module/entity/module.d.ts

@@ -11,31 +11,104 @@ export declare class Modules implements IModules {
     private lang;
     private themesCache;
     constructor(info: Info, httpClient: HttpClient, zipExtractor: ZipExtractor, moduleCache: ModuleCache);
+    /**
+     * Get project module
+     */
     proj(): IModule;
+    /**
+     * Get all modules (project + downloaded)
+     */
     all(): IModule[];
+    /**
+     * Check if module is the project module
+     */
     isProjMod(mod: IModule): boolean;
+    /**
+     * Load modules from import paths
+     */
     load(onProgress?: (progress: {
         modulePath: string;
         downloadPercentage: number;
     }) => void): Promise<void>;
+    /**
+     * Parse version from import path
+     * @param importPath - The import path (e.g., "https://gohugo.net/base.zip?version=1.0")
+     * @returns Object with cleanUrl and version
+     */
     private parseVersionFromImportPath;
+    /**
+     * Get theme registry URL based on the import path host
+     * @param importPath - The import path
+     * @returns The theme registry URL
+     */
     private getThemeRegistryUrl;
+    /**
+     * Resolve latest version by fetching themes.json
+     * @param importPath - The import path with version=latest
+     * @returns The resolved import path with actual version
+     */
     private resolveLatestVersion;
+    /**
+     * Download and add a module
+     */
     downloadModule(moduleImport: Import, onProgress?: (progress: {
         percentage: number;
     }) => void): Promise<Module>;
+    /**
+     * Add a module to the collection
+     */
     private addModule;
+    /**
+     * Create module from cached metadata
+     */
     private createModuleFromCache;
+    /**
+     * Get module directory path
+     */
     private getModuleDir;
+    /**
+     * Get download URL for module path
+     * This would be implemented based on your backend API
+     */
     private getDownloadUrl;
+    /**
+     * Check if cached module is valid for the requested version
+     */
     private isCacheValidForVersion;
+    /**
+     * Add timestamp parameter to URL to avoid caching
+     */
     private addTimestampToUrl;
+    /**
+     * Get module by path
+     */
     getModuleByPath(modulePath: string): Module | null;
+    /**
+     * Check if module is downloaded
+     */
     isModuleDownloaded(modulePath: string): boolean;
+    /**
+     * Get download status for module
+     */
     getModuleStatus(modulePath: string): Promise<DownloadStatus>;
+    /**
+     * Remove module from collection
+     */
     removeModule(modulePath: string): Promise<void>;
+    /**
+     * Clear all downloaded modules
+     */
     clearAll(): Promise<void>;
+    /**
+     * Get source language
+     */
     getSourceLang(source: string): [string, boolean];
+    /**
+     * Parse theme.toml file to extract module import paths
+     */
     private parseThemeToml;
 }
+/**
+ * Creates a new Modules instance
+ */
 export declare function newModules(info: Info, httpClient: HttpClient, zipExtractor: ZipExtractor, moduleCache: ModuleCache): Modules;

package/dist/types/internal/domain/module/factory/module.d.ts

@@ -1,6 +1,12 @@
 import { Modules } from '../entity/module';
 import { Info } from '../type';
+/**
+ * Factory function to create a complete Modules instance with default dependencies
+ */
 export declare function createModules(info: Info): Promise<Modules>;
+/**
+ * Factory function to create a complete Modules instance with progress tracking
+ */
 export declare function createModulesWithProgress(info: Info, onProgress?: (progress: {
     modulePath: string;
     downloadPercentage: number;

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

@@ -1,5 +1,11 @@
 import { Fs } from '../fs/type';
+/**
+ * Module system constants
+ */
 export declare const PACKAGE_JSON_FILENAME = "package.json";
+/**
+ * Component folder constants
+ */
 export declare const ComponentFolderWorkflows = "workflows";
 export declare const ComponentFolderPrompts = "prompts";
 export declare const ComponentFolderContent = "content";
@@ -8,12 +14,18 @@ export declare const ComponentFolderStatic = "static";
 export declare const ComponentFolderAssets = "assets";
 export declare const ComponentFolderI18n = "i18n";
 export declare const ComponentFolders: readonly ["workflows", "prompts", "content", "layouts", "static", "assets", "i18n"];
+/**
+ * Module download status enum
+ */
 export declare enum DownloadStatus {
     PENDING = "pending",
     DOWNLOADING = "downloading",
     COMPLETED = "completed",
     FAILED = "failed"
 }
+/**
+ * Module error types
+ */
 export declare class ModuleError extends Error {
     code?: string | undefined;
     constructor(message: string, code?: string | undefined);
@@ -22,6 +34,9 @@ export declare const ErrModuleNotFound: ModuleError;
 export declare const ErrDownloadFailed: ModuleError;
 export declare const ErrInvalidZipFile: ModuleError;
 export declare const ErrMountFailed: ModuleError;
+/**
+ * Info interface for module system
+ */
 export interface Info {
     osFs(): Fs;
     projDir(): string;
@@ -31,13 +46,23 @@ export interface Info {
     defaultLanguageKey(): string;
     otherLanguageKeys(): string[];
     getRelDir(name: string, langKey: string): string;
+    /**
+     * Optional custom HTTP client instance
+     * If provided, this client will be used instead of creating a new one
+     */
     httpClient?(): HttpClient;
 }
+/**
+ * Mount interface for file system mounting
+ */
 export interface Mount {
     source(): string;
     target(): string;
     lang(): string;
 }
+/**
+ * Module interface
+ */
 export interface Module {
     owner(): Module | null;
     isProjectModule(): boolean;
@@ -45,32 +70,50 @@ export interface Module {
     dir(): string;
     path(): string;
 }
+/**
+ * Modules interface for managing multiple modules
+ */
 export interface Modules {
     proj(): Module;
     all(): Module[];
     isProjMod(mod: Module): boolean;
     getSourceLang(source: string): [string, boolean];
 }
+/**
+ * Import configuration
+ */
 export interface Import {
     path: string;
     url: string;
     version?: string;
     mounts?: MountConfig[];
 }
+/**
+ * Mount configuration
+ */
 export interface MountConfig {
     sourcePath: string;
     targetPath: string;
     language?: string;
 }
+/**
+ * Module configuration
+ */
 export interface ModuleConfig {
     imports: Import[];
 }
+/**
+ * HTTP download configuration
+ */
 export interface DownloadConfig {
     url: string;
     timeout?: number;
     retries?: number;
     headers?: Record<string, string>;
 }
+/**
+ * Module metadata
+ */
 export interface ModuleMetadata {
     path: string;
     version: string;
@@ -81,11 +124,17 @@ export interface ModuleMetadata {
     size?: number;
     checksum?: string;
 }
+/**
+ * Download progress callback
+ */
 export type DownloadProgressCallback = (progress: {
     loaded: number;
     total: number;
     percentage: number;
 }) => void;
+/**
+ * HTTP client interface for downloads
+ */
 export interface HttpClient {
     download(url: string, targetPath: string, options?: {
         onProgress?: DownloadProgressCallback;
@@ -101,10 +150,16 @@ export interface HttpClient {
         status: number;
     }>;
 }
+/**
+ * Zip extractor interface
+ */
 export interface ZipExtractor {
     extract(zipPath: string, targetDir: string): Promise<void>;
     list(zipPath: string): Promise<string[]>;
 }
+/**
+ * Module cache interface
+ */
 export interface ModuleCache {
     get(path: string): Promise<ModuleMetadata | null>;
     set(path: string, metadata: ModuleMetadata): Promise<void>;
@@ -112,6 +167,9 @@ export interface ModuleCache {
     delete(path: string): Promise<void>;
     clear(): Promise<void>;
 }
+/**
+ * Theme TOML structure
+ */
 export interface ThemeToml {
     module?: {
         imports?: {

package/dist/types/internal/domain/module/vo/cache.d.ts

@@ -1,23 +1,59 @@
 import { ModuleCache, ModuleMetadata } from '../type';
 import { Fs } from '../../fs/type';
+/**
+ * File system based module cache implementation
+ */
 export declare class FsModuleCache implements ModuleCache {
     private fs;
     private cacheDir;
     constructor(fs: Fs, cacheDir?: string);
+    /**
+     * Get module metadata from cache
+     */
     get(modulePath: string): Promise<ModuleMetadata | null>;
+    /**
+     * Set module metadata in cache
+     */
     set(modulePath: string, metadata: ModuleMetadata): Promise<void>;
+    /**
+     * Check if module exists in cache
+     */
     has(modulePath: string): Promise<boolean>;
+    /**
+     * Delete module from cache
+     */
     delete(modulePath: string): Promise<void>;
+    /**
+     * Clear all cache
+     */
     clear(): Promise<void>;
+    /**
+     * Get cache file path for module
+     */
     private getCacheFilePath;
+    /**
+     * Get cache directory
+     */
     getCacheDir(): string;
+    /**
+     * Get cache stats
+     */
     getStats(): Promise<{
         totalEntries: number;
         totalSize: number;
     }>;
+    /**
+     * List all cached modules
+     */
     listCached(): Promise<string[]>;
+    /**
+     * Helper to list cache files
+     */
     private listCacheFiles;
 }
+/**
+ * In-memory module cache implementation for testing
+ */
 export declare class MemoryModuleCache implements ModuleCache {
     private cache;
     get(modulePath: string): Promise<ModuleMetadata | null>;
@@ -25,8 +61,20 @@ export declare class MemoryModuleCache implements ModuleCache {
     has(modulePath: string): Promise<boolean>;
     delete(modulePath: string): Promise<void>;
     clear(): Promise<void>;
+    /**
+     * Get cache size for testing
+     */
     size(): number;
+    /**
+     * Get all keys for testing
+     */
     keys(): string[];
 }
+/**
+ * Creates a new file system based module cache
+ */
 export declare function newModuleCache(fs: Fs, cacheDir?: string): ModuleCache;
+/**
+ * Creates a new in-memory module cache for testing
+ */
 export declare function newMemoryModuleCache(): MemoryModuleCache;

package/dist/types/internal/domain/module/vo/httpclient.d.ts

@@ -1,5 +1,9 @@
 import { HttpClient, DownloadProgressCallback } from '../type';
 import { Fs } from '../../fs/type';
+/**
+ * Node.js HTTP client implementation using http/https modules
+ * Alternative to fetch API for better compatibility
+ */
 export declare class NodeHttpClient implements HttpClient {
     private fs;
     private timeout;
@@ -7,11 +11,17 @@ export declare class NodeHttpClient implements HttpClient {
     private defaultTimeout;
     private defaultHeaders;
     constructor(fs: Fs, timeout?: number, headers?: Record<string, string>);
+    /**
+     * Download file from URL to target path using Node.js http/https
+     */
     download(downloadUrl: string, targetPath: string, options?: {
         onProgress?: DownloadProgressCallback;
         headers?: Record<string, string>;
         timeout?: number;
     }): Promise<void>;
+    /**
+     * Perform GET request using Node.js http/https
+     */
     get(requestUrl: string, options?: {
         headers?: Record<string, string>;
         timeout?: number;
@@ -21,4 +31,8 @@ export declare class NodeHttpClient implements HttpClient {
         status: number;
     }>;
 }
+/**
+ * Creates a new HTTP client instance
+ * If a custom client is provided, it will be used instead of creating a new one
+ */
 export declare function newHttpClient(fs: Fs, timeout?: number, headers?: Record<string, string>, customClient?: HttpClient): HttpClient;