@mdfriday/foundry 25.11.12 → 25.11.13

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

@@ -1,211 +1,50 @@
-/**
- * Template functions registry
- * Centralized management of template functions following DDD principles
- * TypeScript equivalent of Go's valueobject/nsreg.go
- */
 import { CustomizedFunctions, TemplateFuncMap } from '../type';
 import { TemplateEngine } from '../entity/template';
-/**
- * Template functions registry interface
- * Domain service for managing template function registration
- */
 export interface TemplateRegistry {
     registerCoreFunctions(funcMap: TemplateFuncMap): void;
     registerExtendedFunctions(funcMap: TemplateFuncMap, services: CustomizedFunctions): void;
     registerAllFunctions(funcMap: TemplateFuncMap, services?: CustomizedFunctions): void;
 }
-/**
- * Template functions registry implementation
- * Following DDD principles - encapsulates template function management logic
- */
 export declare class DefaultTemplateRegistry implements TemplateRegistry {
-    /**
-     * Register core template functions that don't require external services
-     * Equivalent to Go's RegisterNamespaces()
-     */
     registerCoreFunctions(funcMap: TemplateFuncMap): void;
-    /**
-     * Register cryptographic hash functions
-     * Equivalent to Go's crypto packages
-     */
     private registerCryptoFunctions;
-    /**
-     * Register extended template functions that require external services
-     * Equivalent to Go's RegisterExtendedNamespaces()
-     */
     registerExtendedFunctions(funcMap: TemplateFuncMap, services: CustomizedFunctions): void;
-    /**
-     * Register all available functions with services
-     * This is the main entry point for function registration
-     */
     registerAllFunctions(funcMap: TemplateFuncMap, services?: CustomizedFunctions): void;
-    /**
-     * Register functions that depend on TemplateEngine
-     * These functions are registered with placeholder implementations initially
-     */
     private registerEngineDependentFunctions;
-    /**
-     * Register URL template functions using URLService
-     * Equivalent to Go's registerUrls()
-     */
     private registerURLFunctions;
-    /**
-     * Register site template functions using SiteService
-     * Equivalent to Go's registerSite()
-     */
     private registerSiteFunctions;
     private registerResourcesFunctions;
-    /**
-     * Register Hugo template functions using HugoInfoService
-     * Equivalent to Go's registerHugo()
-     */
     private registerHugoFunctions;
-    /**
-     * Register language template functions using LanguageService
-     * Equivalent to Go's registerLang()
-     */
     private registerLanguageFunctions;
-    /**
-     * Register string manipulation functions
-     * Equivalent to Go's registerStrings()
-     */
     private registerStringFunctions;
-    /**
-     * HTML escape utility function
-     */
     private escapeHTML;
-    /**
-     * Truncate plain text, breaking at word boundaries when possible
-     */
     private truncateText;
-    /**
-     * Truncate HTML text while preserving tag structure
-     */
     private truncateHTML;
-    /**
-     * Register math functions
-     * Equivalent to Go's registerMath()
-     */
     private registerMathFunctions;
-    /**
-     * Register time/date functions
-     * Equivalent to Go's registerTime()
-     */
     private registerTimeFunctions;
-    /**
-     * Register collection functions
-     * Equivalent to Go's registerCollections()
-     */
     private registerCollectionFunctions;
-    /**
-     * Core indexing implementation following Go's doIndex logic
-     * Supports nested indexing of arrays, objects, and maps
-     */
     private doIndex;
-    /**
-     * Index into an array or slice
-     */
     private indexArray;
-    /**
-     * Index into a string (treating it like a character array)
-     */
     private indexString;
-    /**
-     * Index into an object/map (including TaxonomyList)
-     */
     private indexObject;
-    /**
-     * Convert value to integer, similar to Go's index conversion
-     */
     private toInteger;
-    /**
-     * Check condition between two values using the specified operator
-     * Following golang's checkCondition logic
-     */
     private checkCondition;
-    /**
-     * Normalize values for comparison
-     */
     private normalizeForComparison;
-    /**
-     * Register safe functions
-     * Equivalent to Go's registerSafe()
-     */
     private registerSafeFunctions;
-    /**
-     * Register format functions (fmt namespace)
-     * Equivalent to Go's registerFmt()
-     */
     private registerFmtFunctions;
-    /**
-     * Register reflect functions
-     * Equivalent to Go's registerReflect()
-     */
     private registerReflectFunctions;
-    /**
-     * Register path manipulation functions
-     * Equivalent to Go's path package functions
-     */
     private registerPathFunctions;
-    /**
-     * Register transform functions (unmarshal, etc.)
-     * Equivalent to Go's transform package functions
-     */
     private registerTransformFunctions;
-    /**
-     * Strip HTML tags from a string
-     * Equivalent to Go's helpers.StripHTML function
-     * Preserves line breaks from block elements and normalizes whitespace
-     */
     private stripHTML;
-    /**
-     * Unmarshal content from string based on format
-     * Supports JSON, YAML, TOML, CSV formats
-     */
     private unmarshalContent;
-    /**
-     * Detect format from content
-     */
     private detectFormat;
-    /**
-     * Parse YAML content (basic implementation)
-     * For a full implementation, you'd want to use a proper YAML library
-     */
     private parseYAML;
-    /**
-     * Parse TOML content (basic implementation)
-     * For a full implementation, you'd want to use a proper TOML library
-     */
     private parseTOML;
-    /**
-     * Parse CSV content (basic implementation)
-     */
     private parseCSV;
-    /**
-     * Parse a single CSV line, handling quoted values
-     */
     private parseCSVLine;
-    /**
-     * Get nested value from object using dot notation path
-     * Following golang's path resolution logic
-     */
     private getNestedValue;
 }
