@mdfriday/foundry 26.4.20 → 26.5.1

package/dist/types/internal/domain/config/entity/social.d.ts

@@ -1,22 +1,65 @@
 import { SocialConfig, SocialPlatformTemplate, SocialUserConfig } from '../type';
+/**
+ * Processed social link with complete information
+ */
 export interface ProcessedSocialLink {
     id: string;
     title: string;
     url: string;
 }
+/**
+ * Social entity holds social configuration and provides business logic
+ */
 export declare class Social {
     private socialConfig;
     constructor(socialConfig: SocialConfig);
+    /**
+     * Get user social configuration
+     */
     getUserConfig(): SocialUserConfig;
+    /**
+     * Get all available social platform templates
+     */
     getPlatformTemplates(): SocialPlatformTemplate[];
+    /**
+     * Get social platform template by platform ID
+     */
     getPlatformTemplate(platformId: string): SocialPlatformTemplate | undefined;
+    /**
+     * Check if a social platform is configured by user
+     */
     isPlatformConfigured(platformId: string): boolean;
+    /**
+     * Get configured social platforms
+     */
     getConfiguredPlatforms(): string[];
+    /**
+     * Get processed social links ready for template rendering
+     * This combines user configuration with icon templates
+     */
     getProcessedSocialLinks(): ProcessedSocialLink[];
+    /**
+     * Get social link for a specific platform
+     */
     getSocialLink(platformId: string): ProcessedSocialLink | undefined;
+    /**
+     * Check if any social platforms are configured
+     */
     hasSocialLinks(): boolean;
+    /**
+     * Get the number of configured social platforms
+     */
     getSocialLinkCount(): number;
+    /**
+     * Get available social platforms (from templates)
+     */
     getAvailablePlatforms(): string[];
+    /**
+     * Get social configuration
+     */
     getSocialConfig(): SocialConfig;
 }
+/**
+ * Create a new Social instance from provider data
+ */
 export declare function newSocial(data: any): Social;

package/dist/types/internal/domain/config/entity/taxonomy.d.ts

@@ -1,19 +1,58 @@
 import { ViewName } from '../type';
+/**
+ * Taxonomy entity holds taxonomy configuration
+ */
 export declare class Taxonomy {
     private taxonomies;
     private views;
     private viewsByTreeKey;
     constructor(taxonomies: Record<string, string>);
+    /**
+     * Get taxonomy views
+     */
     getViews(): ViewName[];
+    /**
+     * Get taxonomies configuration
+     */
     getTaxonomies(): Record<string, string>;
+    /**
+     * Get view by tree key
+     */
     getViewByTreeKey(treeKey: string): ViewName | undefined;
+    /**
+     * Check if taxonomy exists
+     */
     hasTaxonomy(singular: string): boolean;
+    /**
+     * Get plural form of taxonomy
+     */
     getPluralForm(singular: string): string | undefined;
+    /**
+     * Get singular form from plural
+     */
     getSingularForm(plural: string): string | undefined;
+    /**
+     * Get all singular forms
+     */
     getSingularForms(): string[];
+    /**
+     * Get all plural forms
+     */
     getPluralForms(): string[];
+    /**
+     * Setup taxonomy views
+     */
     private setupViews;
+    /**
+     * Get view count
+     */
     getViewCount(): number;
+    /**
+     * Check if taxonomies are empty
+     */
     isEmpty(): boolean;
 }
+/**
+ * Create a new Taxonomy instance from provider data
+ */
 export declare function newTaxonomy(data: any): Taxonomy;

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

@@ -1,3 +1,6 @@
 import { Config } from '../entity/config';
 import { Fs } from '@internal/domain/fs/type';
+/**
+ * Load configuration with custom parameters
+ */
 export declare function loadConfigWithParams(fs: Fs, configFilename: string, workingDir: string, modulesDir: string, params?: Record<string, any>): Promise<Config>;

package/dist/types/internal/domain/config/factory/loader.d.ts

@@ -1,20 +1,44 @@
 import { Provider } from '../type';
 import { SourceDescriptor } from './sourcedescriptor';
+/**
+ * BaseDirs holds the base directories for the configuration
+ */
 export interface BaseDirs {
     workingDir: string;
     modulesDir: string;
     publishDir: string;
     cacheDir: string;
 }
