@mdfriday/foundry 26.4.20 → 26.5.1

package/dist/types/internal/domain/module/vo/module.d.ts

@@ -1,6 +1,10 @@
 import { Module as IModule, Mount as IMount, Import, ModuleMetadata, Info } from '../type';
 import { Fs } from '../../fs/type';
 import { Mount } from './mount';
+/**
+ * Module value object representing a downloaded module
+ * TypeScript version of Go's Module struct
+ */
 export declare class Module implements IModule {
     private fs;
     private absoluteDir;
@@ -11,35 +15,107 @@ export declare class Module implements IModule {
     private isProject;
     constructor(fs: Fs, absoluteDir: string, modulePath: string, parent?: Module | null, isProject?: boolean);
     isProjectModule(): boolean;
+    /**
+     * Get module owner (parent)
+     */
     owner(): Module | null;
+    /**
+     * Get module mounts
+     */
     mounts(): IMount[];
+    /**
+     * Get module directory
+     */
     dir(): string;
+    /**
+     * Get module path
+     */
     path(): string;
+    /**
+     * Set module metadata
+     */
     setMetadata(metadata: ModuleMetadata): void;
+    /**
+     * Get module metadata
+     */
     getMetadata(): ModuleMetadata | null;
+    /**
+     * Apply mounts from import configuration
+     */
     applyMounts(moduleImport: Import): Promise<void>;
+    /**
+     * Add a mount
+     */
     appendMount(mount: Mount): void;
+    /**
+     * Remove a mount
+     */
     removeMount(mount: Mount): boolean;
+    /**
+     * Get mount by target path
+     */
     getMountByTarget(targetPath: string): Mount | null;
+    /**
+     * Get mounts by component
+     */
     getMountsByComponent(component: string): Mount[];
+    /**
+     * Check if module is downloaded
+     */
     isDownloaded(): boolean;
+    /**
+     * Check if module is being downloaded
+     */
     isDownloading(): boolean;
+    /**
+     * Check if module download failed
+     */
     isDownloadFailed(): boolean;
+    /**
+     * Check if directory exists
+     */
     exists(): Promise<boolean>;
+    /**
+     * Create a copy of this module
+     */
     copy(): Module;
+    /**
+     * String representation
+     */
     toString(): string;
 }
+/**
+ * Project module - special module representing the main project
+ */
 export declare class ProjectModule {
     private module;
     constructor(module: Module);
+    /**
+     * Get the underlying module
+     */
     getModule(): Module;
+    /**
+     * Append mount to project module
+     */
     appendMount(mount: Mount): void;
     setDefaultLanguage(lang: string): void;
+    /**
+     * Apply default project mounts
+     */
     applyDefaultMounts(): void;
+    /**
+     * Delegate methods to underlying module
+     */
     owner(): Module | null;
     mounts(): IMount[];
     dir(): string;
     path(): string;
 }
+/**
+ * Creates a new Module instance
+ */
 export declare function newModule(fs: Fs, absoluteDir: string, modulePath: string, parent?: Module): Module;
+/**
+ * Creates a new ProjectModule instance
+ */
 export declare function newProjectModule(info: Info): ProjectModule;

package/dist/types/internal/domain/module/vo/mount.d.ts

@@ -4,20 +4,59 @@ export declare class Mount implements IMount {
     private targetPath;
     private language;
     constructor(sourcePath: string, targetPath: string, language?: string);
+    /**
+     * Get source path
+     */
     source(): string;
+    /**
+     * Get target path
+     */
     target(): string;
+    /**
+     * Get language
+     */
     lang(): string;
+    /**
+     * Set language
+     */
     setLanguage(lang: string): void;
+    /**
+     * Get component name from target path
+     */
     component(): string;
+    /**
+     * Get component and name from target path
+     */
     componentAndName(): {
         component: string;
         name: string;
     };
+    /**
+     * Create a copy of this mount
+     */
     copy(): Mount;
+    /**
+     * Check if this mount is equal to another
+     */
     equals(other: Mount): boolean;
+    /**
+     * Convert to plain object
+     */
     toConfig(): MountConfig;
+    /**
+     * String representation
+     */
     toString(): string;
 }
+/**
+ * Creates a new Mount instance
+ */
 export declare function newMount(sourcePath: string, targetPath: string): Mount;
+/**
+ * Creates a Mount from config
+ */
 export declare function newMountFromConfig(config: MountConfig): Mount;
+/**
+ * Creates default component mounts
+ */
 export declare function createDefaultMounts(componentFolders: readonly string[]): Mount[];

package/dist/types/internal/domain/module/vo/themes.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Theme information from themes.json
+ * Represents a single theme available for download
+ */
 export interface ThemeInfo {
     id: number;
     name: string;
@@ -9,17 +13,51 @@ export interface ThemeInfo {
     demo_notes_url: string;
     tags: string[];
 }
+/**
+ * Collection of themes from themes.json
+ */
 export interface ThemesCollection {
     themes: ThemeInfo[];
 }
+/**
+ * Themes Value Object
+ * Provides functionality to work with themes data from themes.json
+ */
 export declare class Themes {
     private themes;
     constructor(themes: ThemeInfo[]);
+    /**
+     * Create Themes instance from JSON data
+     */
     static fromJson(json: ThemeInfo[]): Themes;
+    /**
+     * Find theme by matching the base URL (without version parameter)
+     * @param targetUrl - The URL to match (e.g., "https://gohugo.net/base.zip?version=latest")
+     * @returns The matching theme info or null if not found
+     */
     findThemeByUrl(targetUrl: string): ThemeInfo | null;
+    /**
+     * Get the latest download URL for a given import path
+     * @param importPath - The import path with version=latest
+     * @returns The updated import path with the actual latest version, or the original path if not found
+     */
     resolveLatestVersion(importPath: string): string;
+    /**
+     * Extract base URL without version parameter
+     * @param url - Full URL with potential version parameter
+     * @returns Base URL without version parameter
+     */
     private extractBaseUrl;
+    /**
+     * Get all available themes
+     */
     getAllThemes(): ThemeInfo[];
+    /**
+     * Get theme by name
+     */
     getThemeByName(name: string): ThemeInfo | null;
+    /**
+     * Get themes by tag
+     */
     getThemesByTag(tag: string): ThemeInfo[];
 }

package/dist/types/internal/domain/module/vo/zipextractor.d.ts

@@ -1,25 +1,56 @@
 import { ZipExtractor } from '../type';
 import { Fs } from '@internal/domain/fs';
+/**
+ * ZIP extractor implementation using JSZip
+ * Note: In a real implementation, you would use a library like JSZip or node-stream-zip
+ */
 export declare class JsZipExtractor implements ZipExtractor {
     private fs;
     constructor(fs: Fs);
+    /**
+     * Extract ZIP file to target directory
+     */
     extract(zipPath: string, targetDir: string): Promise<void>;
+    /**
+     * List contents of ZIP file
+     */
     list(zipPath: string): Promise<string[]>;
+    /**
+     * Real implementation of ZIP extraction using JSZip
+     */
     private extractZipData;
+    /**
+     * Extract a single ZIP entry (file or directory)
+     */
     private extractSingleEntry;
+    /**
+     * Real implementation of ZIP content listing using JSZip
+     */
     private listZipContents;
 }
+/**
+ * Browser-compatible ZIP extractor using Web APIs
+ */
 export declare class WebZipExtractor implements ZipExtractor {
     private fs;
     constructor(fs: Fs);
     extract(zipPath: string, targetDir: string): Promise<void>;
     list(zipPath: string): Promise<string[]>;
 }
+/**
+ * Mock ZIP extractor for testing
+ */
 export declare class MockZipExtractor implements ZipExtractor {
     private mockContents;
     setMockContents(zipPath: string, contents: string[]): void;
     extract(zipPath: string, targetDir: string): Promise<void>;
     list(zipPath: string): Promise<string[]>;
 }
+/**
+ * Factory function to create appropriate ZIP extractor
+ */
 export declare function newZipExtractor(fs: Fs, environment?: 'node' | 'browser'): ZipExtractor;
+/**
+ * Creates a mock ZIP extractor for testing
+ */
 export declare function newMockZipExtractor(): MockZipExtractor;

package/dist/types/internal/domain/paths/entity/path.d.ts

@@ -1,5 +1,9 @@
 import { Path as IPath, PathType } from '../type';
 import { PathComponentsImpl } from '../vo/pathcomponents';
+/**
+ * Path entity implementation
+ * Represents a parsed path with all its components and operations
+ */
 export declare class Path implements IPath {
     private readonly components;
     private _unnormalized?;
@@ -46,13 +50,37 @@ export declare class Path implements IPath {
     private identifierIndex;
     private escapeRegExp;
     toString(): string;
+    /**
+     * Check if two paths are equal
+     */
     equals(other: IPath): boolean;
+    /**
+     * Get a hash code for this path
+     */
     hashCode(): string;
 }
+/**
+ * Utility functions for working with Path instances
+ */
 export declare class PathUtils {
+    /**
+     * Create a path from string components
+     */
     static fromString(component: string, path: string): Path;
+    /**
+     * Check if a path has a specific extension
+     */
     static hasExtension(path: IPath, extension: string): boolean;
+    /**
+     * Check if child path is under parent path
+     */
     static isUnder(child: IPath, parent: IPath): boolean;
+    /**
+     * Get the relative path from one path to another
+     */
     static relativeTo(from: IPath, to: IPath): string;
+    /**
+     * Compare two paths for sorting
+     */
     static compare(a: IPath, b: IPath): number;
 }

package/dist/types/internal/domain/paths/factory/pathfactory.d.ts

@@ -1,57 +1,139 @@
 import { PathFactory, PathParserConfig, PathPool, Path as IPath, PathComponents } from '../type';
+/**
+ * PathFactoryImpl implements the PathFactory interface
+ * Provides methods for creating Path instances
+ */
 export declare class PathFactoryImpl implements PathFactory {
     private processor;
     private pool?;
     constructor(config?: PathParserConfig, pool?: PathPool);
+    /**
+     * Create a Path from component and path string
+     */
     create(component: string, path: string, config?: PathParserConfig): IPath;
+    /**
+     * Create a Path from PathComponents
+     */
     createFromComponents(components: PathComponents): IPath;
+    /**
+     * Create multiple paths from an array of path strings
+     */
     createMany(component: string, paths: string[], config?: PathParserConfig): IPath[];
+    /**
+     * Create a path with custom configuration
+     */
     createWithConfig(component: string, path: string, normalizeConfig?: {
         toLowerCase?: boolean;
         replaceSpaces?: boolean;
         customNormalizer?: (path: string) => string;
     }): IPath;
 }
+/**
+ * DefaultPathFactory provides a default configured path factory
+ */
 export declare class DefaultPathFactory extends PathFactoryImpl {
     constructor();
 }
+/**
+ * SimplePathPool implements PathPool interface for basic object pooling
+ */
 export declare class SimplePathPool implements PathPool {
     private pool;
     private maxSize;
     constructor(maxSize?: number);
     get(): IPath;
     put(path: IPath): void;
+    /**
+     * Clear all paths from the pool
+     */
     clear(): void;
+    /**
+     * Get current pool size
+     */
     size(): number;
 }
+/**
+ * PathBuilder provides a fluent interface for building paths
+ */
 export declare class PathBuilder {
     private component;
     private path;
     private config;
     private factory;
     constructor(factory?: PathFactory);
+    /**
+     * Set the component
+     */
     withComponent(component: string): PathBuilder;
+    /**
+     * Set the path
+     */
     withPath(path: string): PathBuilder;
+    /**
+     * Enable/disable normalization
+     */
     withNormalization(normalize: boolean): PathBuilder;
+    /**
+     * Enable/disable space replacement
+     */
     withSpaceReplacement(replaceSpaces: boolean): PathBuilder;
+    /**
+     * Set custom normalizer
+     */
     withNormalizer(normalizer: (path: string) => string): PathBuilder;
+    /**
+     * Build the path
+     */
     build(): IPath;
+    /**
+     * Reset builder to initial state
+     */
     reset(): PathBuilder;
 }
+/**
+ * Static factory methods for common path creation scenarios
+ */
 export declare class PathFactoryUtils {
     private static defaultFactory;
+    /**
+     * Create a content path
+     */
     static createContentPath(path: string): IPath;
+    /**
+     * Create a static resource path
+     */
     static createStaticPath(path: string): IPath;
+    /**
+     * Create a layout path
+     */
     static createLayoutPath(path: string): IPath;
+    /**
+     * Create an archetype path
+     */
     static createArchetypePath(path: string): IPath;
+    /**
+     * Create a data path
+     */
     static createDataPath(path: string): IPath;
+    /**
+     * Create a theme path
+     */
     static createThemePath(path: string): IPath;
+    /**
+     * Create paths from a configuration object
+     */
     static createFromConfig(config: {
         component: string;
         paths: string[];
         normalize?: boolean;
         replaceSpaces?: boolean;
     }): IPath[];
+    /**
+     * Get a path builder instance
+     */
     static builder(): PathBuilder;
+    /**
+     * Create a path with pooling
+     */
     static createWithPool(component: string, path: string, pool: PathPool): IPath;
 }