@mdfriday/foundry 25.11.12 → 25.11.13

package/dist/internal/domain/site/valueobject/organization.d.ts

@@ -1,5 +1,5 @@
-import { Organization as ContentOrganization } from '../../../domain/content';
-import { SocialLink } from "../../../domain/site/valueobject/author";
+import { Organization as ContentOrganization } from '@internal/domain/content';
+import { SocialLink } from "@internal/domain/site/valueobject/author";
 export declare class Organization {
     private readonly _name;
     private readonly _description;
@@ -10,57 +10,19 @@ export declare class Organization {
     private readonly _vision;
     private _homeOrganization;
     constructor();
-    /**
-     * Get organization name
-     */
     name(): string;
-    /**
-     * Get organization description
-     */
     description(): string;
-    /**
-     * Get organization website
-     */
     website(): string;
-    /**
-     * Set the home organization from content
-     */
     organization(organization: ContentOrganization | undefined): Organization;
-    /**
-     * Get organization name with fallback to home organization
-     */
     get Name(): string;
-    /**
-     * Get organization description with fallback to home organization
-     */
     get Description(): string;
-    /**
-     * Get organization website with fallback to home organization
-     */
     get Website(): string;
-    /**
-     * Get organization vision from home organization
-     */
     get Vision(): string;
-    /**
-     * Get organization logo from home organization
-     */
     get Logo(): string;
-    /**
-     * Get organization contact from home organization
-     */
     get Address(): string;
     get Email(): string;
-    /**
-     * Get organization social from home organization
-     */
-    get Social(): import("../../../domain/content").Social | undefined;
+    get Social(): import("@internal/domain/content").Social | undefined;
     SocialById(id: string): string;
     get Socials(): SocialLink[];
 }
-/**
- * Factory function to create new Organization
- * TypeScript equivalent of NewOrganization function from Go
- */
 export declare function newOrganization(): Organization;
-//# sourceMappingURL=organization.d.ts.map

package/dist/internal/domain/site/valueobject/version.d.ts

@@ -1,22 +1,7 @@
-/**
- * Compiler - TypeScript equivalent of Go's Compiler valueobject
- * Represents compiler version information
- */
 export declare class Compiler {
     private readonly ver;
     constructor(version: string);
-    /**
-     * Get compiler version
-     */
     version(): string;
-    /**
-     * Get environment (simplified implementation)
-     */
     environment(): string;
 }
-/**
- * Factory function to create new Compiler
- * TypeScript equivalent of NewVersion function from Go
- */
 export declare function newVersion(version: string): Compiler;
-//# sourceMappingURL=version.d.ts.map

package/dist/internal/domain/template/entity/executor.d.ts

@@ -1,28 +1,12 @@
 import { Template } from '@mdfriday/text-template';
 import { TemplateExecutor, TemplateError } from '../type';
-/**
- * Executor entity for executing templates
- * TypeScript version of Go's Executor struct
- */
 export declare class Executor implements TemplateExecutor {
-    /**
-     * Execute template with data
-     */
     execute(tmpl: Template, data: any): Promise<string>;
-    /**
-     * Execute template with timeout
-     */
     executeWithTimeout(tmpl: Template, data: any, timeoutMs: number): Promise<string>;
-    /**
-     * Execute template safely with error handling
-     */
     executeSafely(tmpl: Template, data: any): Promise<{
         result: string | null;
         error: TemplateError | null;
     }>;
-    /**
-     * Execute multiple templates in batch
-     */
     executeBatch(templates: Array<{
         name: string;
         template: Template;
@@ -32,17 +16,10 @@ export declare class Executor implements TemplateExecutor {
         result: string | null;
         error: TemplateError | null;
     }>>;
-    /**
-     * Execute template with context and cancellation support
-     */
     executeWithContext(tmpl: Template, data: any, context: {
         signal?: AbortSignal;
         timeout?: number;
         metadata?: Record<string, any>;
     }): Promise<string>;
 }
-/**
- * Create a new Executor instance
- */
 export declare function newExecutor(): Executor;
-//# sourceMappingURL=executor.d.ts.map

package/dist/internal/domain/template/entity/lookup.d.ts

@@ -1,85 +1,29 @@
 import { Template } from '@mdfriday/text-template';
 import { TemplateLookup, TemplateNamespace, TemplateInfo, TemplateLookupFunc, TemplateFuncMap, RegularTemplateNamespaceInterface, PartialTemplateNamespaceInterface, ShortcodeTemplateNamespaceInterface } from '../type';
 import { BaseOf } from '../vo/baseof';
-/**
- * Lookup entity for finding templates and managing dependencies
- * TypeScript version of Go's Lookup struct
- */
 export declare class Lookup implements TemplateLookup {
     private baseOf;
     private funcsv;
     constructor(baseOf?: BaseOf, funcMap?: TemplateFuncMap);
-    /**
-     * Find template with no dependencies (legacy method)
-     */
     findNoDependence(name: string, ns: TemplateNamespace): [Template | null, boolean, Error | null];
-    /**
-     * Find regular template with baseof dependency support
-     */
     findTemplate(name: string, templateNS: RegularTemplateNamespaceInterface): [Template | null, boolean, Error | null];
-    /**
-     * Find partial template (simple lookup, no dependencies)
-     */
     findPartial(name: string, partialNS: PartialTemplateNamespaceInterface): [Template | null, boolean, Error | null];
-    /**
-     * Find shortcode template (simplest lookup)
-     */
     findShortcode(name: string, shortcodeNS: ShortcodeTemplateNamespaceInterface): [Template | null, boolean, Error | null];
-    /**
-     * Find dependent template information
-     */
     findDependentInfo(name: string): [TemplateInfo | null, TemplateInfo | null, boolean];
-    /**
-     * Get function by name
-     */
     getFunc(name: string): any;
-    /**
-     * Set function
-     */
     setFunc(name: string, fn: any): void;
-    /**
-     * Set function map
-     */
     setFuncMap(funcMap: TemplateFuncMap): void;
-    /**
-     * Get function map
-     */
     getFuncMap(): TemplateFuncMap;
-    /**
-     * Create template lookup function for namespace
-     */
     newTemplateLookup(ns: TemplateNamespace): TemplateLookupFunc;
-    /**
-     * Get base template manager
-     */
     getBaseOf(): BaseOf;
-    /**
-     * Set base template manager
-     */
     setBaseOf(baseOf: BaseOf): void;
-    /**
-     * Check if template has dependencies
-     */
     hasDependencies(name: string): boolean;
-    /**
-     * Get all available functions
-     */
     getAllFunctions(): string[];
-    /**
-     * Clear all functions
-     */
     clearFunctions(): void;
-    /**
-     * Get lookup statistics
-     */
     getStats(): {
         functionCount: number;
         baseTemplateCount: number;
         dependentTemplateCount: number;
     };
 }
-/**
- * Create a new Lookup instance
- */
 export declare function newLookup(baseOf?: BaseOf, funcMap?: TemplateFuncMap): Lookup;
-//# sourceMappingURL=lookup.d.ts.map

package/dist/internal/domain/template/entity/parser.d.ts

@@ -1,9 +1,5 @@
 import { Template } from '@mdfriday/text-template';
 import { TemplateParser, TemplateState, TemplateInfo, TemplateLookupFunc, TemplateFuncMap } from '../type';
-/**
- * Parser entity for parsing templates
- * TypeScript version of Go's Parser struct
- */
 export declare class Parser implements TemplateParser {
     private prototypeText;
     private prototypeTextClone?;
@@ -11,53 +7,16 @@ export declare class Parser implements TemplateParser {
     private funcMap;
     private parseOverlapCache;
     constructor(funcMap?: TemplateFuncMap);
-    /**
-     * Mark parser as ready and create clone
-     */
     markReady(): Promise<void>;
-    /**
-     * Parse template info into template state
-     */
     parse(info: TemplateInfo): Promise<TemplateState>;
-    /**
-     * Parse template with lock (for thread safety)
-     */
     parseWithLock(name: string, tpl: string): Promise<Template>;
-    /**
-     * Parse template with overlay and base template
-     */
     parseOverlap(overlay: TemplateInfo, base: TemplateInfo, lookup: TemplateLookupFunc): Promise<[TemplateState | null, boolean, Error | null]>;
-    /**
-     * Apply base template to overlay
-     */
     private applyBaseTemplate;
-    /**
-     * Get template dependencies using syntax tree traversal (与Go版本一致的遍历方法)
-     */
     private getDependencies;
-    /**
-     * Set function map
-     */
     setFuncMap(funcMap: TemplateFuncMap): void;
-    /**
-     * Get function map
-     */
     getFuncMap(): TemplateFuncMap;
-    /**
-     * Parse multiple templates
-     */
     parseMultiple(templates: TemplateInfo[]): Promise<TemplateState[]>;
-    /**
-     * Clear the parse overlap cache
-     */
     clearCache(): void;
-    /**
-     * Get cache statistics
-     */
-    getCacheStats(): import("../../../../pkg/cahce/cache").CacheStats;
+    getCacheStats(): import("@pkg/cahce/cache").CacheStats;
 }
-/**
- * Create a new Parser instance
- */
 export declare function newParser(funcMap?: TemplateFuncMap): Parser;
-//# sourceMappingURL=parser.d.ts.map

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

@@ -4,10 +4,6 @@ import { Executor } from './executor';
 import { Parser } from './parser';
 import { Lookup } from './lookup';
 import { RegularTemplateNamespace, PartialTemplateNamespace, ShortcodeTemplateNamespace } from '../vo/namespace';
-/**
- * Template entity - main template engine with separated template management
- * TypeScript version of Go's Template struct
- */
 export declare class TemplateEngine implements ITemplateEngine {
     private executor;
     private lookup;
@@ -17,121 +13,37 @@ export declare class TemplateEngine implements ITemplateEngine {
     private shortcodeNamespace;
     private fs;
     constructor(executor: Executor, lookup: Lookup, parser: Parser, templateNamespace: RegularTemplateNamespace, partialNamespace: PartialTemplateNamespace, shortcodeNamespace: ShortcodeTemplateNamespace, fs: TemplateFs);
-    /**
-     * Mark template engine as ready
-     */
     markReady(): Promise<void>;
-    /**
-     * Get regular template by name with baseof dependency support
-     */
     getTemplate(name: string): Promise<[Template | null, boolean, Error | null]>;
-    /**
-     * Get partial template by name (simple lookup)
-     */
     getPartial(name: string): Promise<[Template | null, boolean, Error | null]>;
-    /**
-     * Get shortcode template by name
-     */
     getShortcode(name: string): Promise<[Template | null, boolean, Error | null]>;
-    /**
-     * Get template by name (unified method that routes to appropriate namespace)
-     */
     get(name: string): Promise<[Template | null, boolean, Error | null]>;
-    /**
-     * Find first available template from a list of template names by priority
-     * Returns the first template found, its name, whether it was found, and any error
-     */
     findFirst(names: string[]): Promise<[Template | null, string | null, boolean, Error | null]>;
-    /**
-     * Check if a shortcode exists
-     * @param name - The shortcode name
-     * @returns true if the shortcode exists, false otherwise
-     */
     hasShortcode(name: string): boolean;
-    /**
-     * Get all available shortcode names
-     * @returns Array of shortcode names
-     */
     getShortcodeNames(): string[];
-    /**
-     * Get shortcode count
-     * @returns Number of loaded shortcodes
-     */
     getShortcodeCount(): number;
-    /**
-     * Load templates from file system (unified for all template types)
-     */
     loadTemplates(): Promise<void>;
-    /**
-     * Add template from file info (routes to appropriate namespace)
-     */
     private addTemplateFileInfo;
-    /**
-     * Add template to appropriate namespace based on type
-     */
     private addTemplate;
-    /**
-     * Execute template with data
-     */
     execute(templateName: string, data: any): Promise<string>;
     executeRaw(templateName: string, rawContent: string, data: any): Promise<string>;
-    /**
-     * Execute shortcode template with data
-     */
     executeShortcode(shortcodeName: string, data: any): Promise<string>;
-    /**
-     * Execute template safely
-     */
     executeSafely(templateName: string, data: any): Promise<{
         result: string | null;
         error: TemplateError | null;
     }>;
-    /**
-     * Execute shortcode safely
-     */
     executeShortcodeSafely(shortcodeName: string, data: any): Promise<{
         result: string | null;
         error: TemplateError | null;
     }>;
-    /**
-     * Check if template exists
-     */
     hasTemplate(name: string): Promise<boolean>;
-    /**
-     * Get all template names
-     */
     getTemplateNames(): string[];
-    /**
-     * Get all partial template names
-     */
     getPartialTemplateNames(): string[];
-    /**
-     * Get all template names from all namespaces
-     */
     getAllTemplateNames(): string[];
-    /**
-     * Get partial namespace (for internal use by partial function)
-     */
     getPartialNamespace(): PartialTemplateNamespace;
-    /**
-     * Get shortcode namespace (for internal use)
-     */
     getShortcodeNamespace(): ShortcodeTemplateNamespace;
-    /**
-     * Get template namespace (for internal use)
-     */
     getTemplateNamespace(): RegularTemplateNamespace;
-    /**
-     * Clear all templates including shortcodes
-     */
     clear(): void;
-    /**
-     * Get template by pattern
-     */
     getTemplatesByPattern(pattern: RegExp): string[];
 }
-/**
- * Create a new TemplateEngine instance
- */
 export declare function newTemplateEngine(executor: Executor, lookup: Lookup, parser: Parser, templateNamespace: RegularTemplateNamespace, partialNamespace: PartialTemplateNamespace, shortcodeNamespace: ShortcodeTemplateNamespace, fs: TemplateFs): TemplateEngine;
-//# sourceMappingURL=template.d.ts.map

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

@@ -1,30 +1,11 @@
 import { TemplateFactory, TemplateFs, TemplateFactoryConfig, TemplateFuncMap, CustomizedFunctions } from '../type';
 import { TemplateEngine } from '../entity/template';
 import { RegularTemplateNamespace, PartialTemplateNamespace, ShortcodeTemplateNamespace } from '../vo/namespace';
-/**
- * Template factory implementation
- * TypeScript version of Go's template factory
- * Following Go's factory pattern with service injection
- */
 export declare class Factory implements TemplateFactory {
-    /**
-     * Create template engine with file system (core functions only)
-     */
     create(fs: TemplateFs): Promise<TemplateEngine>;
-    /**
-     * Create template engine with configuration
-     */
     createWithConfig(fs: TemplateFs, config: TemplateFactoryConfig): Promise<TemplateEngine>;
-    /**
-     * Create template engine with services
-     * TypeScript equivalent of Go's New(fs, cfs) function
-     */
     createWithServices(fs: TemplateFs, services: CustomizedFunctions): Promise<TemplateEngine>;
 }
-/**
- * Builder for constructing template engine with dependencies
- * TypeScript equivalent of Go's builder pattern
- */
 export declare class Builder {
     private funcMap;
     private services?;
@@ -35,59 +16,16 @@ export declare class Builder {
     private lookup?;
     private parser?;
     private executor?;
-    /**
-     * Set file system
-     */
     withFs(fs: TemplateFs): Builder;
-    /**
-     * Set namespaces
-     */
     withNamespaces(templateNamespace: RegularTemplateNamespace, partialNamespace: PartialTemplateNamespace, shortcodeNamespace: ShortcodeTemplateNamespace): Builder;
-    /**
-     * Set function map directly
-     */
     withFuncMap(funcMap: TemplateFuncMap): Builder;
-    /**
-     * Set services (will generate function map from services)
-     * TypeScript equivalent of Go's withCfs()
-     */
     withServices(services: CustomizedFunctions): Builder;
-    /**
-     * Build lookup component
-     * TypeScript equivalent of Go's buildLookup()
-     */
     buildLookup(): Builder;
-    /**
-     * Build parser component
-     * TypeScript equivalent of Go's buildParser()
-     */
     buildParser(): Builder;
-    /**
-     * Build executor component
-     * TypeScript equivalent of Go's buildExecutor()
-     */
     buildExecutor(): Builder;
-    /**
-     * Build final template engine
-     * TypeScript equivalent of Go's build()
-     */
     build(): Promise<TemplateEngine>;
 }
-/**
- * Create a new template factory
- */
 export declare function newTemplateFactory(): Factory;
-/**
- * Create a new builder
- */
 export declare function newBuilder(): Builder;
-/**
- * Convenience function to create template engine with defaults
- */
 export declare function createTemplateEngine(fs: TemplateFs, funcMap?: TemplateFuncMap): Promise<TemplateEngine>;
-/**
- * Convenience function to create template engine with services
- * TypeScript equivalent of Go's factory.New()
- */
 export declare function createTemplateEngineWithServices(fs: TemplateFs, services: CustomizedFunctions): Promise<TemplateEngine>;
-//# sourceMappingURL=template.d.ts.map

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

@@ -8,4 +8,3 @@ export { Parser, newParser } from './entity/parser';
 export { Lookup, newLookup } from './entity/lookup';
 export { TemplateEngine, newTemplateEngine } from './entity/template';
 export { Factory, Builder, newTemplateFactory, newBuilder, createTemplateEngine, createTemplateEngineWithServices } from './factory/template';
-//# sourceMappingURL=index.d.ts.map