@mdfriday/foundry 26.4.19 → 26.5.1

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

package/dist/types/internal/domain/fs/vo/dir.d.ts

@@ -2,20 +2,61 @@ import { File as IFile, Fs } from '../type';
 import { FileMeta } from './filemeta';
 import { FileInfo } from './fileinfo';
 import { File } from './file';
+/**
+ * DirOpener function type for opening virtual directories
+ * TypeScript version of Go's DirOpener func
+ */
 export type DirOpener = () => Promise<FileInfo[]>;
+/**
+ * Filter function type for filtering directory entries
+ */
 export type DirFilter = (entries: FileInfo[]) => Promise<FileInfo[]>;
+/**
+ * DirFile represents a directory file with virtual directory support
+ * TypeScript version of Go's DirFile struct
+ */
 export declare class DirFile extends File {
     private virtualOpener;
     private filter;
     constructor(file: File, virtualOpener?: DirOpener | null, filter?: DirFilter | null);
+    /**
+     * ReadDir reads directory entries, supporting both real and virtual directories
+     */
     readDir(count: number): Promise<FileInfo[]>;
+    /**
+     * Read virtual directory entries
+     */
     private readVirtualDir;
+    /**
+     * Set the filter function
+     */
     setFilter(filter: DirFilter): void;
+    /**
+     * Set the virtual opener function
+     */
     setVirtualOpener(opener: DirOpener): void;
+    /**
+     * Get the filter function
+     */
     getFilter(): DirFilter | null;
+    /**
+     * Get the virtual opener function
+     */
     getVirtualOpener(): DirOpener | null;
 }
+/**
+ * Creates a new DirFile with virtual opener
+ */
 export declare function newDirFileWithVirtualOpener(file: File, opener: DirOpener): DirFile;
+/**
+ * Creates a new DirFile from file components
+ */
 export declare function newDirFile(file: IFile, meta: FileMeta, fs: Fs): DirFile;
+/**
+ * Creates a new DirFile with filter
+ */
 export declare function newDirFileWithFilter(file: File, filter: DirFilter): DirFile;
+/**
+ * Creates a new DirFile with both virtual opener and filter
+ */
 export declare function newDirFileWithOpenerAndFilter(file: File, opener: DirOpener, filter: DirFilter): DirFile;

package/dist/types/internal/domain/fs/vo/file.d.ts

@@ -1,16 +1,35 @@
 import { File as IFile, Fs, FileInfo as IFileInfo } from '../type';
 import { FileMeta } from './filemeta';
 import { FileInfo } from './fileinfo';
+/**
+ * File represents a file with metadata
+ * TypeScript version of Go's File struct
+ */
 export declare class File implements IFile {
     private readonly file;
     private readonly fileMeta;
     private fs;
     private readonly _isDir;
     constructor(file: IFile | null, fileMeta: FileMeta, fs: Fs, isDir?: boolean);
+    /**
+     * Check if this is a no-op file (null file)
+     */
     isNop(): boolean;
+    /**
+     * Close the file
+     */
     close(): Promise<void>;
+    /**
+     * ReadDir reads directory entries
+     */
     readDir(count: number): Promise<FileInfo[]>;
+    /**
+     * Get the file metadata
+     */
     meta(): FileMeta;
+    /**
+     * Simple path join implementation
+     */
     private joinPath;
     read(buffer: Uint8Array): Promise<{
         bytesRead: number;
@@ -39,7 +58,16 @@ export declare class File implements IFile {
         bytesWritten: number;
     }>;
 }
+/**
+ * Creates a new File instance
+ */
 export declare function newFile(file: IFile, filename: string, fs: Fs): File;
+/**
+ * Creates a new File with existing FileMeta
+ */
 export declare function newFileWithMeta(file: IFile, meta: FileMeta, fs: Fs): File;
 export declare function newDirFileWithMeta(file: IFile, meta: FileMeta, fs: Fs): File;
+/**
+ * Creates a new directory File
+ */
 export declare function newDirFile(file: IFile, filename: string, fs: Fs): File;

package/dist/types/internal/domain/fs/vo/fileinfo.d.ts

@@ -1,12 +1,29 @@
 import { FileInfo as IFileInfo, FileMetaInfo, File } from '../type';
 import { FileMeta } from './filemeta';
+/**
+ * FileInfo represents file information with metadata
+ * TypeScript version of Go's FileInfo struct
+ * Implements FileMetaInfo interface
+ */
 export declare class FileInfo implements FileMetaInfo {
     private readonly fileInfo;
     private _fileMeta;
     constructor(fileInfo: IFileInfo, fileMeta: FileMeta);
+    /**
+     * Meta returns the FileMeta
+     */
     meta(): FileMeta;
+    /**
+     * Type returns the file mode
+     */
     type(): number;
+    /**
+     * Info returns the underlying FileInfo
+     */
     info(): IFileInfo;
+    /**
+     * Set the FileMeta
+     */
     setMeta(meta: FileMeta): void;
     name(): string;
     size(): number;
@@ -20,5 +37,11 @@ export declare class FileInfo implements FileMetaInfo {
     root(): string;
     open(): Promise<File>;
 }
+/**
+ * Creates a new FileInfo instance
+ */
 export declare function newFileInfo(fi: IFileInfo, filename: string): FileInfo;
+/**
+ * Creates a new FileInfo instance with FileMeta
+ */
 export declare function newFileInfoWithMeta(fi: IFileInfo, meta: FileMeta): FileInfo;

package/dist/types/internal/domain/fs/vo/filemeta.d.ts

@@ -1,23 +1,68 @@
 import { File } from '../type';
+/**
+ * FileOpener function type for opening files
+ * TypeScript version of Go's FileOpener func
+ */
 export type FileOpener = () => Promise<File>;
+/**
+ * MetaProvider interface for objects that can provide FileMeta
+ */
 export interface MetaProvider {
     meta(): FileMeta;
 }
+/**
+ * FileMeta represents file metadata
+ * Simplified TypeScript version of Go's FileMeta struct
+ */
 export declare class FileMeta {
     private filename;
     private componentRoot;
     private componentDir;
     private openFunc;
     constructor(filename?: string, openFunc?: FileOpener | null);
+    /**
+     * FileName returns the filename
+     */
     fileName(): string;
+    /**
+     * RelativeFilename returns the relative filename from root
+     */
     relativeFilename(): string;
+    /**
+     * Component returns the component directory
+     */
     component(): string;
+    /**
+     * Root returns the component root
+     */
     root(): string;
+    /**
+     * Open opens the file using the OpenFunc
+     */
     open(): Promise<File>;
+    /**
+     * Set the filename
+     */
     setFileName(filename: string): void;
+    /**
+     * Set the component root
+     */
     setComponentRoot(root: string): void;
+    /**
+     * Set the component directory
+     */
     setComponentDir(dir: string): void;
+    /**
+     * Set the open function
+     */
     setOpenFunc(openFunc: FileOpener): void;
+    /**
+     * Merge merges another FileMeta into this one
+     * Only copies non-empty values
+     */
     merge(from: FileMeta): void;
 }
+/**
+ * Creates a new FileMeta instance
+ */
 export declare function newFileMeta(filename?: string, openFunc?: FileOpener): FileMeta;