@mdfriday/foundry 26.4.20 → 26.5.1

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

@@ -1,9 +1,15 @@
 import { Template } from '@mdfriday/text-template';
 import { FileMetaInfo, WalkCallback, WalkwayConfig } from '../fs/type';
 import { Resource } from '@internal/domain/resources';
+/**
+ * Template domain constants
+ */
 export declare const BASE_FILE_BASE = "baseof";
 export declare const BASE_DEFAULT = "_default";
 export declare const PARTIALS_PREFIX = "partials/";
+/**
+ * Template error types
+ */
 export declare class TemplateError extends Error {
     code?: string | undefined;
     constructor(message: string, code?: string | undefined);
@@ -12,60 +18,102 @@ export declare const ErrTemplateNotFound: TemplateError;
 export declare const ErrTemplateParseFailed: TemplateError;
 export declare const ErrTemplateExecuteFailed: TemplateError;
 export declare const ErrInvalidTemplate: TemplateError;
+/**
+ * Template file system interface
+ */
 export interface TemplateFs {
     walk(start: string, cb: WalkCallback, conf: WalkwayConfig): Promise<void>;
 }
+/**
+ * Template information
+ */
 export interface TemplateInfo {
     name: string;
     template: string;
     fi: FileMetaInfo;
     isZero(): boolean;
 }
+/**
+ * Template type enumeration
+ */
 export declare enum TemplateType {
     TypeUndefined = 0,
     TypeShortcode = 1,
     TypePartial = 2
 }
+/**
+ * Template state - parsed template with metadata
+ */
 export interface TemplateState {
     template: Template;
     info: TemplateInfo;
     baseInfo?: TemplateInfo;
     type: TemplateType;
 }
+/**
+ * Base template configuration
+ */
 export interface BaseOfConfig {
     baseof: Map<string, TemplateInfo>;
     needsBaseof: Map<string, TemplateInfo>;
 }
+/**
+ * Template lookup function
+ */
 export type TemplateLookupFunc = (name: string) => TemplateState | null;
+/**
+ * Template function map
+ */
 export type TemplateFuncMap = Map<string, any>;
+/**
+ * Template execution context
+ */
 export interface TemplateExecutionContext {
     data?: any;
     funcMap?: TemplateFuncMap;
 }
+/**
+ * Template parse configuration
+ */
 export interface TemplateParseConfig {
     name: string;
     template: string;
     funcMap?: TemplateFuncMap;
 }
+/**
+ * Template namespace interface
+ */
 export interface TemplateNamespace {
     addTemplate(name: string, state: TemplateState): void;
     findTemplate(name: string): TemplateState | null;
     lookup(name: string): Template | null;
     getTemplates(): Map<string, TemplateState>;
 }
+/**
+ * Regular template namespace interface - supports baseof dependencies
+ */
 export interface RegularTemplateNamespaceInterface extends TemplateNamespace {
     findTemplateWithDependencies(name: string): TemplateState | null;
     getTemplatesNeedingBase(): TemplateState[];
 }
+/**
+ * Partial template namespace interface - simple lookup only
+ */
 export interface PartialTemplateNamespaceInterface extends TemplateNamespace {
     addPartialTemplate(name: string, state: TemplateState): void;
 }
+/**
+ * Shortcode template namespace interface - simplest lookup
+ */
 export interface ShortcodeTemplateNamespaceInterface extends TemplateNamespace {
     addShortcodeTemplate(name: string, state: TemplateState): void;
     getShortcode(name: string): Template | null;
     hasShortcode(name: string): boolean;
     getShortcodeNames(): string[];
 }
+/**
+ * Template lookup interface
+ */
 export interface TemplateLookup {
     findNoDependence(name: string, ns: TemplateNamespace): [Template | null, boolean, Error | null];
     findDependentInfo(name: string): [TemplateInfo | null, TemplateInfo | null, boolean];
@@ -74,15 +122,24 @@ export interface TemplateLookup {
     findPartial(name: string, partialNS: PartialTemplateNamespaceInterface): [Template | null, boolean, Error | null];
     findShortcode(name: string, shortcodeNS: ShortcodeTemplateNamespaceInterface): [Template | null, boolean, Error | null];
 }
+/**
+ * Template parser interface
+ */
 export interface TemplateParser {
     parse(info: TemplateInfo): Promise<TemplateState>;
     parseWithLock(name: string, tpl: string): Promise<Template>;
     parseOverlap(overlay: TemplateInfo, base: TemplateInfo, lookup: TemplateLookupFunc): Promise<[TemplateState | null, boolean, Error | null]>;
     markReady(): Promise<void>;
 }
+/**
+ * Template executor interface
+ */
 export interface TemplateExecutor {
     execute(tmpl: Template, data: any): Promise<string>;
 }
+/**
+ * Base template manager interface
+ */
 export interface BaseOfManager {
     getTemplateSearchOrder(templateName: string): string[];
     getBaseOf(key: string): TemplateInfo | null;
@@ -92,11 +149,17 @@ export interface BaseOfManager {
     isBaseTemplatePath(path: string): boolean;
     needsBaseOf(name: string, rawContent: string): boolean;
 }
+/**
+ * Template engine interface
+ */
 export interface TemplateEngine {
     findFirst(names: string[]): Promise<[Template | null, string | null, boolean, Error | null]>;
     loadTemplates(): Promise<void>;
     markReady(): Promise<void>;
 }
+/**
+ * Template builder interface
+ */
 export interface TemplateBuilder {
     withFs(fs: TemplateFs): TemplateBuilder;
     withNamespace(ns: TemplateNamespace): TemplateBuilder;
@@ -106,29 +169,53 @@ export interface TemplateBuilder {
     buildExecutor(): TemplateBuilder;
     build(): Promise<TemplateEngine>;
 }
+/**
+ * Template factory interface
+ */
 export interface TemplateFactory {
     create(fs: TemplateFs): Promise<TemplateEngine>;
     createWithConfig(fs: TemplateFs, config: TemplateFactoryConfig): Promise<TemplateEngine>;
 }
+/**
+ * Template factory configuration
+ */
 export interface TemplateFactoryConfig {
     funcMap?: TemplateFuncMap;
     debug?: boolean;
 }
+/**
+ * Template walk callback result
+ */
 export interface TemplateWalkResult {
     templates: TemplateInfo[];
     errors: Error[];
 }
+/**
+ * Template dependencies
+ */
 export interface TemplateDependencies {
     [templateName: string]: TemplateState;
 }
+/**
+ * URL service interface for template functions
+ * TypeScript equivalent of urls.URL interface
+ */
 export interface URLService {
     relURL(input: string): string;
     absURL(input: string): string;
     urlize(uri: string): string;
 }
+/**
+ * RefSource service interface for template functions
+ * TypeScript equivalent of urls.RefSource interface
+ */
 export interface RefSourceService {
     relRefFrom(argsm: Record<string, any>, source: any): Promise<[string, Error | null]>;
 }
+/**
+ * Site service interface - provides site-level operations
+ * Equivalent to Go's site.Service interface
+ */
 export interface SiteService {
     title(): string;
     baseURL(): string;
@@ -144,28 +231,50 @@ export interface ResourcesService {
     ExecuteAsTemplate(targetPath: string, data: any, resource: Resource): Promise<Resource>;
     GetRemote(uri: string): Promise<Resource | null>;
 }
+/**
+ * Hugo info service interface for template functions
+ * TypeScript equivalent of hugo.Info interface
+ */
 export interface HugoInfoService {
     version(): string;
     environment(): string;
     generator(): string;
 }
+/**
+ * Language service interface for template functions
+ * TypeScript equivalent of collections.Language interface
+ */
 export interface LanguageService {
     defaultLanguage(): string;
     languageKeys(): string[];
     isMultiLanguage(): boolean;
 }
+/**
+ * Customized functions interface - aggregates all services needed by template domain
+ * TypeScript equivalent of Go's template.CustomizedFunctions interface
+ * This interface abstracts all external dependencies needed by template functions
+ */
 export interface CustomizedFunctions extends URLService, RefSourceService, SiteService, ResourcesService, HugoInfoService, LanguageService {
 }
+/**
+ * Template engine interface
+ */
 export interface TemplateEngine {
     findFirst(names: string[]): Promise<[Template | null, string | null, boolean, Error | null]>;
     loadTemplates(): Promise<void>;
     markReady(): Promise<void>;
 }
+/**
+ * Template factory interface
+ */
 export interface TemplateFactory {
     create(fs: TemplateFs): Promise<TemplateEngine>;
     createWithConfig(fs: TemplateFs, config: TemplateFactoryConfig): Promise<TemplateEngine>;
     createWithServices(fs: TemplateFs, services: CustomizedFunctions): Promise<TemplateEngine>;
 }
+/**
+ * Template factory configuration
+ */
 export interface TemplateFactoryConfig {
     funcMap?: TemplateFuncMap;
     services?: CustomizedFunctions;

package/dist/types/internal/domain/template/vo/baseof.d.ts

@@ -1,22 +1,69 @@
 import { BaseOfManager, TemplateInfo } from '../type';
+/**
+ * BaseOf value object for managing base template inheritance
+ * TypeScript version of Go's BaseOf struct
+ */
 export declare class BaseOf implements BaseOfManager {
     private baseof;
     private needsBaseof;
+    /**
+     * Get template search order for finding base templates
+     */
     getTemplateSearchOrder(templateName: string): string[];
+    /**
+     * Get base template info by key
+     */
     getBaseOf(key: string): TemplateInfo | null;
+    /**
+     * Get template that needs base template by key
+     */
     getNeedsBaseOf(key: string): TemplateInfo | null;
+    /**
+     * Add base template
+     */
     addBaseOf(key: string, info: TemplateInfo): void;
+    /**
+     * Add template that needs base template
+     */
     addNeedsBaseOf(key: string, info: TemplateInfo): void;
+    /**
+     * Check if path is a base template path
+     */
     isBaseTemplatePath(filePath: string): boolean;
+    /**
+     * Check if template needs base template
+     */
     needsBaseOf(name: string, rawContent: string): boolean;
+    /**
+     * Check if template doesn't need base template
+     */
     private noBaseNeeded;
+    /**
+     * Check if template content needs base template
+     * Returns true if the first non-comment template block is a define block
+     */
     private needsBaseTemplate;
+    /**
+     * Get all base templates
+     */
     getAllBaseOf(): Map<string, TemplateInfo>;
+    /**
+     * Get all templates that need base templates
+     */
     getAllNeedsBaseOf(): Map<string, TemplateInfo>;
+    /**
+     * Clear all base template data
+     */
     clear(): void;
+    /**
+     * Get statistics
+     */
     getStats(): {
         baseOfCount: number;
         needsBaseOfCount: number;
     };
 }
+/**
+ * Creates a new BaseOf instance
+ */
 export declare function newBaseOf(): BaseOf;

package/dist/types/internal/domain/template/vo/info.d.ts

@@ -5,12 +5,40 @@ export declare class TemplateInfo implements ITemplateInfo {
     template: string;
     fi: FileMetaInfo;
     constructor(name: string, template: string, fi: FileMetaInfo);
+    /**
+     * Get identifier base
+     */
     identifierBase(): string;
+    /**
+     * Create error with file context
+     */
     errWithFileContext(what: string, err: Error): TemplateError;
+    /**
+     * Check if template info is zero value
+     */
     isZero(): boolean;
+    /**
+     * Create a copy of this template info
+     */
     copy(): TemplateInfo;
+    /**
+     * Get template content without BOM
+     */
     getCleanContent(): string;
 }
+/**
+ * Load template from file meta info
+ */
 export declare function loadTemplate(name: string, fim: FileMetaInfo): Promise<TemplateInfo>;
+/**
+ * Resolve template type based on template name
+ * @param name - Template name/path
+ * @returns Template type
+ */
 export declare function resolveTemplateType(name: string): TemplateType;
+/**
+ * Check if template name indicates a shortcode
+ * @param name - Template name/path
+ * @returns true if it's a shortcode template
+ */
 export declare function isShortcode(name: string): boolean;

package/dist/types/internal/domain/template/vo/namespace.d.ts

@@ -1,38 +1,129 @@
 import { Template } from '@mdfriday/text-template';
 import { TemplateNamespace, TemplateState } from '../type';
+/**
+ * Base namespace for template storage with common functionality
+ * Abstract base class for different template namespace types
+ */
 declare abstract class BaseNamespace<T extends TemplateState> {
     protected templates: Map<string, T>;
     protected readonly mutex: Set<string>;
+    /**
+     * Add template to namespace
+     */
     addTemplate(name: string, state: T): void;
+    /**
+     * Find template in namespace
+     */
     findTemplate(name: string): T | null;
+    /**
+     * Get all templates
+     */
     getTemplates(): Map<string, T>;
+    /**
+     * Check if template exists
+     */
     hasTemplate(name: string): boolean;
+    /**
+     * Get template names
+     */
     getTemplateNames(): string[];
+    /**
+     * Remove template
+     */
     removeTemplate(name: string): boolean;
+    /**
+     * Clear all templates
+     */
     clear(): void;
+    /**
+     * Get template count
+     */
     size(): number;
+    /**
+     * Get templates by pattern
+     */
     getTemplatesByPattern(pattern: RegExp): T[];
+    /**
+     * Simple lock mechanism for thread safety simulation
+     */
     protected withLock<R>(fn: () => R): R;
+    /**
+     * Simple read lock mechanism
+     */
     protected withReadLock<R>(fn: () => R): R;
+    /**
+     * Abstract method for type-specific lookup logic
+     */
     abstract lookup(name: string): Template | null;
 }
+/**
+ * Regular template namespace - supports baseof dependencies and template keywords
+ * Handles complex template dependencies and inheritance
+ */
 export declare class RegularTemplateNamespace extends BaseNamespace<TemplateState> implements TemplateNamespace {
+    /**
+     * Lookup template by name with dependency support
+     */
     lookup(name: string): Template | null;
+    /**
+     * Find template with dependency information for baseof processing
+     */
     findTemplateWithDependencies(name: string): TemplateState | null;
+    /**
+     * Get templates that need baseof
+     */
     getTemplatesNeedingBase(): TemplateState[];
 }
+/**
+ * Partial template namespace - simple lookup, no template keyword support
+ * For templates in the partials/ directory
+ */
 export declare class PartialTemplateNamespace extends BaseNamespace<TemplateState> {
+    /**
+     * Simple lookup for partial templates
+     */
     lookup(name: string): Template | null;
+    /**
+     * Add partial template with validation
+     */
     addPartialTemplate(name: string, state: TemplateState): void;
 }
+/**
+ * Shortcode template namespace - simplest lookup, no dependencies allowed
+ * For shortcode templates with content-focused rendering
+ */
 export declare class ShortcodeTemplateNamespace extends BaseNamespace<TemplateState> {
+    /**
+     * Simple lookup for shortcode templates
+     */
     lookup(name: string): Template | null;
+    /**
+     * Add shortcode template with validation
+     */
     addShortcodeTemplate(name: string, state: TemplateState): void;
+    /**
+     * Get shortcode by name (alias for lookup for clarity)
+     */
     getShortcode(name: string): Template | null;
+    /**
+     * Check if shortcode exists
+     */
     hasShortcode(name: string): boolean;
+    /**
+     * Get all shortcode names
+     */
     getShortcodeNames(): string[];
 }
+/**
+ * Create a new regular template namespace
+ */
 export declare function newRegularTemplateNamespace(): RegularTemplateNamespace;
+/**
+ * Create a new partial template namespace
+ */
 export declare function newPartialTemplateNamespace(): PartialTemplateNamespace;
+/**
+ * Create a new shortcode template namespace
+ */
 export declare function newShortcodeTemplateNamespace(): ShortcodeTemplateNamespace;
 export {};