@mdfriday/foundry 26.4.20 → 26.5.1

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;
 }

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

@@ -2,9 +2,15 @@ import { FsService } from '../type';
 import { PageTreesNode, WeightedTermTreeNode } from './pagetrees';
 import { PageBuilder } from './pagebuilder';
 import { NodeShiftTree, TreeShiftTree } from '@pkg/doctree';
+/**
+ * Term class - exact replica of Go's Term struct
+ */
 export declare class Term {
     terms: Record<string, string[]>;
     fsSvc: FsService;
     constructor(fsSvc: FsService);
+    /**
+     * Assemble - exact replica of Go's Assemble method
+     */
     assemble(pages: NodeShiftTree<PageTreesNode>, entries: TreeShiftTree<WeightedTermTreeNode>, pb: PageBuilder, langIdx: number): Promise<Error | null>;
 }

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

@@ -10,10 +10,32 @@ export declare class Translator {
     private contentLanguage;
     private translateFuncs;
     constructor(contentLanguage: string);
+    /**
+     * Translate a translation ID for a specific language
+     * @param lang Language code (e.g., 'en', 'cn', 'zh-TW')
+     * @param translationID Translation identifier
+     * @returns Translated string or fallback
+     */
     translate(lang: string, translationID: string): string;
+    /**
+     * Setup translation functions from i18n files
+     * @param fsService File system service to read i18n files
+     */
     setupTranslateFuncs(fsService: FsService): Promise<void>;
+    /**
+     * Read i18n file content from FileMetaInfo
+     */
     private readI18nFile;
+    /**
+     * Parse YAML content into translation items
+     */
     private parseI18nContent;
+    /**
+     * Get available languages
+     */
     getAvailableLanguages(): string[];
+    /**
+     * Check if a language is supported
+     */
     hasLanguage(lang: string): boolean;
 }

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

@@ -293,10 +293,16 @@ export interface PageSorter {
     less(i: number, j: number): boolean;
 }
 export type CollatorStringCompare = (getString: (page: Page) => string, p1: Page, p2: Page) => number;
+/**
+ * OrdinalWeightPage - TypeScript equivalent of Go's OrdinalWeightPage interface
+ */
 export interface OrdinalWeightPage {
     weight(): number;
     ordinal(): number;
     page(): Page;
     owner(): Page;
 }
+/**
+ * WalkTaxonomyFunc - TypeScript equivalent of Go's WalkTaxonomyFunc
+ */
 export type WalkTaxonomyFunc = (taxonomy: string, term: string, page: OrdinalWeightPage) => Promise<void>;

package/dist/types/internal/domain/content/vo/classifier.d.ts

@@ -4,12 +4,36 @@ export declare class Classifier {
     private files;
     constructor(files: FileInfo[]);
     static newClassifier(fis: FileMetaInfo[]): Promise<Classifier>;
+    /**
+     * Sort files using the same logic as Go version
+     */
     private sort;
+    /**
+     * GetLeaf - returns the first leaf bundle file
+     */
     getLeaf(): FileInfo | null;
+    /**
+     * Get all files
+     */
     getFiles(): FileInfo[];
+    /**
+     * Get number of files
+     */
     length(): number;
+    /**
+     * Get file at index
+     */
     at(index: number): FileInfo | undefined;
+    /**
+     * Filter files by predicate
+     */
     filter(predicate: (file: FileInfo) => boolean): FileInfo[];
+    /**
+     * Find first file matching predicate
+     */
     find(predicate: (file: FileInfo) => boolean): FileInfo | undefined;
+    /**
+     * Check if empty
+     */
     isEmpty(): boolean;
 }

package/dist/types/internal/domain/content/vo/frontmatter.d.ts

@@ -1,25 +1,90 @@
 import { FrontMatter, FrontMatterParser, LangService, TaxonomyService } from '../type';
 export type Params = Record<string, any>;
+/**
+ * NewFrontMatter creates a new FrontMatter instance with default values
+ * Modified: Don't set default date - will be set from file modTime
+ */
 export declare function newFrontMatter(): FrontMatter;
+/**
+ * FrontMatterParser class - exact replica of Go's FrontMatterParser struct
+ */
 export declare class FrontMatterParserImpl implements FrontMatterParser {
     params: Record<string, any> | undefined;
     langSvc: LangService;
     taxonomySvc: TaxonomyService;
     constructor(params: Record<string, any> | undefined, langSvc: LangService, taxonomySvc: TaxonomyService);
+    /**
+     * Parse front matter from parameters
+     * Exact replica of Go version: func (b *FrontMatterParser) Parse() (*FrontMatter, error)
+     */
     parse(baseURL: string): Promise<FrontMatter>;
+    /**
+     * Parse date field
+     * Modified: Don't set default date here, let applyFrontMatter handle it based on file modTime
+     */
     private parseDate;
+    /**
+     * Parse weight field
+     * Exact replica of Go version: func (b *FrontMatterParser) parseWeight(fm *FrontMatter) error
+     */
     private parseWeight;
+    /**
+     * Parse title field
+     * Exact replica of Go version: func (b *FrontMatterParser) parseTitle(fm *FrontMatter) error
+     */
     private parseTitle;
     private parseDescription;
+    /**
+     * Parse customized fields (path, lang, kind)
+     * Exact replica of Go version: func (b *FrontMatterParser) parseCustomized(fm *FrontMatter) error
+     */
     private parseCustomized;
+    /**
+     * Parse terms (taxonomies)
+     * Exact replica of Go version: func (b *FrontMatterParser) parseTerms(fm *FrontMatter) error
+     */
     private parseTerms;
+    /**
+     * Parse organization field
+     * Parses organization configuration from front matter parameters
+     */
     private parseOrganization;
+    /**
+     * Parse menu field
+     * Parses menu configuration from front matter parameters
+     */
     private parseMenu;
+    /**
+     * Parse menu items array
+     * Helper method to parse an array of menu item objects
+     */
     private parseMenuItems;
+    /**
+     * Parse author field
+     * Parses author configuration from front matter parameters
+     */
     private parseAuthor;
+    /**
+     * Parse contact information (shared between Organization and Author)
+     */
     private parseContact;
+    /**
+     * Parse social information (shared between Organization and Author)
+     */
     private parseSocial;
+    /**
+     * Convert path to slash preserving leading slash
+     * Equivalent to Go's paths.ToSlashPreserveLeading
+     */
     private toSlashPreserveLeading;
 }
+/**
+ * Get parameter with case-insensitive key lookup (lowercase version)
+ * Exact replica of Go version: func GetParamToLower(m maps.Params, key string) any
+ */
 export declare function getParamToLower(m: Params, key: string): any;
+/**
+ * Get parameter with case-insensitive key lookup
+ * Exact replica of Go version: func GetParam(p maps.Params, key string, stringToLower bool) any
+ */
 export declare function getParam(p: Record<string, any>, key: string, stringToLower: boolean): any;

package/dist/types/internal/domain/content/vo/kind.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Gets the page kind given a string, empty if not found.
+ * Note that this will not return any temporary kinds (e.g. robotstxt).
+ */
 export declare function getKindMain(s: string): string;
+/**
+ * Returns whether the given kind is a branch node.
+ */
 export declare function isBranch(kind: string): boolean;
+/**
+ * Returns the new kind if the given kind is deprecated.
+ */
 export declare function isDeprecatedAndReplacedWith(s: string): string;