@mdfriday/foundry 25.11.12 → 25.11.14

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

@@ -1,10 +1,6 @@
 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;
@@ -15,108 +11,35 @@ 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;
-//# sourceMappingURL=module.d.ts.map

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

@@ -4,60 +4,20 @@ 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[];
-//# sourceMappingURL=mount.d.ts.map

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

@@ -1,7 +1,3 @@
-/**
- * Theme information from themes.json
- * Represents a single theme available for download
- */
 export interface ThemeInfo {
     id: number;
     name: string;
@@ -13,52 +9,17 @@ 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[];
 }
-//# sourceMappingURL=themes.d.ts.map

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

@@ -1,57 +1,25 @@
 import { ZipExtractor } from '../type';
-import { Fs } from '../../../domain/fs';
-/**
- * ZIP extractor implementation using JSZip
- * Note: In a real implementation, you would use a library like JSZip or node-stream-zip
- */
+import { Fs } from '@internal/domain/fs';
 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;
-//# sourceMappingURL=zipextractor.d.ts.map

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

@@ -1,9 +1,5 @@
 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?;
@@ -49,38 +45,13 @@ 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;
 }
-//# sourceMappingURL=path.d.ts.map

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

@@ -1,140 +1,57 @@
 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;
 }
-//# sourceMappingURL=pathfactory.d.ts.map

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

@@ -41,4 +41,3 @@ export declare const PathDomain: {
         replaceSpaces?: boolean;
     }) => BasicPathNormalizer;
 };
-//# sourceMappingURL=index.d.ts.map