@mdfriday/foundry 26.3.8 → 26.3.9

package/dist/internal/application/container.d.ts

@@ -0,0 +1,9 @@
+import { WorkspaceFactory } from '@internal/domain/workspace';
+import { WorkspaceAppService } from '@internal/application/workspace';
+import { HttpClient as IdentityHttpClient } from '@internal/domain/identity';
+import { IdentityAppService } from '@internal/application/identity';
+export declare function createWorkspaceFactory(): WorkspaceFactory;
+export declare function createWorkspaceAppService(): WorkspaceAppService;
+export declare function createIdentityService(workspacePath?: string): Promise<IdentityAppService>;
+export declare function createIdentityServiceForObsidian(workspacePath: string, httpClient: IdentityHttpClient): Promise<IdentityAppService>;
+export declare function createPublishAppService(): any;

package/dist/internal/application/index.d.ts

@@ -0,0 +1,4 @@
+export { WorkspaceAppService } from './workspace';
+export { PublishAppService } from './publish';
+export { IdentityAppService } from './identity';
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createPublishAppService, } from './container';

package/dist/internal/application/publish.d.ts

@@ -1,11 +1,6 @@
-import { PublisherFactory } from '@internal/domain/publish';
+import { PublisherFactory, AnyPublishConfig } from '@internal/domain/publish';
 import { WorkspaceAppService } from './workspace';
