@mdfriday/foundry 25.11.12 → 25.11.14

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

@@ -1,69 +1,23 @@
 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;
-//# sourceMappingURL=filemeta.d.ts.map

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

@@ -1,24 +1,13 @@
 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;
@@ -29,9 +18,6 @@ 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;
@@ -42,8 +28,4 @@ export declare class FilesystemsCollector {
     private isI18n;
     private absPathify;
 }
-/**
- * Create new FilesystemsCollector
- */
 export declare function newFilesystemsCollector(sourceProject: IFs): FilesystemsCollector;
-//# sourceMappingURL=filesystemscollector.d.ts.map

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

@@ -1,12 +1,3 @@
-import { FileInfo } from "../../../domain/fs/vo/fileinfo";
-/**
- * Creates a new FileInfo instance with virtual file using filename
- * TypeScript equivalent of Go's NewFileInfoWithName
- */
+import { FileInfo } from "@internal/domain/fs/vo/fileinfo";
 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;
-//# sourceMappingURL=filevitural.d.ts.map

package/dist/internal/domain/fs/vo/incremental-file-collector.d.ts

@@ -1,3 +1,2 @@
 import { FileMetaInfo, Fs } from '../type';
 export declare function collectFileMetaInfos(paths: string[], fss: Fs[]): Promise<Map<string, FileMetaInfo>>;
-//# sourceMappingURL=incremental-file-collector.d.ts.map

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

@@ -1,8 +1,5 @@
 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;
@@ -14,9 +11,6 @@ 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;
@@ -53,9 +47,6 @@ 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>;
@@ -71,8 +62,4 @@ 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;
-//# sourceMappingURL=osfs.d.ts.map

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

@@ -1,14 +1,9 @@
 import { OriginFs } from '../entity/originfs';
-import { FilesystemsCollector } from '../../../domain/fs';
+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;
     osFs: any;
 }, mods: Modules): OriginFs;
-//# sourceMappingURL=overlay-factory.d.ts.map

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

@@ -1,8 +1,5 @@
 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;
@@ -10,63 +7,23 @@ 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;
-//# sourceMappingURL=overlayfs-factory.d.ts.map

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

@@ -1,13 +1,5 @@
 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;
@@ -17,53 +9,16 @@ 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;
-//# sourceMappingURL=overlayoptions.d.ts.map

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

@@ -4,34 +4,11 @@ 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;
 }
-//# sourceMappingURL=static-copier.d.ts.map

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

@@ -1,8 +1,4 @@
 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;
@@ -10,29 +6,10 @@ 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;
-//# sourceMappingURL=walkway.d.ts.map

package/dist/internal/domain/markdown/entity/markdown.d.ts

@@ -1,8 +1,4 @@
 import { ContentResult, DocumentContext, Highlighter, Markdown, MarkdownRenderer, ParseAndRenderOptions, ParsedContentResult, RenderableDocument, RenderContext, Result } from '../type';
-/**
- * MarkdownImpl implements the main Markdown interface
- * This is the TypeScript equivalent of the Go entity.Markdown
- */
 export declare class MarkdownImpl implements Markdown {
     private renderer;
     private highlighter;
@@ -13,46 +9,14 @@ export declare class MarkdownImpl implements Markdown {
     renderCodeblock(cctx: any, w: import('../type').FlexiWriter, ctx: import('../type').CodeblockContext): Promise<void>;
     isDefaultCodeBlockRenderer(): boolean;
     prepareRender(source: Uint8Array): Promise<RenderableDocument>;
-    /**
-     * Parse and render content in one step - simplified interface for external use
-     * This method hides implementation details and provides a clean interface
-     */
     parseAndRenderContent(source: Uint8Array, options?: ParseAndRenderOptions): Promise<ContentResult>;
-    /**
-     * Parse markdown source with front matter and shortcodes
-     */
     parseContent(source: Uint8Array): Promise<ParsedContentResult>;
-    /**
-     * Parse front matter from item
-     */
     private parseFrontMatter;
-    /**
-     * Simple YAML parser (basic implementation)
-     */
     private parseYAML;
-    /**
-     * Simple TOML parser using smol-toml library
-     */
     private parseTOML;
-    /**
-     * Simple JSON parser
-     */
     private parseJSON;
-    /**
-     * Simple Org mode parser (basic implementation)
-     */
     private parseOrg;
-    /**
-     * Parse value (string, number, boolean, array)
-     */
     private parseValue;
-    /**
-     * Parse markdown source into tokens and create parsing result
-     */
     private parse;
-    /**
-     * Render the parsed result to bytes
-     */
     private renderToBytes;
 }
-//# sourceMappingURL=markdown.d.ts.map

package/dist/internal/domain/markdown/factory/markdown.d.ts

@@ -1,3 +1,2 @@
 import { Markdown, MarkdownRenderer } from '../type';
 export declare function createMarkdown(renderer: MarkdownRenderer): Markdown;
-//# sourceMappingURL=markdown.d.ts.map

package/dist/internal/domain/markdown/index.d.ts

@@ -9,4 +9,3 @@ export * from './vo/shortcode';
 export * from './vo/content';
 export * from './entity/markdown';
 export * from './factory/markdown';
-//# sourceMappingURL=index.d.ts.map