@mdfriday/foundry 25.11.12 → 25.11.14

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

@@ -1,15 +1,9 @@
 import { Template } from '@mdfriday/text-template';
 import { FileMetaInfo, WalkCallback, WalkwayConfig } from '../fs/type';
-import { Resource } from '../../domain/resources';
-/**
- * Template domain constants
- */
+import { Resource } from '@internal/domain/resources';
 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);
@@ -18,102 +12,60 @@ 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];
@@ -122,24 +74,15 @@ 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;
@@ -149,17 +92,11 @@ 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;
@@ -169,53 +106,29 @@ 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;
@@ -231,53 +144,30 @@ 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;
     debug?: boolean;
 }
-//# sourceMappingURL=type.d.ts.map

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

@@ -1,70 +1,22 @@
 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;
-//# sourceMappingURL=baseof.d.ts.map

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

@@ -5,41 +5,12 @@ 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;
-//# sourceMappingURL=info.d.ts.map

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

@@ -1,130 +1,38 @@
 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 {};
-//# sourceMappingURL=namespace.d.ts.map