@mdfriday/foundry 26.4.20 → 26.5.2

package/dist/types/internal/domain/content/entity/content.d.ts

@@ -15,16 +15,52 @@ export declare class Content {
     collectPages(): Promise<void>;
     private process;
     private assemble;
+    /**
+     * GetPageSources - exact replica of Go's GetPageSources method
+     */
     getPageSources(page: Page): Promise<PageSource[]>;
+    /**
+     * GlobalPages - exact replica of Go's GlobalPages method
+     */
     globalPages(langIndex: number): Promise<Pages>;
     globalRegularPages(): Promise<Pages>;
+    /**
+     * WalkPages - exact replica of Go's WalkPages method
+     * TypeScript equivalent of golang/internal/domain/contenthub/entity/walk.go:WalkPages
+     */
     walkPages(langIndex: number, walker: (page: Page) => Promise<void>): Promise<void>;
+    /**
+     * WalkTaxonomies - exact replica of Go's WalkTaxonomies method
+     * TypeScript equivalent of golang/internal/domain/contenthub/entity/walk.go:WalkTaxonomies
+     */
     walkTaxonomies(langIndex: number, walker: WalkTaxonomyFunc): Promise<void>;
+    /**
+     * GetPageFromPath - TypeScript equivalent of Go's PageFinder.GetPageFromPath
+     * This is the core content domain business logic for finding pages by path
+     */
     getPageFromPath(langIndex: number, path: string): Page | null;
     getPageFromFile(langIndex: number, file: FileInfo): Page | null;
     handleChangeFiles(fileMetaInfos: Map<string, FileMetaInfo>): Promise<string[]>;
+    /**
+     * 添加或更新文件到 PageMap，参考 collectDir 中的实现
+     */
     private addOrUpdateFile;
+    /**
+     * Translate a message for a specific language
+     * @param lang Language code
+     * @param translationID Translation identifier
+     * @returns Translated string
+     */
     translate(lang: string, translationID: string): string;
+    /**
+     * Get available translation languages
+     * @returns Array of language codes
+     */
     getAvailableLanguages(): string[];
+    /**
+     * Check if a language has translation support
+     * @param lang Language code
+     * @returns True if language is supported
+     */
     hasLanguageSupport(lang: string): boolean;
 }

package/dist/types/internal/domain/content/entity/page.d.ts

