@mdfriday/foundry 26.4.20 → 26.5.2

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;

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

@@ -1,13 +1,24 @@
 import { Fs as IFs } from '../type';
 import { OverlayFs } from '../entity/overlayfs';
 import { Modules } from '../../module';
+/**
+ * RootMapping represents a filesystem mount mapping
+ * TypeScript version of Go's RootMapping
+ */
 export declare class RootMapping {
     readonly from: string;
     readonly to: string;
     readonly toBase: string;
     constructor(from: string, to: string, toBase?: string);
+    /**
+     * Create a filesystem for this mapping
+     */
     fs(sourceProject: IFs): IFs;
 }
+/**
+ * FilesystemsCollector value object
+ * TypeScript version of Go's FilesystemsCollector
+ */
 export declare class FilesystemsCollector {
     readonly sourceProject: IFs;
     overlayMountsPrompt: OverlayFs;
@@ -18,6 +29,9 @@ export declare class FilesystemsCollector {
     overlayMountsAssets: OverlayFs;
     overlayMountsI18n: OverlayFs;
     constructor(sourceProject: IFs);
+    /**
+     * Collect filesystem mounts from modules
+     */
     collect(mods: Modules): Promise<void>;
     private isPrompts;
     private isWorkflows;
@@ -28,4 +42,7 @@ export declare class FilesystemsCollector {
     private isI18n;
     private absPathify;
 }
+/**
+ * Create new FilesystemsCollector
+ */
 export declare function newFilesystemsCollector(sourceProject: IFs): FilesystemsCollector;

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

@@ -1,3 +1,11 @@
 import { FileInfo } from "@internal/domain/fs/vo/fileinfo";
+/**
+ * Creates a new FileInfo instance with virtual file using filename
+ * TypeScript equivalent of Go's NewFileInfoWithName
+ */
 export declare function newFileInfoWithName(filename: string): FileInfo;
+/**
+ * Creates a new FileInfo instance with virtual file using content
+ * TypeScript equivalent of Go's NewFileInfoWithContent
+ */
 export declare function newFileInfoWithContent(content: string): FileInfo;

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

@@ -1,5 +1,8 @@
 import { Stats } from 'fs';
 import { File, FileInfo, Fs } from '../type';
+/**
+ * OsFileInfo implements FileInfo for Node.js fs.Stats
+ */
 export declare class OsFileInfo implements FileInfo {
     private stats;
     private _name;
@@ -11,6 +14,9 @@ export declare class OsFileInfo implements FileInfo {
     isDir(): boolean;
     sys(): any;
 }
+/**
+ * OsFile implements File for Node.js file handles
+ */
 export declare class OsFile implements File {
     private filePath;
     private flags;
@@ -47,6 +53,9 @@ export declare class OsFile implements File {
         bytesWritten: number;
     }>;
 }
+/**
+ * OsFs implements Fs for Node.js file system operations
+ */
 export declare class OsFs implements Fs {
     create(name: string): Promise<File>;
     mkdir(name: string, perm: number): Promise<void>;
@@ -62,4 +71,7 @@ export declare class OsFs implements Fs {
     chown(name: string, uid: number, gid: number): Promise<void>;
     chtimes(name: string, atime: Date, mtime: Date): Promise<void>;
 }
+/**
+ * Create a new OsFs instance
+ */
 export declare function newOsFs(): OsFs;

package/dist/types/internal/domain/fs/vo/overlay-factory.d.ts

@@ -2,6 +2,10 @@ import { OriginFs } from '../entity/originfs';
 import { FilesystemsCollector } from '@internal/domain/fs';
 import { Modules } from '../../module';
 export declare function createMainOverlayFs(ofs: OriginFs, mods: Modules): Promise<FilesystemsCollector>;
+/**
+ * Create OriginFs from workspace
+ * TypeScript version of Go's NewOriginFs function
+ */
 export declare function createOriginFs(workspace: {
     path: string;
     publish: string;

package/dist/types/internal/domain/fs/vo/overlayfs-factory.d.ts

@@ -1,5 +1,8 @@
 import { Fs, OverlayFsOptions, DirsMerger } from '../type';
 import { OverlayFs } from '../entity/overlayfs';
+/**
+ * OverlayFs factory interface
+ */
 export interface OverlayFsFactory {
     create(fss: Fs[]): OverlayFs;
     createWithOptions(options: OverlayFsOptions): OverlayFs;
@@ -7,23 +10,62 @@ export interface OverlayFsFactory {
     createWritable(fss: Fs[]): OverlayFs;
     createWithMerger(fss: Fs[], merger: DirsMerger): OverlayFs;
 }
+/**
+ * OverlayFs factory implementation
+ */
 export declare class Factory implements OverlayFsFactory {
+    /**
+     * Create overlay filesystem with default settings
+     */
     create(fss: Fs[]): OverlayFs;
+    /**
+     * Create overlay filesystem with custom options
+     */
     createWithOptions(options: OverlayFsOptions): OverlayFs;
+    /**
+     * Create read-only overlay filesystem
+     */
     createReadOnly(fss: Fs[]): OverlayFs;
+    /**
+     * Create writable overlay filesystem (first filesystem is writable)
+     */
     createWritable(fss: Fs[]): OverlayFs;
+    /**
+     * Create overlay filesystem with custom directory merger
+     */
     createWithMerger(fss: Fs[], merger: DirsMerger): OverlayFs;
 }
+/**
+ * Create new OverlayFs factory
+ */
 export declare function newOverlayFsFactory(): Factory;
+/**
+ * Convenience function to create overlay filesystem
+ */
 export declare function createOverlayFileSystem(fss: Fs[], options?: {
     firstWritable?: boolean;
     dirsMerger?: DirsMerger;
 }): OverlayFs;
+/**
+ * Create read-only overlay filesystem (convenience function)
+ */
 export declare function createReadOnlyOverlayFs(fss: Fs[]): OverlayFs;
+/**
+ * Create writable overlay filesystem (convenience function)
+ */
 export declare function createWritableOverlayFs(fss: Fs[], dirsMerger?: DirsMerger): OverlayFs;
+/**
+ * Append filesystems to existing overlay (convenience function)
+ */
 export declare function appendToOverlayFs(overlayFs: OverlayFs, ...fss: Fs[]): OverlayFs;
+/**
+ * Create overlay filesystem from array of filesystem pairs
+ */
 export declare function createOverlayFromPairs(pairs: Array<{
     fs: Fs;
     priority: number;
 }>): OverlayFs;
+/**
+ * Create multilayer overlay filesystem
+ */
 export declare function createMultilayerOverlayFs(readOnlyLayers: Fs[], writableLayer?: Fs, dirsMerger?: DirsMerger): OverlayFs;

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

@@ -1,5 +1,13 @@
 import { Fs, DirsMerger, OverlayFsOptions } from '../type';
+/**
+ * Default directory merger implementation
+ * TypeScript version of Go's defaultDirMerger
+ */
 export declare const defaultDirMerger: DirsMerger;
+/**
+ * OverlayFs options value object
+ * TypeScript version of Go's Options struct
+ */
 export declare class OverlayOptions implements OverlayFsOptions {
     readonly fss: Fs[];
     readonly firstWritable: boolean;
@@ -9,16 +17,52 @@ export declare class OverlayOptions implements OverlayFsOptions {
         firstWritable?: boolean;
         dirsMerger?: DirsMerger;
     });
+    /**
+     * Create new options with additional filesystems
+     */
     withFilesystems(...additionalFss: Fs[]): OverlayOptions;
+    /**
+     * Create new options with different writability
+     */
     withFirstWritable(writable: boolean): OverlayOptions;
+    /**
+     * Create new options with different directory merger
+     */
     withDirsMerger(merger: DirsMerger): OverlayOptions;
+    /**
+     * Get writable filesystem (first if firstWritable is true)
+     */
     getWritableFs(): Fs | null;
+    /**
+     * Validate options
+     */
     isValid(): boolean;
+    /**
+     * Get filesystem count
+     */
     getFilesystemCount(): number;
+    /**
+     * Get filesystem by index
+     */
     getFilesystem(index: number): Fs | null;
+    /**
+     * Check if filesystem exists in overlay
+     */
     hasFilesystem(fs: Fs): boolean;
+    /**
+     * Get all filesystems as readonly array
+     */
     getFilesystems(): readonly Fs[];
 }
+/**
+ * Factory function to create OverlayOptions
+ */
 export declare function newOverlayOptions(fss: Fs[], firstWritable?: boolean, dirsMerger?: DirsMerger): OverlayOptions;
+/**
+ * Create overlay options with default settings
+ */
 export declare function createDefaultOverlayOptions(fss: Fs[]): OverlayOptions;
+/**
+ * Create overlay options for read-write scenario
+ */
 export declare function createWritableOverlayOptions(fss: Fs[], dirsMerger?: DirsMerger): OverlayOptions;

package/dist/types/internal/domain/fs/vo/static-copier.d.ts

@@ -4,11 +4,33 @@ export declare class StaticCopier {
     private readonly toFs;
     constructor(froms: IFs[], to: IFs);
     copy(): Promise<void>;
+    /**
+     * Execute function with publish directories
+     */
     private doWithPublishDirs;
+    /**
+     * Copy static files from source to target directory
+     * TypeScript equivalent of Go's copyStaticTo
+     */
     private copyStaticTo;
+    /**
+     * Walk source files and copy them
+     */
     private walkSourceFiles;
+    /**
+     * Walk filesystem recursively
+     */
     private walkFileSystem;
+    /**
+     * Copy a single file from source to target
+     */
     private copyFile;
+    /**
+     * Join path components
+     */
     private joinPath;
+    /**
+     * Get directory name from path
+     */
     private dirname;
 }

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

@@ -1,4 +1,8 @@
 import { Fs, WalkCallback, WalkwayConfig } from '../type';
+/**
+ * Walkway represents a filesystem walker
+ * TypeScript version of Go's Walkway struct
+ */
 export declare class Walkway {
     private fs;
     private root;
@@ -6,10 +10,28 @@ export declare class Walkway {
     private cfg;
     private walked;
     constructor(fs: Fs, cb: WalkCallback);
+    /**
+     * WalkWith performs walk with specified root and configuration
+     */
     walkWith(root: string, cfg: WalkwayConfig): Promise<void>;
+    /**
+     * Walk performs the filesystem walk
+     */
     walk(): Promise<void>;
+    /**
+     * Check if error should be handled gracefully
+     */
     private checkErr;
+    /**
+     * Check if error is a "not exist" error
+     */
     private isNotExistError;
+    /**
+     * Walk recursively descends path, calling walkFn
+     */
     private walkRecursive;
 }
+/**
+ * Creates a new Walkway instance
+ */
 export declare function newWalkway(fs: Fs, cb: WalkCallback): Walkway;

package/dist/types/internal/domain/identity/entity/user.d.ts

@@ -3,53 +3,153 @@ import { Token } from '../value-object/token';
 import { ServerConfig } from '../value-object/server-config';
 import { License } from '../value-object/license';
 import { SyncConfig } from '../value-object/sync-config';
+/**
+ * User Status - 用户状态信息
+ *
+ * 包含认证、许可证和同步配置的完整状态
+ */
 export interface UserStatus {
+    /** 是否已认证 */
     isAuthenticated: boolean;
+    /** 用户邮箱 */
     email: string;
+    /** 服务器 URL */
     serverUrl: string;
+    /** Token 是否过期 */
     tokenExpired: boolean;
+    /** 是否有 Token */
     hasToken: boolean;
+    /** 是否有 License */
     hasLicense: boolean;
+    /** License Key */
     license?: string | undefined;
+    /** License 是否有效 */
     licenseValid: boolean;
+    /** 是否为试用账号 */
     isTrial: boolean;
+    /** License 计划类型 */
     licensePlan?: string | undefined;
+    /** License 过期时间（格式化） */
     licenseExpires?: string | undefined;
+    /** License 剩余天数 */
     licenseDaysRemaining?: number | undefined;
+    /** 是否有 Sync 配置 */
     hasSyncConfig: boolean;
+    /** Sync 配置信息 */
     syncConfig?: {
+        /** 数据库端点 */
         dbEndpoint: string;
+        /** 数据库名称 */
         dbName: string;
+        /** 邮箱 */
         email: string;
+        /** 用户目录 */
         userDir: string;
+        /** Sync 状态 */
         status: string;
+        /** Sync 是否激活 */
         isActive: boolean;
     } | undefined;
 }
+/**
+ * User Entity (Aggregate Root)
+ *
+ * 用户聚合根，管理用户认证信息和 License
+ *
+ * 职责：
+ * - 管理用户身份信息（email）
+ * - 管理认证令牌（token）
+ * - 管理服务器配置（serverConfig）
+ * - 管理用户 License（license）
+ * - 管理同步配置（syncConfig）
+ * - 提供认证状态查询
+ */
 export declare class User {
     private readonly email;
     private token;
     private serverConfig;
     private license;
     private syncConfig;
+    /**
+     * 构造函数（私有，通过 Factory 创建）
+     */
     constructor(email: Email, token: Token | null, serverConfig: ServerConfig, license?: License | null, syncConfig?: SyncConfig | null);
+    /**
+     * 获取用户邮箱
+     */
     getEmail(): Email;
+    /**
+     * 获取认证令牌
+     */
     getToken(): Token | null;
+    /**
+     * 获取服务器配置
+     */
     getServerConfig(): ServerConfig;
+    /**
+     * 获取 License
+     */
     getLicense(): License | null;
+    /**
+     * 获取同步配置
+     */
     getSyncConfig(): SyncConfig | null;
+    /**
+     * 设置认证令牌（登录成功后）
+     */
     setToken(token: Token): void;
+    /**
+     * 清除认证令牌（登出）
+     */
     clearToken(): void;
+    /**
+     * 更新服务器配置
+     */
     updateServerConfig(config: ServerConfig): void;
+    /**
+     * 设置 License
+     */
     setLicense(license: License): void;
+    /**
+     * 清除 License
+     */
     clearLicense(): void;
+    /**
+     * 设置同步配置
+     */
     setSyncConfig(syncConfig: SyncConfig): void;
+    /**
+     * 清除同步配置
+     */
     clearSyncConfig(): void;
+    /**
+     * 检查是否已认证
+     */
     isAuthenticated(): boolean;
+    /**
+     * 检查令牌是否已过期
+     */
     isTokenExpired(): boolean;
+    /**
+     * 检查 License 是否有效
+     */
     hasValidLicense(): boolean;
+    /**
+     * 检查是否是试用账户
+     */
     isTrialAccount(): boolean;
+    /**
+     * 获取认证状态信息
+     */
+    /**
+     * 获取用户状态
+     *
+     * @returns 完整的用户状态信息，包括认证、License 和 Sync 配置
+     */
     getStatus(): UserStatus;
+    /**
+     * 序列化为 JSON（用于持久化）
+     */
     toJSON(): {
         email: string;
         token: {