-import { Project } from '@internal/domain/workspace';
-export interface PublishOptions {
-    force?: boolean;
-    incremental?: boolean;
-    config?: any;
-}
+import { Workspace, Project } from '@internal/domain/workspace';
 export type PublishProgressCallback = (progress: {
     phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
     percentage: number;
@@ -19,10 +14,14 @@ export declare class PublishAppService {
     private publisherFactory;
     private workspaceService;
     constructor(publisherFactory: PublisherFactory, workspaceService: WorkspaceAppService);
-    publish(project: Project, method: 'ftp' | 'netlify' | 'mdfriday', options?: PublishOptions, onProgress?: PublishProgressCallback): Promise<any>;
-    testConnection(project: Project, method: 'ftp' | 'netlify' | 'mdfriday'): Promise<{
+    publish(project: Project, config: AnyPublishConfig, options?: {
+        force?: boolean;
+        incremental?: boolean;
+    }, onProgress?: PublishProgressCallback): Promise<any>;
+    testConnection(project: Project, config: AnyPublishConfig): Promise<{
         success: boolean;
         error?: string;
     }>;
+    prepareFinalConfig(workspace: Workspace, project: Project, method: 'ftp' | 'netlify' | 'mdfriday'): Promise<AnyPublishConfig>;
     private getMethodConfig;
 }

package/dist/internal/interfaces/cli/commands/publish.d.ts

@@ -5,16 +5,6 @@ export interface PublishOptions {
     project?: string;
     force?: boolean;
     verbose?: boolean;
-    host?: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    remotePath?: string;
-    secure?: boolean;
-    siteId?: string;
-    token?: string;
-    type?: 'share' | 'sub' | 'custom' | 'enterprise';
-    licenseKey?: string;
 }
 export declare class PublishCommand implements Command {
     private publishService;
@@ -23,5 +13,5 @@ export declare class PublishCommand implements Command {
     description: string;
     constructor(publishService: PublishAppService, workspaceAppService: WorkspaceAppService);
     execute(args: string[], options: PublishOptions): Promise<CommandResult>;
-    private parseConfigOverride;
+    private executeTest;
 }

package/dist/internal/interfaces/cli/container.d.ts

@@ -1,7 +1 @@
-import { WorkspaceFactory } from '@internal/domain/workspace';
-import { WorkspaceAppService } from '@internal/application/workspace';
-import { IdentityAppService } from '@internal/application/identity';
-export declare function createWorkspaceFactory(): WorkspaceFactory;
-export declare function createWorkspaceAppService(): WorkspaceAppService;
-export declare function createIdentityService(projectPath?: string): Promise<IdentityAppService>;
-export declare function createPublishAppService(): any;
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createIdentityServiceForObsidian, createPublishAppService, } from '@internal/application/container';

package/dist/internal/interfaces/cli/types.d.ts

@@ -48,6 +48,4 @@ export interface ServeOptions {
     livereloadPort?: number;
     publish?: 'ftp' | 'netlify' | 'mdfriday';
     publishDelay?: number;
-    type?: 'share' | 'sub' | 'custom' | 'enterprise';
-    licenseKey?: string;
 }

package/dist/internal/interfaces/obsidian/auth.d.ts

@@ -1,4 +1,5 @@
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianAuthStatus {
     isAuthenticated: boolean;
     email?: string;
@@ -16,11 +17,10 @@ export interface ObsidianAuthResult<T = void> {
     error?: string;
 }
 export declare class ObsidianAuthService {
-    private httpClient;
-    constructor(httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     getStatus(): Promise<ObsidianAuthResult<ObsidianAuthStatus>>;
     getConfig(): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
     updateConfig(config: ObsidianServerConfig): Promise<ObsidianAuthResult<ObsidianServerConfig>>;
-    private getIdentityService;
 }
-export declare function createObsidianAuthService(httpClient?: HttpClient): ObsidianAuthService;
+export declare function createObsidianAuthService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianAuthService>;

package/dist/internal/interfaces/obsidian/container.d.ts

@@ -1,4 +1,4 @@
-import { WorkspaceFactory } from '@internal/domain/workspace';
-import { WorkspaceAppService } from '@internal/application/workspace';
-export declare function createWorkspaceFactory(): WorkspaceFactory;
-export declare function createWorkspaceAppService(): WorkspaceAppService;
+import { HttpClient } from "@internal/domain/identity";
+import { IdentityAppService } from "@internal/application";
+export { createWorkspaceFactory, createWorkspaceAppService, createIdentityService, createIdentityServiceForObsidian, createPublishAppService, } from '@internal/application/container';
+export declare function getIdentityService(workspacePath: string, httpClient: HttpClient): Promise<IdentityAppService>;

package/dist/internal/interfaces/obsidian/domain.d.ts

@@ -1,4 +1,5 @@
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianDomainInfo {
     subdomain: string;
     fullDomain: string;
@@ -46,14 +47,13 @@ export interface ObsidianDomainResult<T = void> {
     error?: string;
 }
 export declare class ObsidianDomainService {
-    private httpClient;
-    constructor(httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     getDomainInfo(): Promise<ObsidianDomainResult<ObsidianDomainInfo>>;
     checkSubdomain(subdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainCheckResult>>;
     updateSubdomain(newSubdomain: string): Promise<ObsidianDomainResult<ObsidianSubdomainUpdateResult>>;
     checkCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainCheckResult>>;
     addCustomDomain(domain: string): Promise<ObsidianDomainResult<ObsidianCustomDomainAddResult>>;
     checkHttpsStatus(domain: string): Promise<ObsidianDomainResult<ObsidianHttpsStatusResult>>;
-    private getIdentityService;
 }
-export declare function createObsidianDomainService(httpClient?: HttpClient): ObsidianDomainService;
+export declare function createObsidianDomainService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianDomainService>;

package/dist/internal/interfaces/obsidian/index.d.ts

@@ -8,4 +8,6 @@ export { ObsidianLicenseService, createObsidianLicenseService, ObsidianLicenseIn
 export { ObsidianAuthService, createObsidianAuthService, ObsidianAuthStatus, ObsidianServerConfig, ObsidianAuthResult, } from './auth';
 export { ObsidianDomainService, createObsidianDomainService, ObsidianDomainInfo, ObsidianSubdomainCheckResult, ObsidianSubdomainUpdateResult, ObsidianCustomDomainCheckResult, ObsidianCustomDomainAddResult, ObsidianHttpsCertificate, ObsidianHttpsStatusResult, ObsidianDomainResult, } from './domain';
 export { createWorkspaceAppService, createWorkspaceFactory, } from './container';
-export type { HttpClient, HttpResponse } from '@internal/domain/publish/repository/http-client';
+export type { HttpClient as PublishHttpClient, HttpResponse as PublishHttpResponse } from '@internal/domain/publish/repository/http-client';
+export type { HttpClient as IdentityHttpClient, HttpResponse as IdentityHttpResponse } from '@internal/domain/identity';
+export type { AnyPublishConfig, FTPConfig, NetlifyConfig, MDFridayConfig, } from '@internal/domain/publish';

package/dist/internal/interfaces/obsidian/license.d.ts

@@ -1,5 +1,5 @@
-import { WorkspaceAppService } from '@internal/application/workspace';
-import { HttpClient } from '@internal/domain/publish/repository/http-client';
+import { IdentityAppService } from '@internal/application/identity';
+import { HttpClient } from '@internal/domain/identity';
 export interface ObsidianLicenseInfo {
     key: string;
     plan: string;
@@ -60,9 +60,8 @@ export interface ObsidianLicenseResult<T = any> {
     error?: string;
 }
 export declare class ObsidianLicenseService {
-    private workspaceAppService;
-    private httpClient;
-    constructor(workspaceAppService: WorkspaceAppService, httpClient?: HttpClient);
+    private identityService;
+    constructor(identityService: IdentityAppService);
     requestTrial(email: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
     loginWithLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
     activateLicense(licenseKey: string): Promise<ObsidianLicenseResult<ObsidianLicenseInfo>>;
@@ -70,7 +69,6 @@ export declare class ObsidianLicenseService {
     getLicenseUsage(): Promise<ObsidianLicenseResult<ObsidianLicenseUsage>>;
     resetUsage(force: boolean): Promise<ObsidianLicenseResult<any>>;
     hasActiveLicense(): Promise<boolean>;
-    private getIdentityService;
     private buildLicenseInfo;
 }
-export declare function createObsidianLicenseService(httpClient?: HttpClient): ObsidianLicenseService;
+export declare function createObsidianLicenseService(workspacePath: string, httpClient: HttpClient): Promise<ObsidianLicenseService>;

package/dist/internal/interfaces/obsidian/publish.d.ts

@@ -1,13 +1,14 @@
 import { PublishAppService } from '@internal/application/publish';
 import { WorkspaceAppService } from '@internal/application/workspace';
+import { AnyPublishConfig } from '@internal/domain/publish';
 import { HttpClient } from '@internal/domain/publish/repository/http-client';
 export type ObsidianPublishMethod = 'ftp' | 'netlify' | 'mdfriday';
 export interface ObsidianPublishOptions {
     workspacePath: string;
     projectName: string;
     method: ObsidianPublishMethod;
+    config: AnyPublishConfig;
     force?: boolean;
-    config?: any;
 }
 export interface ObsidianPublishProgress {
     phase: 'scanning' | 'uploading' | 'deploying' | 'complete';
@@ -38,6 +39,6 @@ export declare class ObsidianPublishService {
     private workspaceAppService;
     constructor(publishAppService: PublishAppService, workspaceAppService: WorkspaceAppService);
     publish(options: ObsidianPublishOptions, onProgress?: (progress: ObsidianPublishProgress) => void): Promise<ObsidianPublishResult>;
-    testConnection(workspacePath: string, projectName: string, method: ObsidianPublishMethod): Promise<ObsidianTestConnectionResult>;
+    testConnection(workspacePath: string, projectName: string, config: AnyPublishConfig): Promise<ObsidianTestConnectionResult>;
 }
 export declare function createObsidianPublishService(httpClient: HttpClient): ObsidianPublishService;

package/dist/internal/interfaces/obsidian/serve.d.ts

@@ -2,6 +2,7 @@ import { WorkspaceAppService } from '@internal/application/workspace';
 import { PublishAppService } from '@internal/application/publish';
 import { HttpClient } from '@internal/domain/publish/repository/http-client';
 import { MarkdownRenderer } from '@internal/domain/markdown';
+import { AnyPublishConfig } from '@internal/domain/publish';
 export interface ObsidianServeOptions {
     workspacePath: string;
     projectName: string;
@@ -9,11 +10,10 @@ export interface ObsidianServeOptions {
     host?: string;
     livereloadPort?: number;
     livereload?: boolean;
-    publish?: 'ftp' | 'netlify' | 'mdfriday';
-    publishDelay?: number;
     publishConfig?: {
-        type?: string;
-        licenseKey?: string;
+        method: 'ftp' | 'netlify' | 'mdfriday';
+        config: AnyPublishConfig;
+        delay?: number;
     };
     markdown?: MarkdownRenderer;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdfriday/foundry",
-  "version": "26.3.8",
+  "version": "26.3.9",
   "description": "The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",