@mdfriday/foundry
Version:
The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.
281 lines • 8.71 kB
TypeScript
import { Template } from '@mdfriday/text-template';
import { FileMetaInfo, WalkCallback, WalkwayConfig } from '../fs/type';
import { Resource } from '../../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);
}
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];
getFunc(name: string): any;
findTemplate(name: string, templateNS: RegularTemplateNamespaceInterface): [Template | null, boolean, Error | null];
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;
getNeedsBaseOf(key: string): TemplateInfo | null;
addBaseOf(key: string, info: TemplateInfo): void;
addNeedsBaseOf(key: string, info: TemplateInfo): void;
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;
withFuncMap(funcMap: TemplateFuncMap): TemplateBuilder;
buildLookup(): TemplateBuilder;
buildParser(): 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;
params(): Record<string, any>;
menus(): Record<string, any[]>;
isMultiLanguage(): boolean;
}
export interface ResourcesService {
Get(filename: string): Promise<Resource | null>;
Minify(resource: Resource): Promise<Resource>;
Fingerprint(resource: Resource): Promise<Resource>;
ExecuteAsTemplate(targetPath: string, data: any, resource: Resource): Promise<Resource>;
}
/**
* 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