@mdfriday/foundry 26.4.20 → 26.5.2

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

@@ -1,16 +1,52 @@
 import { MarkdownConfig, MarkdownPlugins } from '../type';
+/**
+ * Markdown entity holds markdown renderer configuration
+ */
 export declare class Markdown {
     private markdownConfig;
     constructor(markdownConfig: MarkdownConfig);
+    /**
+     * Check if internal markdown renderer should be used
+     */
     useInternalRenderer(): boolean;
+    /**
+     * Check if wikilink plugin is enabled
+     */
     isWikilinkEnabled(): boolean;
+    /**
+     * Check if tag plugin is enabled
+     */
     isTagEnabled(): boolean;
+    /**
+     * Check if callout plugin is enabled
+     */
     isCalloutEnabled(): boolean;
+    /**
+     * Check if LaTeX plugin is enabled
+     */
     isLatexEnabled(): boolean;
+    /**
+     * Check if Mermaid plugin is enabled
+     */
     isMermaidEnabled(): boolean;
+    /**
+     * Get the markdown configuration
+     */
     getMarkdownConfig(): MarkdownConfig;
+    /**
+     * Get plugin configuration
+     */
     getPlugins(): MarkdownPlugins;
+    /**
+     * Check if any plugin is enabled
+     */
     hasEnabledPlugins(): boolean;
+    /**
+     * Validate the markdown configuration
+     */
     validate(): boolean;
 }
+/**
+ * Create a new Markdown instance from provider data
+ */
 export declare function newMarkdown(data: any): Markdown;

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

@@ -1,16 +1,52 @@
 import { ModuleConfig } from '../type';
+/**
+ * Module entity holds module configuration
+ */
 export declare class Module {
     private moduleConfig;
     constructor(moduleConfig: ModuleConfig);
+    /**
+     * Get import paths from module imports
+     */
     importPaths(): string[];
+    /**
+     * Get the module configuration
+     */
     getModuleConfig(): ModuleConfig;
+    /**
+     * Get all imports
+     */
     getImports(): import("../type").Import[];
+    /**
+     * Get all mounts
+     */
     getMounts(): import("../type").Mount[];
+    /**
+     * Get import count
+     */
     importCount(): number;
+    /**
+     * Get mount count
+     */
     mountCount(): number;
+    /**
+     * Check if module has imports
+     */
     hasImports(): boolean;
+    /**
+     * Check if module has mounts
+     */
     hasMounts(): boolean;
+    /**
+     * Find import by path
+     */
     findImport(path: string): import("../type").Import | undefined;
+    /**
+     * Find mount by source
+     */
     findMount(source: string): import("../type").Mount | undefined;
 }
+/**
+ * Create a new Module instance from provider data
+ */
 export declare function newModule(data: any): Module;

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

@@ -1,18 +1,57 @@
 import { RootConfig } from '../type';
+/**
+ * Root entity holds the root configuration
+ */
 export declare class Root {
     private rootConfig;
     private rootParams;
     constructor(rootConfig: RootConfig, rootParams?: Record<string, any>);
+    /**
+     * Get the default theme
+     */
     defaultTheme(): string;
+    /**
+     * Get the compiled timeout duration
+     */
     compiledTimeout(): number;
+    /**
+     * Get the base URL
+     */
     baseUrl(): string;
+    /**
+     * Get configuration parameters
+     */
     configParams(): Record<string, any>;
+    /**
+     * Get site title
+     */
     siteTitle(): string;
+    /**
+     * Get the root configuration
+     */
     getRootConfig(): RootConfig;
+    /**
+     * Get theme list
+     */
     getThemes(): string[];
+    /**
+     * Get default content language
+     */
     getDefaultContentLanguage(): string;
+    /**
+     * Check if drafts should be built
+     */
     shouldBuildDrafts(): boolean;
+    /**
+     * Check if future content should be built
+     */
     shouldBuildFuture(): boolean;
+    /**
+     * Check if expired content should be built
+     */
     shouldBuildExpired(): boolean;
 }
+/**
+ * Create a new Root instance from provider data
+ */
 export declare function newRoot(data: any, params?: Record<string, any>): Root;

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

@@ -1,19 +1,55 @@
 import { ServiceConfig } from '../type';
+/**
+ * Service entity holds service configuration
+ */
 export declare class Service {
     private serviceConfig;
     constructor(serviceConfig: ServiceConfig);
+    /**
+     * Check if Google Analytics is enabled
+     */
     isGoogleAnalyticsEnabled(): boolean;
+    /**
+     * Get Google Analytics ID
+     */
     googleAnalyticsID(): string;
+    /**
+     * Check if Google Analytics should respect Do Not Track
+     */
     isGoogleAnalyticsRespectDoNotTrack(): boolean;
+    /**
+     * Check if Disqus is enabled
+     */
     isDisqusEnabled(): boolean;
     disqusShortname(): string;
     isXRespectDoNotTrack(): boolean;
     isXDisableInlineCSS(): boolean;
+    /**
+     * Get RSS limit
+     */
     rssLimit(): number;
+    /**
+     * Get the service configuration
+     */
     getServiceConfig(): ServiceConfig;
+    /**
+     * Get Google Analytics configuration
+     */
     getGoogleAnalytics(): import("../type").GoogleAnalytics;
+    /**
+     * Get Disqus configuration
+     */
     getDisqus(): import("../type").Disqus;
+    /**
+     * Get RSS configuration
+     */
     getRSS(): import("../type").RSS;
+    /**
+     * Check if any service is enabled
+     */
     hasEnabledServices(): boolean;
 }
+/**
+ * Create a new Service instance from provider data
+ */
 export declare function newService(data: any): Service;

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>;