@mdfriday/foundry 26.4.20 → 26.5.2

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;

package/dist/types/internal/domain/fs/entity/basefs.d.ts

@@ -3,12 +3,31 @@ export declare class BaseFs implements Fs {
     private readonly fs;
     private readonly roots;
     constructor(fs: Fs, roots: string[]);
+    /**
+     * Convert relative path to absolute path using the first root
+     * In BaseFs context, all paths are relative to the BaseFs root, even if they start with "/"
+     */
     private toAbsolutePath;
     private isSameRootedPath;
+    /**
+     * Stat returns file info with opener function
+     */
     stat(name: string): Promise<IFileInfo>;
+    /**
+     * Open opens a file or directory
+     */
     open(name: string): Promise<IFile>;
+    /**
+     * Private method to open a file internally
+     */
     private openInternal;
+    /**
+     * Get the matching root path for a given name
+     */
     private getRoot;
+    /**
+     * Private method to open a directory
+     */
     private openDir;
     create(name: string): Promise<IFile>;
     mkdir(name: string, perm: number): Promise<void>;
@@ -22,4 +41,8 @@ export declare class BaseFs implements Fs {
     chown(name: string, uid: number, gid: number): Promise<void>;
     chtimes(name: string, atime: Date, mtime: Date): Promise<void>;
 }
+/**
+ * Creates a new BaseFs instance
+ * TypeScript version of Go's NewBaseFs function
+ */
 export declare function newBaseFs(fs: Fs, roots: string[]): BaseFs;

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

@@ -2,6 +2,10 @@ import { FileMetaInfo, Fs as IFs, WalkCallback, WalkwayConfig } from '../type';
 import { OriginFs } from './originfs';
 import { OverlayFs } from './overlayfs';
 import { Service } from "@internal/domain/fs";
+/**
+ * Fs entity - main filesystem entity
+ * TypeScript version of Go's Fs struct
+ */
 export declare class Fs {
     readonly originFs: OriginFs;
     readonly prompts: OverlayFs;
@@ -14,7 +18,13 @@ export declare class Fs {
     readonly work: IFs;
     readonly service: Service;
     constructor(originFs: OriginFs, prompts: OverlayFs, workflows: OverlayFs, content: OverlayFs[], layouts: OverlayFs, statics: OverlayFs, assets: OverlayFs, i18n: OverlayFs, work: IFs);
+    /**
+     * Get the OS filesystem
+     */
     os(): IFs;
+    /**
+     * Get the work filesystem
+     */
     workFs(): IFs;
     workflowFs(): IFs;
     promptFs(): IFs;
@@ -27,6 +37,9 @@ export declare class Fs {
     newFileMetaInfo(filename: string): FileMetaInfo;
     newFileMetaInfoWithContent(content: string): FileMetaInfo;
     getFileMetaInfos(paths: string[]): Promise<Map<string, FileMetaInfo>>;
+    /**
+     * Create new base path filesystem
+     */
     newBasePathFs(source: IFs, path: string): IFs;
     walkPrompts(start: string, cb: WalkCallback, conf: WalkwayConfig): Promise<void>;
     walkWorkflows(start: string, cb: WalkCallback, conf: WalkwayConfig): Promise<void>;

package/dist/types/internal/domain/fs/entity/originfs.d.ts

@@ -4,7 +4,13 @@ export declare class OriginFs {
     readonly origin: IFs;
     readonly publishDir: IFs;
     constructor(source: IFs, origin: IFs, publishDir: IFs);
+    /**
+     * Get the source filesystem
+     */
     getSource(): IFs;
+    /**
+     * Get the origin filesystem
+     */
     getOrigin(): IFs;
     publish(): IFs;
 }

package/dist/types/internal/domain/fs/entity/overlaydir.d.ts

@@ -1,4 +1,8 @@
 import { File, FileInfo, DirsMerger, InfoFunc, OverlayDirOptions, Fs } from '../type';
+/**
+ * OverlayDir entity - represents a merged directory from multiple filesystems
+ * TypeScript version of Go's Dir struct
+ */
 export declare class OverlayDir implements File {
     private _name;
     private fss;
@@ -10,14 +14,41 @@ export declare class OverlayDir implements File {
     private fis;
     private closed;
     constructor(options?: OverlayDirOptions);
+    /**
+     * Get file name
+     */
     name(): string;
+    /**
+     * Check if directory is closed
+     */
     private isClosed;
+    /**
+     * Read directory entries
+     */
     readdir(count: number): Promise<FileInfo[]>;
+    /**
+     * Read directory names
+     */
     readdirnames(n: number): Promise<string[]>;
+    /**
+     * Load directory entries from all filesystems
+     */
     private loadDirectoryEntries;
+    /**
+     * Read directory entries from a specific filesystem or file
+     */
     private readFromFilesystem;
+    /**
+     * Get file statistics
+     */
     stat(): Promise<FileInfo>;
+    /**
+     * Close directory
+     */
     close(): Promise<void>;
+    /**
+     * Not supported operations for directories
+     */
     private notSupported;
     read(buffer: Uint8Array): Promise<{
         bytesRead: number;
@@ -42,7 +73,20 @@ export declare class OverlayDir implements File {
         bytesWritten: number;
     }>;
 }
+/**
+ * Get a directory from the pool
+ */
 export declare function getDir(): OverlayDir;
+/**
+ * Release a directory back to the pool
+ */
 export declare function releaseDir(dir: OverlayDir): void;
+/**
+ * Open a new merged directory
+ * TypeScript version of Go's OpenDir function
+ */
 export declare function openDir(name: string, merge: DirsMerger | null, info: InfoFunc | null, fss: Fs[]): Promise<OverlayDir>;
+/**
+ * Create a new OverlayDir instance
+ */
 export declare function newOverlayDir(options?: OverlayDirOptions): OverlayDir;

package/dist/types/internal/domain/fs/entity/overlayfs.d.ts

@@ -1,33 +1,112 @@
 import { Fs, File, FileInfo, OverlayFs as IOverlayFs, DirsMerger, OverlayFsOptions } from '../type';
 import { OverlayOptions } from '@internal/domain/fs/vo/overlayoptions';
+/**
+ * OverlayFs entity - main overlay filesystem implementation
+ * TypeScript version of Go's OverlayFs struct
+ */
 export declare class OverlayFs implements IOverlayFs {
     private fss;
     private mergeDirs;
     private firstWritable;
     constructor(options: OverlayOptions);
+    /**
+     * Get filesystem name
+     */
     name(): string;
+    /**
+     * Implementation of FilesystemIterator interface
+     */
     filesystem(i: number): Fs | null;
+    /**
+     * Get number of filesystems in overlay
+     */
     numFilesystems(): number;
+    /**
+     * Append filesystems to overlay (returns new instance)
+     */
     append(...fss: Fs[]): OverlayFs;
+    /**
+     * Set directory merger (returns new instance)
+     */
     withDirsMerger(merger: DirsMerger): OverlayFs;
+    /**
+     * Get writable filesystem (first filesystem if firstWritable is true)
+     */
     private writeFs;
+    /**
+     * Collect directories from all filesystems
+     */
     private collectDirs;
+    /**
+     * Recursively collect directories from filesystem hierarchy
+     */
     private collectDirsRecursive;
+    /**
+     * Stat file/directory across all filesystems
+     */
     private statInternal;
+    /**
+     * Recursive stat implementation
+     */
     private statRecursive;
+    /**
+     * Check if error is "not exist" error
+     */
     private isNotExistError;
+    /**
+     * Create a file (write operation)
+     */
     create(name: string): Promise<File>;
+    /**
+     * Create directory (write operation)
+     */
     mkdir(name: string, perm: number): Promise<void>;
+    /**
+     * Create directory tree (write operation)
+     */
     mkdirAll(path: string, perm: number): Promise<void>;
+    /**
+     * Open file for reading (searches all filesystems)
+     */
     open(name: string): Promise<File>;
+    /**
+     * Open file with flags (write operations use first filesystem)
+     */
     openFile(name: string, flag: number, perm: number): Promise<File>;
+    /**
+     * Remove file (write operation)
+     */
     remove(name: string): Promise<void>;
+    /**
+     * Remove directory tree (write operation)
+     */
     removeAll(path: string): Promise<void>;
+    /**
+     * Rename file (write operation)
+     */
     rename(oldname: string, newname: string): Promise<void>;
+    /**
+     * Get file info (searches all filesystems)
+     */
     stat(name: string): Promise<FileInfo>;
+    /**
+     * Change file mode (write operation)
+     */
     chmod(name: string, mode: number): Promise<void>;
+    /**
+     * Change file ownership (write operation)
+     */
     chown(name: string, uid: number, gid: number): Promise<void>;
+    /**
+     * Change file times (write operation)
+     */
     chtimes(name: string, atime: Date, mtime: Date): Promise<void>;
 }
+/**
+ * Factory function to create new OverlayFs
+ */
 export declare function newOverlayFs(options: OverlayOptions): OverlayFs;
+/**
+ * Create OverlayFs from raw options
+ */
 export declare function createOverlayFs(opts: OverlayFsOptions): OverlayFs;

package/dist/types/internal/domain/fs/entity/service.d.ts

@@ -1,7 +1,22 @@
 import { FileMetaInfo } from '../type';
+/**
+ * Service class for filesystem entity operations
+ * TypeScript equivalent of Go's Service struct
+ */
 export declare class Service {
+    /**
+     * Creates a new FileMetaInfo with the given filename
+     * TypeScript equivalent of Go's NewFileMetaInfo method
+     */
     newFileMetaInfo(filename: string): FileMetaInfo;
+    /**
+     * Creates a new FileMetaInfo with the given content
+     * TypeScript equivalent of Go's NewFileMetaInfoWithContent method
+     */
     newFileMetaInfoWithContent(content: string): FileMetaInfo;
 }
+/**
+ * Creates a new Service instance
+ */
 export declare function newService(): Service;
 export default Service;

package/dist/types/internal/domain/fs/factory/fs.d.ts

@@ -6,4 +6,8 @@ export interface Workspace {
     publish: string;
     osFs: IFs;
 }
+/**
+ * Create Fs entity following Go version structure
+ * TypeScript version of Go's New function
+ */
 export declare function createFs(workspace: Workspace, mods: Modules): Promise<Fs>;

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

@@ -36,20 +36,69 @@ export interface File {
     }>;
 }
 export interface Fs {
+    /**
+     * Create creates a file in the filesystem, returning the file and an
+     * error, if any happens.
+     */
     create(name: string): Promise<File>;
+    /**
+     * Mkdir creates a directory in the filesystem, return an error if any
+     * happens.
+     */
     mkdir(name: string, perm: number): Promise<void>;
+    /**
+     * MkdirAll creates a directory path and all parents that does not exist
+     * yet.
+     */
     mkdirAll(path: string, perm: number): Promise<void>;
+    /**
+     * Open opens a file, returning it or an error, if any happens.
+     */
     open(name: string): Promise<File>;
+    /**
+     * OpenFile opens a file using the given flags and the given mode.
+     */
     openFile(name: string, flag: number, perm: number): Promise<File>;
+    /**
+     * Remove removes a file identified by name, returning an error, if any
+     * happens.
+     */
     remove(name: string): Promise<void>;
+    /**
+     * RemoveAll removes a directory path and any children it contains. It
+     * does not fail if the path does not exist (return null).
+     */
     removeAll(path: string): Promise<void>;
+    /**
+     * Rename renames a file.
+     */
     rename(oldname: string, newname: string): Promise<void>;
+    /**
+     * Stat returns a FileInfo describing the named file, or an error, if any
+     * happens.
+     */
     stat(name: string): Promise<FileInfo>;
+    /**
+     * The name of this FileSystem
+     */
     name(): string;
+    /**
+     * Chmod changes the mode of the named file to mode.
+     */
     chmod(name: string, mode: number): Promise<void>;
+    /**
+     * Chown changes the uid and gid of the named file.
+     */
     chown(name: string, uid: number, gid: number): Promise<void>;
+    /**
+     * Chtimes changes the access and modification times of the named file
+     */
     chtimes(name: string, atime: Date, mtime: Date): Promise<void>;
 }
+/**
+ * File system error constants
+ * Equivalent to Go's afero error variables
+ */
 export declare class FsError extends Error {
     code?: string | undefined;
     constructor(message: string, code?: string | undefined);
@@ -60,6 +109,9 @@ export declare const ErrTooLarge: FsError;
 export declare const ErrFileNotFound: FsError;
 export declare const ErrFileExists: FsError;
 export declare const ErrDestinationExists: FsError;
+/**
+ * File open flags (equivalent to Go's vo package flags)
+ */
 export declare enum OpenFlags {
     O_RDONLY = 0,
     O_WRONLY = 1,
@@ -77,13 +129,25 @@ export interface FileMetaInfo extends FileInfo {
     root(): string;
     open(): Promise<File>;
 }
+/**
+ * Walk function type - called for each file/directory during walk
+ */
 export type WalkFunc = (path: string, info: FileMetaInfo) => Promise<void | Error>;
+/**
+ * Walk hook function type - called before/after processing directory contents
+ */
 export type WalkHook = (dir: FileMetaInfo, path: string, readdir: FileMetaInfo[]) => Promise<FileMetaInfo[]>;
+/**
+ * WalkCallback structure containing hooks and walk function
+ */
 export interface WalkCallback {
     hookPre?: WalkHook;
     walkFn: WalkFunc;
     hookPost?: WalkHook;
 }
+/**
+ * WalkwayConfig structure containing hooks and walk function
+ */
 export interface WalkwayConfig {
     info?: FileMetaInfo;
     dirEntries?: FileMetaInfo[];
@@ -91,24 +155,52 @@ export interface WalkwayConfig {
     failOnNotExist?: boolean;
     sortDirEntries?: boolean;
 }
+/**
+ * Walk-related errors
+ */
 export declare const ErrSkipDir: Error;
 export declare const ErrWalkAlreadyWalked: FsError;
+/**
+ * Filesystem iterator interface for iterating over wrapped filesystems
+ * TypeScript version of Go's FilesystemIterator
+ */
 export interface FilesystemIterator {
     filesystem(i: number): Fs | null;
     numFilesystems(): number;
 }
+/**
+ * Directory merger function type
+ * TypeScript version of Go's DirsMerger
+ */
 export type DirsMerger = (lofi: FileInfo[], bofi: FileInfo[]) => FileInfo[];
+/**
+ * OverlayFs options configuration
+ * TypeScript version of Go's Options
+ */
 export interface OverlayFsOptions {
     fss: Fs[];
     firstWritable?: boolean;
     dirsMerger?: DirsMerger;
 }
+/**
+ * OverlayFs interface extending base Fs functionality
+ * TypeScript version of Go's OverlayFs interface
+ */
 export interface OverlayFs extends Fs, FilesystemIterator {
     append(...fss: Fs[]): OverlayFs;
     withDirsMerger(merger: DirsMerger): OverlayFs;
 }
+/**
+ * Directory opener function type
+ */
 export type DirOpener = () => Promise<File>;
+/**
+ * Info function type for directory stats
+ */
 export type InfoFunc = () => Promise<FileInfo>;
+/**
+ * Overlay directory options
+ */
 export interface OverlayDirOptions {
     name?: string;
     fss?: Fs[];
@@ -116,6 +208,9 @@ export interface OverlayDirOptions {
     info?: InfoFunc;
     merge?: DirsMerger;
 }
+/**
+ * OverlayFs errors
+ */
 export declare class OverlayFsError extends FsError {
     constructor(message: string, code?: string);
 }