+/**
+ * ConfigLoader loads and assembles configuration
+ */
 export declare class ConfigLoader {
     private cfg;
     private sourceDescriptor;
     private baseDirs;
     constructor(sourceDescriptor: SourceDescriptor, baseDirs: BaseDirs);
+    /**
+     * Load configuration by default
+     */
     loadConfigByDefault(): Promise<Provider>;
+    /**
+     * Delete merge strategies
+     */
     deleteMergeStrategies(): void;
+    /**
+     * Load provider from config file
+     */
     private loadProvider;
+    /**
+     * Apply default configuration settings
+     */
     private applyDefaultConfig;
+    /**
+     * Check if file exists
+     */
     private fileExists;
+    /**
+     * Load configuration from file
+     */
     private loadConfigFromFile;
 }

package/dist/types/internal/domain/config/factory/provider.d.ts

@@ -1,4 +1,8 @@
 import { Provider } from '../type';
+/**
+ * DefaultConfigProvider is a Provider backed by a map where all keys are lower case
+ * All methods are thread safe (in single-threaded JS environment)
+ */
 export declare class DefaultConfigProvider implements Provider {
     private root;
     private keyCache;
@@ -21,5 +25,11 @@ export declare class DefaultConfigProvider implements Provider {
     walkParams(walkFn: (params: Record<string, any>) => boolean): void;
     isSet(key: string): boolean;
 }
+/**
+ * Create a Provider backed by params
+ */
 export declare function newFromParams(params: Record<string, any>): Provider;
+/**
+ * Create a Provider backed by an empty params object
+ */
 export declare function newDefaultProvider(): Provider;

package/dist/types/internal/domain/config/factory/sourcedescriptor.d.ts

@@ -1,6 +1,18 @@
 import { Fs } from '@internal/domain/fs/type';
+/**
+ * SourceDescriptor describes where to find the config (e.g. config.toml etc.)
+ */
 export interface SourceDescriptor {
+    /**
+     * Get the filesystem
+     */
     fs(): Fs;
+    /**
+     * Get the filename - RelPath to the config file to use, e.g. /my/project/config.toml
+     */
     filename(): string;
 }
+/**
+ * Create a new SourceDescriptor
+ */
 export declare function newSourceDescriptor(fs: Fs, filename: string): SourceDescriptor;

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

@@ -1,3 +1,6 @@
+/**
+ * Provider provides the configuration settings interface
+ */
 export interface Provider {
     getString(key: string): string;
     getInt(key: string): number;
@@ -15,21 +18,33 @@ export interface Provider {
     walkParams(walkFn: (params: Record<string, any>) => boolean): void;
     isSet(key: string): boolean;
 }
+/**
+ * Mount configuration for modules
+ */
 export interface Mount {
     source: string;
     target: string;
     lang?: string;
 }
+/**
+ * Import represents a module import configuration
+ */
 export interface Import {
     path: string;
     url?: string;
     version?: string;
     mounts?: Mount[];
 }
+/**
+ * ModuleConfig represents module configuration with imports
+ */
 export interface ModuleConfig {
     mounts: Mount[];
     imports: Import[];
 }
+/**
+ * RootConfig holds all the top-level configuration options
+ */
 export interface RootConfig {
     baseURL: string;
     title: string;
@@ -63,6 +78,9 @@ export interface BaseDir {
     publishDir: string;
     cacheDir: string;
 }
+/**
+ * LanguageConfig represents a single language configuration
+ */
 export interface LanguageConfig {
     languageCode: string;
     languageName: string;
@@ -72,6 +90,9 @@ export interface LanguageConfig {
     disabled: boolean;
     params: Record<string, any>;
 }
+/**
+ * GoogleAnalytics service configuration
+ */
 export interface GoogleAnalytics {
     disable: boolean;
     respectDoNotTrack: boolean;
@@ -81,37 +102,61 @@ export interface X {
     respectDoNotTrack: boolean;
     disableInlineCSS: boolean;
 }
+/**
+ * Disqus service configuration
+ */
 export interface Disqus {
     disable: boolean;
     shortname: string;
 }
+/**
+ * RSS service configuration
+ */
 export interface RSS {
     limit: number;
 }
+/**
+ * ServiceConfig holds service-related configurations
+ */
 export interface ServiceConfig {
     disqus: Disqus;
     googleAnalytics: GoogleAnalytics;
     rss: RSS;
     x: X;
 }
+/**
+ * Social platform template configuration
+ */
 export interface SocialPlatformTemplate {
     id: string;
     title: string;
 }
+/**
+ * User social configuration
+ */
 export interface SocialUserConfig {
     [key: string]: {
         link: string;
     };
 }
+/**
+ * Social configuration
+ */
 export interface SocialConfig {
     userConfig: SocialUserConfig;
     platformTemplates: SocialPlatformTemplate[];
 }
+/**
+ * ViewName represents a taxonomy view
+ */
 export interface ViewName {
     singular: string;
     plural: string;
     pluralTreeKey: string;
 }
+/**
+ * Markdown plugin configuration
+ */
 export interface MarkdownPlugins {
     wikilink: boolean;
     tag: boolean;
@@ -119,14 +164,25 @@ export interface MarkdownPlugins {
     latex: boolean;
     mermaid: boolean;
 }
+/**
+ * Markdown configuration
+ */
 export interface MarkdownConfig {
+    /** Use internal markdown renderer */
     useInternalRenderer: boolean;
+    /** Plugin configuration */
     plugins: MarkdownPlugins;
 }
+/**
+ * ConfigError represents configuration related errors
+ */
 export declare class ConfigError extends Error {
     code?: string | undefined;
     constructor(message: string, code?: string | undefined);
 }
+/**
+ * Predefined configuration errors
+ */
 export declare const ErrConfigNotFound: ConfigError;
 export declare const ErrInvalidConfig: ConfigError;
 export declare const ErrWorkspaceNotFound: ConfigError;

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

@@ -1,4 +1,10 @@
 import { LanguageConfig } from '../type';
+/**
+ * Default language configuration
+ */
 export declare const DefaultLanguageConfig: Partial<LanguageConfig>;
 export declare function decodeLanguageConfig(data: any): Record<string, LanguageConfig>;
+/**
+ * Validates language configuration
+ */
 export declare function validateLanguageConfig(configs: Record<string, LanguageConfig>, defaultLang: string): boolean;

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

@@ -1,5 +1,18 @@
 import { MarkdownConfig, MarkdownPlugins } from '../type';
+/**
+ * Default markdown plugin configuration
+ * All plugins are enabled by default
+ */
 export declare const DefaultMarkdownPlugins: MarkdownPlugins;
+/**
+ * Default markdown configuration
+ */
 export declare const DefaultMarkdownConfig: MarkdownConfig;
+/**
+ * Creates a markdown configuration from provider data
+ */
 export declare function decodeMarkdownConfig(data: any): MarkdownConfig;
+/**
+ * Checks if markdown configuration uses default settings
+ */
 export declare function isDefaultMarkdownConfig(config: MarkdownConfig): boolean;

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

@@ -1,4 +1,13 @@
 import { ModuleConfig } from '../type';
+/**
+ * Empty module configuration
+ */
 export declare const EmptyModuleConfig: ModuleConfig;
+/**
+ * Creates a module configuration from provider data
+ */
 export declare function decodeModuleConfig(data: any): ModuleConfig;
+/**
+ * Checks if a module configuration is empty
+ */
 export declare function isEmptyModuleConfig(config: ModuleConfig): boolean;

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

@@ -1,3 +1,9 @@
 import { RootConfig } from '../type';
+/**
+ * Default root configuration
+ */
 export declare const DefaultRootConfig: Partial<RootConfig>;
+/**
+ * Creates a root configuration from provider data
+ */
 export declare function decodeRootConfig(data: any): RootConfig;

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

@@ -1,3 +1,9 @@
 import { ServiceConfig } from '../type';
+/**
+ * Default service configuration
+ */
 export declare const DefaultServiceConfig: ServiceConfig;
+/**
+ * Creates a service configuration from provider data
+ */
 export declare function decodeServiceConfig(services: any): ServiceConfig;

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

@@ -1,6 +1,22 @@
 import { SocialConfig, SocialPlatformTemplate } from '../type';
+/**
+ * Predefined social platform templates
+ * Based on popular social platforms with their titles
+ */
 export declare const DefaultSocialPlatformTemplates: SocialPlatformTemplate[];
+/**
+ * Default social configuration
+ */
 export declare const DefaultSocialConfig: SocialConfig;
+/**
+ * Creates a social configuration from provider data
+ */
 export declare function decodeSocialConfig(social: any): SocialConfig;
+/**
+ * Get social platform template by ID
+ */
 export declare function getSocialPlatformTemplate(id: string): SocialPlatformTemplate | undefined;
+/**
+ * Get all available social platform IDs
+ */
 export declare function getAvailableSocialPlatforms(): string[];

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

@@ -1,5 +1,17 @@
 import { ViewName } from '../type';
+/**
+ * Default taxonomies
+ */
 export declare const DefaultTaxonomies: Record<string, string>;
+/**
+ * Creates a clean tree key for taxonomy
+ */
 export declare function cleanTreeKey(...elems: string[]): string;
+/**
+ * Creates taxonomy views from taxonomies configuration
+ */
 export declare function setupTaxonomyViews(taxonomies: Record<string, string>): ViewName[];
+/**
+ * Creates taxonomy configuration from provider data
+ */
 export declare function decodeTaxonomyConfig(data: any): Record<string, string>;

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

@@ -15,16 +15,52 @@ export declare class Content {
     collectPages(): Promise<void>;
     private process;
     private assemble;
+    /**
+     * GetPageSources - exact replica of Go's GetPageSources method
+     */
     getPageSources(page: Page): Promise<PageSource[]>;
+    /**
+     * GlobalPages - exact replica of Go's GlobalPages method
+     */
     globalPages(langIndex: number): Promise<Pages>;
     globalRegularPages(): Promise<Pages>;
+    /**
+     * WalkPages - exact replica of Go's WalkPages method
+     * TypeScript equivalent of golang/internal/domain/contenthub/entity/walk.go:WalkPages
+     */
     walkPages(langIndex: number, walker: (page: Page) => Promise<void>): Promise<void>;
+    /**
+     * WalkTaxonomies - exact replica of Go's WalkTaxonomies method
+     * TypeScript equivalent of golang/internal/domain/contenthub/entity/walk.go:WalkTaxonomies
+     */
     walkTaxonomies(langIndex: number, walker: WalkTaxonomyFunc): Promise<void>;
+    /**
+     * GetPageFromPath - TypeScript equivalent of Go's PageFinder.GetPageFromPath
+     * This is the core content domain business logic for finding pages by path
+     */
     getPageFromPath(langIndex: number, path: string): Page | null;
     getPageFromFile(langIndex: number, file: FileInfo): Page | null;
     handleChangeFiles(fileMetaInfos: Map<string, FileMetaInfo>): Promise<string[]>;
+    /**
+     * 添加或更新文件到 PageMap，参考 collectDir 中的实现
+     */
     private addOrUpdateFile;
+    /**
+     * Translate a message for a specific language
+     * @param lang Language code
+     * @param translationID Translation identifier
+     * @returns Translated string
+     */
     translate(lang: string, translationID: string): string;
+    /**
+     * Get available translation languages
+     * @returns Array of language codes
+     */
     getAvailableLanguages(): string[];
+    /**
+     * Check if a language has translation support
+     * @param lang Language code
+     * @returns True if language is supported
+     */
     hasLanguageSupport(lang: string): boolean;
 }

package/dist/types/internal/domain/content/entity/page.d.ts

@@ -26,13 +26,36 @@ export declare class PageImpl implements Page {
     section(): string;
     paths(): Path;
     path(): string;
+    /**
+     * Get page slug for PageGraph (Quartz-compatible format)
+     * Slug format: "posts/my-post" (no leading slash, no extension)
+     *
+     * Examples:
+     * - "/posts/my-post.md" → "posts/my-post"
+     * - "/posts/index.md" → "posts"
+     * - "/about.md" → "about"
+     * - "/index.md" → "index"
+     */
     slug(): string;
+    /**
+     * Convert path to slug (Quartz-compatible)
+     *
+     * Rules:
+     * 1. Remove leading slash
+     * 2. Remove file extension
+     * 3. Handle index files (index → parent folder)
+     * 4. Handle _index files (Hugo-style section index)
+     */
     private pathToSlug;
     posOffset(offset: number): Promise<Position>;
     description(): string;
     get Description(): string;
     StaticURL(src: string): string;
     params(): Record<string, any>;
+    /**
+     * Template-friendly Params property getter
+     * Allows templates to access .Params instead of .params()
+     */
     get Params(): Record<string, any>;
     store(): Scratch;
     get Store(): Scratch;

package/dist/types/internal/domain/content/entity/pagebuilder.d.ts

@@ -28,35 +28,118 @@ export declare class PageBuilder {
     private renderableDocument;
     constructor(urlSvc: URLService, langSvc: LangService, taxonomySvc: TaxonomyService, templateSvc: Template | null, pageMapper: PageMap | null, taxonomy: Taxonomy, term: Term, section: Section, standalone: Standalone, converter: Converter, contentHub: ContentHub | null);
     withSource(source: Source): PageBuilder;
+    /**
+     * WithLangIdx - exact replica of Go's WithLangIdx method
+     */
     withLangIdx(idx: number): PageBuilder;
+    /**
+     * Reset - exact replica of Go's reset method
+     */
     private reset;
+    /**
+     * Build - exact replica of Go's Build method
+     */
     build(): Promise<Page>;
+    /**
+     * KindBuild - exact replica of Go's KindBuild method
+     */
     kindBuild(): Promise<Page>;
+    /**
+     * Build internal - exact replica of Go's build method
+     */
     private buildInternal;
+    /**
+     * Build page - exact replica of Go's buildPage method
+     */
     private buildPage;
+    /**
+     * Build page with kind - exact replica of Go's buildPageWithKind method
+     */
     private buildPageWithKind;
+    /**
+     * Apply front matter - exact replica of Go's applyFrontMatter method
+     */
     private applyFrontMatter;
+    /**
+     * Build home - exact replica of Go's buildHome method
+     */
     private buildHome;
+    /**
+     * Build section - exact replica of Go's buildSection method
+     */
     private buildSection;
+    /**
+     * Build 404 - exact replica of Go's build404 method
+     */
     private build404;
+    /**
+     * Build sitemap - exact replica of Go's buildSitemap method
+     */
     private buildSitemap;
+    /**
+     * Build taxonomy - exact replica of Go's buildTaxonomy method
+     */
     private buildTaxonomy;
+    /**
+     * Build term - exact replica of Go's buildTerm method
+     */
     private buildTerm;
     private render;
     private parse;
+    /**
+     * Parse terms - exact replica of Go's parseTerms method
+     */
     private parseTerms;
+    /**
+     * Parse kind - exact replica of Go's parseKind method
+     */
     private parseKind;
+    /**
+     * Parse language by default - exact replica of Go's parseLanguageByDefault method
+     */
     private parseLanguageByDefault;
+    /**
+     * Parse language by index - exact replica of Go's parseLanguageByIdx method
+     */
     private parseLanguageByIdx;
+    /**
+     * Parse language - exact replica of Go's parseLanguage method
+     */
     private parseLanguage;
+    /**
+     * Parse front matter - exact replica of Go's parseFrontMatter method
+     */
     private parseFrontMatter;
+    /**
+     * Create shortcode renderer - returns a simple renderer for shortcodes
+     */
     private createShortcodeRenderer;
     private doRenderShortcode;
     private renderShortcodeMarkdown;
+    /**
+     * Build pagination - creates pagination for page
+     * TypeScript equivalent of Go's buildPagination method
+     */
     private buildPagination;
+    /**
+     * Adapt pagination - creates empty pagination for pages that don't support it
+     * TypeScript equivalent of Go's adaptPagination method
+     */
     private adaptPagination;
+    /**
+     * Build output - builds page output
+     */
     private buildOutput;
+    /**
+     * New page - creates a new page instance based on Go version
+     */
     private newPage;
+    /**
+     * New taxonomy - creates a new taxonomy page
+     */
     private newTaxonomy;
+    /**
+     * New term - creates a new term page
+     */
     private newTerm;
 }