-/**
- * Create default template registry
- */
 export declare function newTemplateRegistry(): TemplateRegistry;
-/**
- * Convenience function to create and register core functions only
- */
 export declare function createCoreFuncMap(): TemplateFuncMap;
-/**
- * Convenience function to create and register all functions with services
- */
 export declare function createStandardFuncMap(services: CustomizedFunctions): TemplateFuncMap;
-/**
- * Update all engine-dependent functions with the template engine instance
- * This should be called after the template engine is created
- */
 export declare function updateEngineDependentFunctions(engine: TemplateEngine): void;
-//# sourceMappingURL=registry.d.ts.map

package/dist/pkg/cahce/cache.d.ts

@@ -1,91 +1,34 @@
-/**
- * 并发安全的缓存实现，专为站点构建场景优化
- * 支持多个页面并发访问时避免重复创建相同对象
- */
 export declare class ConcurrentCache<K, V> {
     private cache;
     private pendingPromises;
     private deletedKeys;
     constructor();
-    /**
-     * Get value from cache
-     */
     get(key: K): V | undefined;
-    /**
-     * Set value in cache
-     */
     set(key: K, value: V): void;
-    /**
-     * Check if key exists in cache
-     */
     has(key: K): boolean;
-    /**
-     * Check if key is currently being created
-     */
     isPending(key: K): boolean;
-    /**
-     * Remove key from cache
-     */
     delete(key: K): boolean;
-    /**
-     * Clear all cache entries and pending promises
-     */
     clear(): void;
-    /**
-     * Get cache size
-     */
     size(): number;
-    /**
-     * Get pending promises count
-     */
     pendingCount(): number;
-    /**
-     * 并发安全的获取或创建值
-     * 如果多个并发请求访问同一个key，只会创建一次
-     */
     getOrCreate(key: K, create: (key: K) => Promise<V>): Promise<V>;
-    /**
-     * 创建并缓存值
-     */
     private createAndCache;
-    /**
-     * 执行创建函数，包装错误处理
-     */
     private executeCreate;
-    /**
-     * 获取缓存统计信息
-     */
     getStats(): CacheStats;
-    /**
-     * 批量预加载数据
-     */
     preload(entries: Array<{
         key: K;
         create: (key: K) => Promise<V>;
     }>): Promise<void>;
 }
-/**
- * 缓存统计信息
- */
 export interface CacheStats {
     size: number;
     pendingCount: number;
     keys: unknown[];
     pendingKeys: unknown[];
 }
-/**
- * DynaCache interface implementation
- */
 export interface DynaCache<K, V> {
     getOrCreate(key: K, create: (key: K) => Promise<V>): Promise<V>;
     getStats?(): CacheStats;
 }
-/**
- * 创建一个新的并发缓存实例
- */
 export declare function createCache<K, V>(): ConcurrentCache<K, V>;
-/**
- * 全局缓存实例，用于站点构建时的数据共享
- */
 export declare const globalBuildCache: ConcurrentCache<string, any>;
-//# sourceMappingURL=cache.d.ts.map

package/dist/pkg/cast/cast.d.ts

@@ -3,4 +3,3 @@ export declare class Cast {
     static toInt(v: any): number;
     static toTime(v: any): Date;
 }