@@ -26,13 +26,36 @@ export declare class PageImpl implements Page {
     section(): string;
     paths(): Path;
     path(): string;
+    /**
+     * Get page slug for PageGraph (Quartz-compatible format)
+     * Slug format: "posts/my-post" (no leading slash, no extension)
+     *
+     * Examples:
+     * - "/posts/my-post.md" → "posts/my-post"
+     * - "/posts/index.md" → "posts"
+     * - "/about.md" → "about"
+     * - "/index.md" → "index"
+     */
     slug(): string;
+    /**
+     * Convert path to slug (Quartz-compatible)
+     *
+     * Rules:
+     * 1. Remove leading slash
+     * 2. Remove file extension
+     * 3. Handle index files (index → parent folder)
+     * 4. Handle _index files (Hugo-style section index)
+     */
     private pathToSlug;
     posOffset(offset: number): Promise<Position>;
     description(): string;
     get Description(): string;
     StaticURL(src: string): string;
     params(): Record<string, any>;
+    /**
+     * Template-friendly Params property getter
+     * Allows templates to access .Params instead of .params()
+     */
     get Params(): Record<string, any>;
     store(): Scratch;
     get Store(): Scratch;

package/dist/types/internal/domain/content/entity/pagebuilder.d.ts

@@ -28,35 +28,118 @@ export declare class PageBuilder {
     private renderableDocument;
     constructor(urlSvc: URLService, langSvc: LangService, taxonomySvc: TaxonomyService, templateSvc: Template | null, pageMapper: PageMap | null, taxonomy: Taxonomy, term: Term, section: Section, standalone: Standalone, converter: Converter, contentHub: ContentHub | null);
     withSource(source: Source): PageBuilder;
+    /**
+     * WithLangIdx - exact replica of Go's WithLangIdx method
+     */
     withLangIdx(idx: number): PageBuilder;
+    /**
+     * Reset - exact replica of Go's reset method
+     */
     private reset;
+    /**
+     * Build - exact replica of Go's Build method
+     */
     build(): Promise<Page>;
+    /**
+     * KindBuild - exact replica of Go's KindBuild method
+     */
     kindBuild(): Promise<Page>;
+    /**
+     * Build internal - exact replica of Go's build method
+     */
     private buildInternal;
+    /**
+     * Build page - exact replica of Go's buildPage method
+     */
     private buildPage;
+    /**
+     * Build page with kind - exact replica of Go's buildPageWithKind method
+     */
     private buildPageWithKind;
+    /**
+     * Apply front matter - exact replica of Go's applyFrontMatter method
+     */
     private applyFrontMatter;
+    /**
+     * Build home - exact replica of Go's buildHome method
+     */
     private buildHome;
+    /**
+     * Build section - exact replica of Go's buildSection method
+     */
     private buildSection;
+    /**
+     * Build 404 - exact replica of Go's build404 method
+     */
     private build404;
+    /**
+     * Build sitemap - exact replica of Go's buildSitemap method
+     */
     private buildSitemap;
+    /**
+     * Build taxonomy - exact replica of Go's buildTaxonomy method
+     */
     private buildTaxonomy;
+    /**
+     * Build term - exact replica of Go's buildTerm method
+     */
     private buildTerm;
     private render;
     private parse;
+    /**
+     * Parse terms - exact replica of Go's parseTerms method
+     */
     private parseTerms;
+    /**
+     * Parse kind - exact replica of Go's parseKind method
+     */
     private parseKind;
+    /**
+     * Parse language by default - exact replica of Go's parseLanguageByDefault method
+     */
     private parseLanguageByDefault;
+    /**
+     * Parse language by index - exact replica of Go's parseLanguageByIdx method
+     */
     private parseLanguageByIdx;
+    /**
+     * Parse language - exact replica of Go's parseLanguage method
+     */
     private parseLanguage;
+    /**
+     * Parse front matter - exact replica of Go's parseFrontMatter method
+     */
     private parseFrontMatter;
+    /**
+     * Create shortcode renderer - returns a simple renderer for shortcodes
+     */
     private createShortcodeRenderer;
     private doRenderShortcode;
     private renderShortcodeMarkdown;
+    /**
+     * Build pagination - creates pagination for page
+     * TypeScript equivalent of Go's buildPagination method
+     */
     private buildPagination;
+    /**
+     * Adapt pagination - creates empty pagination for pages that don't support it
+     * TypeScript equivalent of Go's adaptPagination method
+     */
     private adaptPagination;
+    /**
+     * Build output - builds page output
+     */
     private buildOutput;
+    /**
+     * New page - creates a new page instance based on Go version
+     */
     private newPage;
+    /**
+     * New taxonomy - creates a new taxonomy page
+     */
     private newTaxonomy;
+    /**
+     * New term - creates a new term page
+     */
     private newTerm;
 }

package/dist/types/internal/domain/content/entity/pagecollector.d.ts

@@ -5,6 +5,9 @@ export declare class PagesCollector {
     private processedPaths;
     constructor(pageMap: PageMap, fs: FsService);
     collect(): Promise<void>;
+    /**
+     * CollectDir - exact replica of Go's collectDir method
+     */
     private collectDir;
     private handleBundleLeaf;
 }

package/dist/types/internal/domain/content/entity/pagecontent.d.ts

@@ -1,22 +1,36 @@
 import { TocFragments } from "@internal/domain/markdown";
 export declare class Content {
     private rawSource;
+    /** Front matter data */
     frontMatter?: Record<string, any>;
+    /** Final rendered HTML content */
     renderedContent: string;
+    /** Content summary */
     summary: string;
+    /** Word count */
     wordCount: number;
+    /** Reading time in minutes */
     readingTime: number;
     toc?: TocFragments;
     lazyRendered: boolean;
     lazyRender: (() => Promise<void>) | undefined;
     constructor(source: Uint8Array);
+    /**
+     * Update content with parsed and rendered data
+     */
     updateWithContentResult(result: any): void;
+    /**
+     * Get raw source content
+     */
     getRawSource(): Uint8Array;
     RenderedContent(): Promise<string>;
     Summary(): Promise<string>;
     WordCount(): Promise<number>;
     ReadingTime(): Promise<number>;
     render(): Promise<void>;
+    /**
+     * Check if content is empty
+     */
     isEmpty(): boolean;
 }
 export declare function newContent(source: Uint8Array): Content;

package/dist/types/internal/domain/content/entity/pagemap.d.ts

@@ -3,7 +3,13 @@ import { PageTrees, PageTreesNode } from './pagetrees';
 import { PageBuilder } from './pagebuilder';
 import { FileInfo } from '../vo/fileinfo';
 import { DynaCache } from '@pkg/cahce/cache';
+/**
+ * Path utility functions - simplified implementations
+ */
 export declare function addTrailingSlash(path: string): string;
+/**
+ * Page predicates - exact replica of Go's pagePredicates
+ */
 export declare const pagePredicates: {
     kindPage: (p: Page) => boolean;
     kindSection: (p: Page) => boolean;
@@ -14,18 +20,27 @@ export declare const pagePredicates: {
     shouldListAny: (p: Page) => boolean;
     shouldLink: (p: Page) => boolean;
 };
+/**
+ * PageMapQueryPagesBelowPath - query for pages below a path
+ */
 export interface PageMapQueryPagesBelowPath {
     path: string;
     keyPart: string;
     include: (p: Page) => boolean;
     key(): string;
 }
+/**
+ * PageMapQueryPagesInSection - query for pages in a section
+ */
 export interface PageMapQueryPagesInSection extends PageMapQueryPagesBelowPath {
     recursive: boolean;
     includeSelf: boolean;
     index: number;
     key(): string;
 }
+/**
+ * Implementation of PageMapQueryPagesBelowPath
+ */
 export declare class PageMapQueryPagesBelowPathImpl implements PageMapQueryPagesBelowPath {
     path: string;
     keyPart: string;
@@ -33,6 +48,9 @@ export declare class PageMapQueryPagesBelowPathImpl implements PageMapQueryPages
     constructor(path: string, keyPart: string, include?: (p: Page) => boolean);
     key(): string;
 }
+/**
+ * Implementation of PageMapQueryPagesInSection
+ */
 export declare class PageMapQueryPagesInSectionImpl extends PageMapQueryPagesBelowPathImpl implements PageMapQueryPagesInSection {
     recursive: boolean;
     includeSelf: boolean;
@@ -44,22 +62,73 @@ export declare class PageMap extends PageTrees {
     private pageReverseIndex;
     pageBuilder: PageBuilder;
     constructor(pageBuilder: PageBuilder);
+    /**
+     * SetupReverseIndex - exact replica of Go's SetupReverseIndex method
+     */
     setupReverseIndex(): void;
+    /**
+     * InsertResourceNode - exact replica of Go's InsertResourceNode method
+     */
     insertResourceNode(key: string, node: PageTreesNode): void;
     addFi(f: FileInfo): Promise<void>;
+    /**
+     * Assemble - exact replica of Go's Assemble method
+     */
     assemble(): Promise<void>;
+    /**
+     * AssembleTerms - exact replica of Go's assembleTerms method
+     */
     private assembleTerms;
+    /**
+     * CleanPages - exact replica of Go's cleanPages method
+     */
     private cleanPages;
+    /**
+     * ApplyAggregates - exact replica of Go's applyAggregates method
+     */
     private applyAggregates;
+    /**
+     * AssembleStructurePages - exact replica of Go's assembleStructurePages method
+     */
     private assembleStructurePages;
+    /**
+     * AddMissingTaxonomies - exact replica of Go's addMissingTaxonomies method
+     */
     private addMissingTaxonomies;
+    /**
+     * AddMissingStandalone - exact replica of Go's addMissingStandalone method
+     */
     private addMissingStandalone;
+    /**
+     * GetResourcesForPage - exact replica of Go's getResourcesForPage method
+     */
     getResourcesForPage(ps: Page): Promise<PageSource[]>;
+    /**
+     * ForEachResourceInPage - exact replica of Go's forEachResourceInPage method
+     */
     private forEachResourceInPage;
+    /**
+     * GetPagesInSection - exact replica of Go's getPagesInSection method
+     */
     getPagesInSection(langIndex: number, q: PageMapQueryPagesInSection): Promise<Pages>;
+    /**
+     * GetOrCreatePagesFromCache - simplified synchronous version
+     */
     getOrCreatePagesFromCacheSync(cache: DynaCache<string, Pages> | null, key: string, create: (key: string) => Promise<Pages>): Promise<Pages>;
+    /**
+     * GetPagesWithTerm - exact replica of Go's getPagesWithTerm method
+     */
     getPagesWithTerm(langIndex: number, q: PageMapQueryPagesBelowPath): Promise<Pages>;
+    /**
+     * GetTermsForPageInTaxonomy - exact replica of Go's getTermsForPageInTaxonomy method
+     */
     getTermsForPageInTaxonomy(langIndex: number, base: string, taxonomy: string): Promise<Pages>;
+    /**
+     * GetSections - exact replica of Go's getSections method
+     */
     getSections(langIndex: number, prefix: string): Promise<Pages>;
+    /**
+     * Helper method to get directory from path
+     */
     private pathDir;
 }

package/dist/types/internal/domain/content/entity/pagesource.d.ts

@@ -9,18 +9,70 @@ export declare class Source implements PageSource {
     constructor(file: FileInfo);
     sourceKey(): string;
     contentSource(): Promise<Uint8Array>;
+    /**
+     * Read source all - exact replica of Go's readSourceAll method
+     */
     private readSourceAll;
+    /**
+     * Position offset - exact replica of Go's PosOffset method
+     */
     posOffset(offset: number): Promise<Position>;
+    /**
+     * Get identity - for PageIdentity interface
+     */
     pageIdentity(): Identity;
+    /**
+     * Get file - for FileProvider interface
+     */
     pageFile(): FileInfo;
+    /**
+     * Get stale versions - for Staler interface
+     */
     staleVersions(): number[];
+    /**
+     * Get section - for PageSource interface
+     */
     section(): string;
+    /**
+     * Get paths - for PageSource interface
+     */
     paths(): any;
+    /**
+     * Get path - for PageSource interface
+     */
     path(): string;
+    /**
+     * Get page slug for PageGraph (Quartz-compatible format)
+     * Slug format: "posts/my-post" (no leading slash, no extension)
+     *
+     * This is the same logic as in PageImpl.slug()
+     */
     slug(): string;
+    /**
+     * Convert path to slug (Quartz-compatible)
+     *
+     * Rules:
+     * 1. Remove leading slash
+     * 2. Remove file extension
+     * 3. Handle index files (index → parent folder)
+     * 4. Handle _index files (Hugo-style section index)
+     */
     private pathToSlug;
+    /**
+     * Get opener - for PageSource interface
+     */
     opener(): () => Promise<any>;
+    /**
+     * Open reader - simple implementation
+     */
     openReader(): any;
+    /**
+     * Content - simple implementation
+     */
     content(): Promise<Uint8Array>;
 }
+/**
+ * Factory function to create new page source
+ * Exact replica of Go's newPageSource function
+ */
 export declare function newPageSource(file: FileInfo): Source;

package/dist/types/internal/domain/content/entity/pagetrees.d.ts

@@ -1,5 +1,8 @@
 import { Page, PageIdentity, PageSource } from '../type';
 import { NodeShiftTree, TreeShiftTree, WalkableTrees, MutableTrees } from '@pkg/doctree';
+/**
+ * OrdinalWeightPage - page with ordinal and weight
+ */
 declare class OrdinalWeightPage {
     private ordinal;
     private weight;
@@ -11,6 +14,9 @@ declare class OrdinalWeightPage {
     name(): string;
     title(): string;
 }
+/**
+ * WeightedTermTreeNode - tree node for weighted terms
+ */
 export declare class WeightedTermTreeNode {
     private pageTreesNodeInstance;
     term: OrdinalWeightPage;
@@ -21,6 +27,9 @@ export declare class WeightedTermTreeNode {
     isEmpty(): boolean;
     shift(languageIndex: number, exact: boolean): [PageTreesNode | null, boolean];
 }
+/**
+ * PageTreesNode - represents a node in the page tree
+ */
 export interface IPageTreesNode {
     getPage(): [Page, boolean];
 }
@@ -53,5 +62,8 @@ export declare class PageTrees {
     get TreeTaxonomyEntries(): TreeShiftTree<WeightedTermTreeNode>;
     get ResourceTrees(): MutableTrees;
 }
+/**
+ * Factory function to create new PageTreesNode
+ */
 export declare function newPageTreesNode(ps: PageSource): PageTreesNode;
 export {};

package/dist/types/internal/domain/content/entity/paginator.d.ts

@@ -1,4 +1,7 @@
 import { Page, PageGroups, Pager, PagerManager, Pages } from "@internal/domain/content";
+/**
+ * TypeScript implementation of Go's Paginator
+ */
 export declare class PaginatorImpl {
     private paginatedElements;
     private _pagers;
@@ -11,8 +14,14 @@ export declare class PaginatorImpl {
     getElement(pageNumber: number): any[];
     getBase(): string;
     getPagers(): PagerImpl[];
+    /**
+     * Get all pages across all pagers - flattens all paginated elements
+     */
     getAllPages(): Pages;
 }
+/**
+ * TypeScript implementation of Go's Pager - implements the existing Pager interface
+ */
 declare class PagerImpl implements Pager {
     private number;
     private paginator;
@@ -32,10 +41,16 @@ declare class PagerImpl implements Pager {
     private element;
     private pathJoin;
 }
+/**
+ * PagerManager service interface
+ */
 export interface PagerSvc {
     pageSize(): number;
     globalRegularPages(): Promise<any[]>;
 }
+/**
+ * TypeScript implementation of Go's Paginator entity - implements existing PagerManager interface
+ */
 export declare class PaginatorManagerImpl implements PagerManager {
     private currentPager;
     private initialized;
@@ -47,6 +62,10 @@ export declare class PaginatorManagerImpl implements PagerManager {
     paginate(groups: PageGroups): Promise<Pager>;
     paginate(pages: Pages): Promise<Pager>;
     paginator(): Promise<Pager>;
+    /**
+     * Initialize paginator - TypeScript equivalent of golang's init.Do()
+     * This matches the exact logic from golang's Paginator.Paginator() method
+     */
     private initializePaginator;
     private newPaginatorFromPages;
     private newPaginatorFromPageGroups;

package/dist/types/internal/domain/content/entity/section.d.ts

@@ -2,14 +2,29 @@ import { FsService, Page } from '../type';
 import { PageTreesNode } from './pagetrees';
 import { PageBuilder } from './pagebuilder';
 import { NodeShiftTree } from '@pkg/doctree';
+/**
+ * Constants - exact replica of Go's constants
+ */
 export declare const PAGE_HOME_BASE = "/";
+/**
+ * Section class - exact replica of Go's Section struct
+ */
 export declare class Section {
     home: Page | null;
     seen: Record<string, boolean>;
     fsSvc: FsService;
     constructor(fsSvc: FsService);
+    /**
+     * IsHome - exact replica of Go's isHome method
+     */
     isHome(key: string): boolean;
+    /**
+     * IsSectionExist - exact replica of Go's isSectionExist method
+     */
     isSectionExist(section: string): boolean;
     assemble(pages: NodeShiftTree<PageTreesNode>, pb: PageBuilder, langIdx: number): Promise<void>;
+    /**
+     * CreateHome - exact replica of Go's CreateHome method
+     */
     createHome(pb: PageBuilder): Promise<void>;
 }

package/dist/types/internal/domain/content/entity/shortcode.d.ts

@@ -1,5 +1,8 @@
 import { Page, Position } from '../type';
 import { Scratch } from '@pkg/maps/scratch';
+/**
+ * ShortcodeWithPage is the "." context in a shortcode template.
+ */
 export declare class ShortcodeWithPage {
     private _params;
     private _inner;
@@ -14,23 +17,59 @@ export declare class ShortcodeWithPage {
     private _pos;
     private _scratch;
     constructor(params: any, inner: string, page: Page, parent: ShortcodeWithPage | null, name: string, isNamedParams: boolean, ordinal: number, indentation?: string, posOffset?: number);
+    /**
+     * Get shortcode parameters
+     */
     get params(): any;
     get Params(): any;
     get IsNamedParams(): boolean;
+    /**
+     * Get inner content
+     */
     get inner(): string;
     get Inner(): string;
+    /**
+     * Get parent page
+     */
     get page(): Page;
     get Page(): Page;
+    /**
+     * Get parent shortcode if any
+     */
     get parent(): ShortcodeWithPage | null;
     get Parent(): ShortcodeWithPage | null;
+    /**
+     * Get shortcode name
+     */
     get name(): string;
+    /**
+     * Check if using named parameters
+     */
     get isNamedParams(): boolean;
+    /**
+     * Get ordinal position
+     */
     get ordinal(): number;
     get Ordinal(): number;
+    /**
+     * Returns the (potentially de-indented) inner content of the shortcode
+     */
     innerDeindent(): string;
     get InnerDeindent(): string;
+    /**
+     * Position returns this shortcode's detailed position.
+     * Note that this information may be expensive to calculate,
+     * so only use this in error situations.
+     */
     position(): Promise<Position>;
+    /**
+     * Scratch returns a scratch-pad scoped for this shortcode.
+     * This can be used as a temporary storage for variables, counters etc.
+     */
     scratch(): Scratch;
+    /**
+     * Get is a convenience method to look up shortcode parameters by its key
+     */
     get(key: string | number): any;
     Get(key: string | number): any;
 }

package/dist/types/internal/domain/content/entity/standalone.d.ts

@@ -2,11 +2,20 @@ import { FsService } from '../type';
 import { PageTreesNode } from './pagetrees';
 import { PageBuilder } from './pagebuilder';
 import { NodeShiftTree } from '@pkg/doctree';
+/**
+ * Constants - exact replica of Go's constants
+ */
 export declare const STANDALONE_PAGE_404_BASE = "404";
 export declare const STANDALONE_PAGE_SITEMAP_BASE = "_sitemap";
+/**
+ * Standalone class - exact replica of Go's Standalone struct
+ */
 export declare class Standalone {
     fsSvc: FsService;
     constructor(fsSvc: FsService);
+    /**
+     * Assemble - exact replica of Go's Assemble method
+     */
     assemble(pages: NodeShiftTree<PageTreesNode>, pb: PageBuilder): Promise<void>;
     private addStandalone;
 }

package/dist/types/internal/domain/content/entity/taxonomy.d.ts

@@ -6,9 +6,24 @@ export declare class Taxonomy {
     views: ITaxonomy[];
     fsSvc: FsService;
     constructor(views: ITaxonomy[], fsSvc: FsService);
+    /**
+     * Assemble - exact replica of Go's Assemble method
+     */
     assemble(pages: NodeShiftTree<PageTreesNode>, pb: PageBuilder, langIdx: number): Promise<void>;
+    /**
+     * IsTaxonomyPath - exact replica of Go's IsTaxonomyPath method
+     */
     isTaxonomyPath(p: string): boolean;
+    /**
+     * PluralTreeKey - exact replica of Go's PluralTreeKey method
+     */
     pluralTreeKey(plural: string): string;
+    /**
+     * GetTaxonomy - exact replica of Go's getTaxonomy method
+     */
     getTaxonomy(s: string): ITaxonomy | null;
+    /**
+     * IsZero - exact replica of Go's IsZero method
+     */
     isZero(v: ITaxonomy | null): boolean;
 }