-//# sourceMappingURL=cast.d.ts.map

package/dist/pkg/cast/index.d.ts

@@ -1,2 +1 @@
 export * from './cast';
-//# sourceMappingURL=index.d.ts.map

package/dist/pkg/doctree/dimensions.d.ts

@@ -16,4 +16,3 @@ export declare const dimensionFlag: {
     set: (flag: DimensionFlag, other: DimensionFlag) => DimensionFlag;
     index: (flag: DimensionFlag) => number;
 };
-//# sourceMappingURL=dimensions.d.ts.map

package/dist/pkg/doctree/index.d.ts

@@ -3,4 +3,3 @@ export { LockType, Event, WalkContext, MutableTree, WalkableTree, WalkableTrees,
 export { Tree, SimpleTree, newSimpleTree } from './simpletree';
 export { TreeShiftTree } from './treeshifttree';
 export { Config, Shifter, NodeShiftTree, NodeShiftTreeWalker, NodeShiftTreeWalkerConfig, WalkFunc, WalkConfig } from './nodeshifttree';
-//# sourceMappingURL=index.d.ts.map

package/dist/pkg/doctree/nodeshifttree.d.ts

@@ -80,4 +80,3 @@ export interface WalkConfig<T> {
     noShift?: boolean;
     exact?: boolean;
 }
-//# sourceMappingURL=nodeshifttree.d.ts.map

package/dist/pkg/doctree/simpletree.d.ts

@@ -17,4 +17,3 @@ export declare class SimpleTree<T> implements Tree<T> {
     insert(s: string, v: T): T;
     walkPrefix(lockType: LockType, s: string, f: (s: string, v: T) => [boolean, Error | null]): Promise<Error | null>;
 }
-//# sourceMappingURL=simpletree.d.ts.map

package/dist/pkg/doctree/support.d.ts

@@ -58,4 +58,3 @@ export declare class MutableTrees implements MutableTree {
 export declare function validateKey(key: string): Error | null;
 export declare function cleanKey(key: string): string;
 export declare function mustValidateKey(key: string): string;
-//# sourceMappingURL=support.d.ts.map

package/dist/pkg/doctree/treeshifttree.d.ts

@@ -15,4 +15,3 @@ export declare class TreeShiftTree<T> implements Tree<T> {
     deletePrefix(prefix: string): Promise<number>;
     lock(writable: boolean): () => void;
 }
-//# sourceMappingURL=treeshifttree.d.ts.map

package/dist/pkg/lang/data.d.ts

@@ -1,28 +1,6 @@
-/**
- * Language Data
- * Contains mapping of language codes to language names with direction support
- */
 import { LanguageInfo } from './types';
-/**
- * LTR (Left-to-Right) Languages
- * Currently supported languages that read from left to right
- */
 export declare const LTR_LANGUAGES: LanguageInfo[];
-/**
- * RTL (Right-to-Left) Languages
- * Languages that read from right to left (to be supported in the future)
- */
 export declare const RTL_LANGUAGES: LanguageInfo[];
-/**
- * All supported languages (LTR + RTL)
- */
 export declare const ALL_LANGUAGES: LanguageInfo[];
-/**
- * Create a map of language code to language info
- */
 export declare const LANGUAGE_MAP: Record<string, LanguageInfo>;
-/**
- * Create a simple code-to-name mapping
- */
 export declare const CODE_NAME_MAP: Record<string, string>;
-//# sourceMappingURL=data.d.ts.map

package/dist/pkg/lang/index.d.ts

@@ -1,65 +1,18 @@
-/**
- * Language Package
- * Basic language code to name mapping service with LTR/RTL support
- */
 export type { LanguageDirection, LanguageInfo, LanguageService } from './types';
 export { LTR_LANGUAGES, RTL_LANGUAGES, ALL_LANGUAGES, LANGUAGE_MAP, CODE_NAME_MAP } from './data';
 export { DefaultLanguageService, getLanguageService, createLanguageService } from './service';
-/**
- * Default language service instance
- */
 export declare const lang: import("./types").LanguageService;
-/**
- * Convenience functions using the default service
- */
 export declare const languages: {
-    /**
-     * Get all language codes
-     */
     getAllCodes: () => string[];
-    /**
-     * Get all language names
-     */
     getAllNames: () => string[];
-    /**
-     * Get language codes by direction
-     */
     getCodesByDirection: (direction: "ltr" | "rtl") => string[];
-    /**
-     * Get language names by direction
-     */
     getNamesByDirection: (direction: "ltr" | "rtl") => string[];
-    /**
-     * Get code-name mapping
-     */
     getCodeNameMap: () => Record<string, string>;
-    /**
-     * Get code-name mapping by direction
-     */
     getCodeNameMapByDirection: (direction: "ltr" | "rtl") => Record<string, string>;
-    /**
-     * Get language name by code
-     */
     getNameByCode: (code: string) => string | undefined;
-    /**
-     * Get language info by code
-     */
     getLanguageInfo: (code: string) => import("./types").LanguageInfo | undefined;
-    /**
-     * Check if language is supported
-     */
     isSupported: (code: string) => boolean;
-    /**
-     * Get language direction
-     */
     getDirection: (code: string) => import("./types").LanguageDirection | undefined;
-    /**
-     * Check if language is LTR
-     */
     isLTR: (code: string) => boolean;
-    /**
-     * Check if language is RTL
-     */
     isRTL: (code: string) => boolean;
 };
-//# sourceMappingURL=index.d.ts.map

package/dist/pkg/lang/service.d.ts

@@ -1,67 +1,17 @@
-/**
- * Language Service Implementation
- * Provides methods to query language information
- */
 import { LanguageInfo, LanguageDirection, LanguageService } from './types';
-/**
- * Default implementation of LanguageService
- */
 export declare class DefaultLanguageService implements LanguageService {
-    /**
-     * Get all supported language codes
-     */
     getAllCodes(): string[];
-    /**
-     * Get all supported language names
-     */
     getAllNames(): string[];
-    /**
-     * Get language codes for a specific direction
-     */
     getCodesByDirection(direction: LanguageDirection): string[];
-    /**
-     * Get language names for a specific direction
-     */
     getNamesByDirection(direction: LanguageDirection): string[];
-    /**
-     * Get code-to-name mapping for all languages
-     */
     getCodeNameMap(): Record<string, string>;
-    /**
-     * Get code-to-name mapping for a specific direction
-     */
     getCodeNameMapByDirection(direction: LanguageDirection): Record<string, string>;
-    /**
-     * Get language name by code
-     */
     getNameByCode(code: string): string | undefined;
-    /**
-     * Get complete language information by code
-     */
     getLanguageInfo(code: string): LanguageInfo | undefined;
-    /**
-     * Check if a language code is supported
-     */
     isSupported(code: string): boolean;
-    /**
-     * Get language direction by code
-     */
     getDirection(code: string): LanguageDirection | undefined;
-    /**
-     * Check if a language is LTR (Left-to-Right)
-     */
     isLTR(code: string): boolean;
-    /**
-     * Check if a language is RTL (Right-to-Left)
-     */
     isRTL(code: string): boolean;
 }
-/**
- * Get the singleton language service instance
- */
 export declare function getLanguageService(): LanguageService;
-/**
- * Create a new language service instance
- */
 export declare function createLanguageService(): LanguageService;
-//# sourceMappingURL=service.d.ts.map

package/dist/pkg/lang/types.d.ts

@@ -1,51 +1,21 @@
-/**
- * Language Package Types
- * Basic language code to name mapping with LTR/RTL support
- */
-/**
- * Language direction type
- */
 export type LanguageDirection = 'ltr' | 'rtl';
-/**
- * Language information interface
- */
 export interface LanguageInfo {
-    /** Language code (ISO 639-1) */
     code: string;
-    /** Native language name */
     name: string;
-    /** Language direction */
     direction: LanguageDirection;
-    /** English name (optional, for reference) */
     englishName?: string;
 }
-/**
- * Language service interface
- */
 export interface LanguageService {
-    /** Get all language codes */
     getAllCodes(): string[];
-    /** Get all language names */
     getAllNames(): string[];
-    /** Get all language codes for a specific direction */
     getCodesByDirection(direction: LanguageDirection): string[];
-    /** Get all language names for a specific direction */
     getNamesByDirection(direction: LanguageDirection): string[];
-    /** Get code-name mapping for all languages */
     getCodeNameMap(): Record<string, string>;
-    /** Get code-name mapping for a specific direction */
     getCodeNameMapByDirection(direction: LanguageDirection): Record<string, string>;
-    /** Get language name by code */
     getNameByCode(code: string): string | undefined;
-    /** Get language information by code */
     getLanguageInfo(code: string): LanguageInfo | undefined;
-    /** Check if a language code is supported */
     isSupported(code: string): boolean;
-    /** Get language direction by code */
     getDirection(code: string): LanguageDirection | undefined;
-    /** Check if a language is LTR */
     isLTR(code: string): boolean;
-    /** Check if a language is RTL */
     isRTL(code: string): boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/pkg/log/http.d.ts

@@ -2,25 +2,8 @@ import { Logger } from './logger';
 export declare class HTTPErrorLogger {
     private logger;
     constructor(logger: Logger);
-    /**
-     * Process HTTP error messages and log them appropriately
-     * Similar to Go's httpErrorLog.Write method
-     */
     write(message: string): void;
-    /**
-     * Create a write stream compatible function for HTTP servers
-     * This can be used with HTTP server error handlers
-     */
     getWriteFunction(): (message: string) => void;
-    /**
-     * Create a Node.js compatible writable stream interface
-     * This allows the logger to be used where a writable stream is expected
-     */
     createWritableStream(): NodeJS.WritableStream;
 }
-/**
- * Create a new HTTP error logger
- * Similar to Go's NewHTTPErrorLog function
- */
 export declare function NewHTTPErrorLogger(logger: Logger): HTTPErrorLogger;
-//# sourceMappingURL=http.d.ts.map

package/dist/pkg/log/index.d.ts

@@ -14,4 +14,3 @@ export declare const warnf: (template: string, ...args: any[]) => void;
 export declare const errorf: (template: string, ...args: any[]) => void;
 export declare const fatalf: (template: string, ...args: any[]) => void;
 export declare const with_: (fields: Record<string, any>) => import("./logger").Logger;
-//# sourceMappingURL=index.d.ts.map

package/dist/pkg/log/logger.d.ts

@@ -22,4 +22,3 @@ export declare class Logger implements ILogger {
 }
 export declare function New(level?: LogLevel): Logger;
 export declare function NewWithConfig(config: LoggerConfig): Logger;
-//# sourceMappingURL=logger.d.ts.map

package/dist/pkg/log/manager.d.ts

@@ -1,84 +1,26 @@
 import { Logger } from './logger';
 import { LogLevel, LoggerConfig } from './types';
-/**
- * Global Logger Manager
- * Manages logger instances across different domains with unified configuration
- */
 export declare class LoggerManager {
     private static instance;
     private globalConfig;
     private loggers;
     private constructor();
-    /**
-     * Get the singleton instance of LoggerManager
-     */
     static getInstance(): LoggerManager;
-    /**
-     * Set global logger configuration
-     * This affects all new logger instances created after this call
-     */
     setGlobalConfig(config: Partial<LoggerConfig>): void;
-    /**
-     * Get global logger configuration
-     */
     getGlobalConfig(): LoggerConfig;
-    /**
-     * Get logger for a specific domain/component
-     * Creates and caches logger instances per domain
-     */
     getLogger(domain: string, additionalFields?: Record<string, any>): Logger;
-    /**
-     * Get logger for a specific domain with component information
-     */
     getComponentLogger(domain: string, component: string, additionalFields?: Record<string, any>): Logger;
-    /**
-     * Clear all cached loggers
-     * Useful when you want to force recreation with new configuration
-     */
     clearCache(): void;
-    /**
-     * Get all cached logger domains
-     */
     getCachedDomains(): string[];
-    /**
-     * Set log level for all existing and future loggers
-     */
     setLogLevel(level: LogLevel): void;
-    /**
-     * Enable or disable caller information for all loggers
-     */
     setCallerEnabled(enabled: boolean): void;
-    /**
-     * Set JSON format for all loggers
-     */
     setJsonFormat(enabled: boolean): void;
 }
 declare const globalLoggerManager: LoggerManager;
-/**
- * Initialize global logger configuration
- * Call this once at application startup
- */
 export declare function initLogger(config: Partial<LoggerConfig>): void;
-/**
- * Get logger for a domain
- * Convenience function to avoid accessing LoggerManager directly
- */
 export declare function getDomainLogger(domain: string, additionalFields?: Record<string, any>): Logger;
-/**
- * Get logger for a specific component within a domain
- */
 export declare function getComponentLogger(domain: string, component: string, additionalFields?: Record<string, any>): Logger;
-/**
- * Set global log level
- */
 export declare function setGlobalLogLevel(level: LogLevel): void;
-/**
- * Enable or disable caller information globally
- */
 export declare function setGlobalCallerEnabled(enabled: boolean): void;
-/**
- * Set JSON format globally
- */
 export declare function setGlobalJsonFormat(enabled: boolean): void;
 export { globalLoggerManager };
-//# sourceMappingURL=manager.d.ts.map