@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/src/operations.ts

@@ -4,135 +4,145 @@ import { runPipeline } from './pipeline.js';
 import { createPageScaffold } from './html/pageScaffold.js';
 import { prepareWorkspaceConfig } from './config/setup.js';
 import {
-    applySsgRouting,
-    assertNoSsgRoutes,
-    ensureSsgViewMetadataForPage,
-    generateSsgViewData
+  applySsgRouting,
+  assertNoSsgRoutes,
+  ensureSsgViewMetadataForPage,
+  generateSsgViewData,
 } from './modes/ssg/index.js';
 import path from 'node:path';
 import { FOLDERS } from './core/constants.js';
 import { pathExists, readJson, remove } from './utils/fs.js';
 
 export async function runBuild(options: FrontendCommandOptions): Promise<void> {
-    const config = await prepareWorkspaceConfig(options.workspaceRoot);
-    const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
-
-    console.info('[webstir-frontend] Running build pipeline...');
-    await runPipeline(config, 'build', { changedFile: options.changedFile, enable });
-    console.info('[webstir-frontend] Build pipeline completed.');
+  const config = await prepareWorkspaceConfig(options.workspaceRoot);
+  const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
+
+  console.info('[webstir-frontend] Running build pipeline...');
+  await runPipeline(config, 'build', {
+    changedFile: options.changedFile,
+    enable,
+    env: process.env,
+  });
+  console.info('[webstir-frontend] Build pipeline completed.');
 }
 
 export async function runPublish(options: FrontendCommandOptions): Promise<void> {
-    const config = await prepareWorkspaceConfig(options.workspaceRoot);
-    const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
-    const publishConfig = options.publishMode === 'ssg' ? applySsgPublishLayout(config) : config;
-
-    const modeLabel = options.publishMode === 'ssg' ? 'SSG publish' : 'publish';
-    console.info(`[webstir-frontend] Running ${modeLabel} pipeline...`);
-
-    if (options.publishMode === 'ssg') {
-        await assertNoSsgRoutes(config.paths.workspace);
-    }
-
-    await runPipeline(publishConfig, 'publish', { enable });
-    if (options.publishMode === 'ssg') {
-        await generateSsgViewData(publishConfig);
-        await applySsgRouting(publishConfig);
-        await removeLegacyPagesFolder(publishConfig);
-    }
-    console.info(`[webstir-frontend] ${modeLabel} pipeline completed.`);
+  const config = await prepareWorkspaceConfig(options.workspaceRoot);
+  const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
+  const publishConfig = options.publishMode === 'ssg' ? applySsgPublishLayout(config) : config;
+
+  const modeLabel = options.publishMode === 'ssg' ? 'SSG publish' : 'publish';
+  console.info(`[webstir-frontend] Running ${modeLabel} pipeline...`);
+
+  if (options.publishMode === 'ssg') {
+    await assertNoSsgRoutes(config.paths.workspace);
+  }
+
+  await runPipeline(publishConfig, 'publish', { enable, env: process.env });
+  if (options.publishMode === 'ssg') {
+    await generateSsgViewData(publishConfig);
+    await applySsgRouting(publishConfig);
+    await removeLegacyPagesFolder(publishConfig);
+  }
+  console.info(`[webstir-frontend] ${modeLabel} pipeline completed.`);
 }
 
 export async function runRebuild(options: FrontendCommandOptions): Promise<void> {
-    const config = await prepareWorkspaceConfig(options.workspaceRoot);
-    const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
-
-    console.info('[webstir-frontend] Running rebuild pipeline...');
-    await runPipeline(config, 'build', { changedFile: options.changedFile, enable });
-    console.info('[webstir-frontend] Rebuild pipeline completed.');
+  const config = await prepareWorkspaceConfig(options.workspaceRoot);
+  const enable = await readWorkspaceEnableFlags(options.workspaceRoot);
+
+  console.info('[webstir-frontend] Running rebuild pipeline...');
+  await runPipeline(config, 'build', {
+    changedFile: options.changedFile,
+    enable,
+    env: process.env,
+  });
+  console.info('[webstir-frontend] Rebuild pipeline completed.');
 }
 
 export async function runAddPage(options: AddPageCommandOptions): Promise<void> {
-    const config = await prepareWorkspaceConfig(options.workspaceRoot);
-    console.info('[webstir-frontend] Creating page scaffold...');
-
-    const isSsgWorkspace = await detectSsgWorkspace(options.workspaceRoot);
-    const effectiveSsg = options.ssg ?? isSsgWorkspace;
-    await createPageScaffold({
-        workspaceRoot: options.workspaceRoot,
-        pageName: options.pageName,
-        mode: effectiveSsg ? 'ssg' : 'standard',
-        paths: {
-            pages: config.paths.src.pages,
-            app: config.paths.src.app
-        }
+  const config = await prepareWorkspaceConfig(options.workspaceRoot);
+  console.info('[webstir-frontend] Creating page scaffold...');
+
+  const isSsgWorkspace = await detectSsgWorkspace(options.workspaceRoot);
+  const effectiveSsg = options.ssg ?? isSsgWorkspace;
+  await createPageScaffold({
+    workspaceRoot: options.workspaceRoot,
+    pageName: options.pageName,
+    mode: effectiveSsg ? 'ssg' : 'standard',
+    paths: {
+      pages: config.paths.src.pages,
+      app: config.paths.src.app,
+    },
+  });
+  if (effectiveSsg) {
+    await ensureSsgViewMetadataForPage({
+      workspaceRoot: options.workspaceRoot,
+      pageName: options.pageName,
     });
-    if (effectiveSsg) {
-        await ensureSsgViewMetadataForPage({
-            workspaceRoot: options.workspaceRoot,
-            pageName: options.pageName
-        });
-    }
-    console.info('[webstir-frontend] Page scaffold created.');
+  }
+  console.info('[webstir-frontend] Page scaffold created.');
 }
 
 interface WorkspacePackageJsonMode {
-    readonly webstir?: {
-        readonly mode?: string;
-    };
+  readonly webstir?: {
+    readonly mode?: string;
+  };
 }
 
 async function detectSsgWorkspace(workspaceRoot: string): Promise<boolean> {
-    const pkgPath = path.join(workspaceRoot, 'package.json');
-    const pkg = await readJson<WorkspacePackageJsonMode>(pkgPath);
-    const mode = pkg?.webstir?.mode;
-    return typeof mode === 'string' && mode.toLowerCase() === 'ssg';
+  const pkgPath = path.join(workspaceRoot, 'package.json');
+  const pkg = await readJson<WorkspacePackageJsonMode>(pkgPath);
+  const mode = pkg?.webstir?.mode;
+  return typeof mode === 'string' && mode.toLowerCase() === 'ssg';
 }
 
-function applySsgPublishLayout(config: import('./types.js').FrontendConfig): import('./types.js').FrontendConfig {
-    const distFrontend = config.paths.dist.frontend;
-    const distPages = distFrontend;
-    const distContent = path.join(distFrontend, 'docs');
-
-    return {
-        ...config,
-        paths: {
-            ...config.paths,
-            dist: {
-                ...config.paths.dist,
-                pages: distPages,
-                content: distContent
-            }
-        }
-    };
+function applySsgPublishLayout(
+  config: import('./types.js').FrontendConfig,
+): import('./types.js').FrontendConfig {
+  const distFrontend = config.paths.dist.frontend;
+  const distPages = distFrontend;
+  const distContent = path.join(distFrontend, 'docs');
+
+  return {
+    ...config,
+    paths: {
+      ...config.paths,
+      dist: {
+        ...config.paths.dist,
+        pages: distPages,
+        content: distContent,
+      },
+    },
+  };
 }
 
 interface WorkspacePackageJsonEnable {
-    readonly webstir?: {
-        readonly enable?: EnableFlags;
-    };
+  readonly webstir?: {
+    readonly enable?: EnableFlags;
+  };
 }
 
 async function readWorkspaceEnableFlags(workspaceRoot: string): Promise<EnableFlags | undefined> {
-    const pkgPath = path.join(workspaceRoot, 'package.json');
-    const pkg = await readJson<WorkspacePackageJsonEnable>(pkgPath);
-    return pkg?.webstir?.enable;
+  const pkgPath = path.join(workspaceRoot, 'package.json');
+  const pkg = await readJson<WorkspacePackageJsonEnable>(pkgPath);
+  return pkg?.webstir?.enable;
 }
 
 async function removeLegacyPagesFolder(config: import('./types.js').FrontendConfig): Promise<void> {
-    const legacyPagesRoot = path.join(config.paths.dist.frontend, FOLDERS.pages);
-    if (legacyPagesRoot === config.paths.dist.pages) {
-        return;
-    }
+  const legacyPagesRoot = path.join(config.paths.dist.frontend, FOLDERS.pages);
+  if (legacyPagesRoot === config.paths.dist.pages) {
+    return;
+  }
 
-    if (!(await pathExists(legacyPagesRoot))) {
-        return;
-    }
+  if (!(await pathExists(legacyPagesRoot))) {
+    return;
+  }
 
-    const entries = await readdir(legacyPagesRoot);
-    if (entries.length > 0) {
-        return;
-    }
+  const entries = await readdir(legacyPagesRoot);
+  if (entries.length > 0) {
+    return;
+  }
 
-    await remove(legacyPagesRoot);
+  await remove(legacyPagesRoot);
 }

package/src/pipeline.ts

@@ -5,84 +5,96 @@ import type { Builder, BuilderContext } from './builders/types.js';
 import { createHookContext, executeHooks, loadHooks } from './hooks.js';
 
 export interface PipelineOptions {
-    readonly changedFile?: string;
-    readonly enable?: EnableFlags;
+  readonly changedFile?: string;
+  readonly enable?: EnableFlags;
+  readonly env?: Record<string, string | undefined>;
 }
 
 export type PipelineMode = 'build' | 'publish';
 
-export async function runPipeline(config: FrontendConfig, mode: PipelineMode, options: PipelineOptions = {}): Promise<void> {
-    const context: BuilderContext = { config, changedFile: options.changedFile, enable: options.enable };
-    const builders: Builder[] = createBuilders(context);
-    const hooks = await loadHooks(config.paths.workspace, mode === 'build');
-    const pipelineContext = createHookContext(config, mode, options.changedFile);
-
-    await executeHooks('pipeline.beforeAll', hooks.pipelineBefore, pipelineContext);
-
-    let pipelineError: unknown;
-
-    try {
-        for (const builder of builders) {
-            const builderContext = createHookContext(config, mode, options.changedFile, builder.name);
-            const beforeHooks = hooks.builderBefore.get(builder.name) ?? [];
-            const afterHooks = hooks.builderAfter.get(builder.name) ?? [];
-
-            await executeHooks(`builder.${builder.name}.before`, beforeHooks, builderContext);
-
-            const start = performance.now();
-            let builderError: Error | undefined;
-            let afterHookError: Error | undefined;
-
-            try {
-                if (mode === 'build') {
-                    await builder.build(context);
-                } else {
-                    await builder.publish(context);
-                }
-            } catch (error) {
-                builderError = wrapPipelineError(builder.name, mode, error);
-            }
-
-            try {
-                await executeHooks(`builder.${builder.name}.after`, afterHooks, builderContext);
-            } catch (error) {
-                afterHookError = error as Error;
-            }
-
-            const end = performance.now();
-            const duration = end - start;
-            console.info(`[webstir-frontend] ${mode}:${builder.name} completed in ${duration.toFixed(1)}ms`);
-
-            if (builderError) {
-                throw builderError;
-            }
-
-            if (afterHookError) {
-                throw afterHookError;
-            }
-        }
-    } catch (error) {
-        pipelineError = error;
-    } finally {
-        try {
-            await executeHooks('pipeline.afterAll', hooks.pipelineAfter, pipelineContext);
-        } catch (hookError) {
-            if (!pipelineError) {
-                pipelineError = hookError;
-            }
+export async function runPipeline(
+  config: FrontendConfig,
+  mode: PipelineMode,
+  options: PipelineOptions = {},
+): Promise<void> {
+  const context: BuilderContext = {
+    config,
+    changedFile: options.changedFile,
+    enable: options.enable,
+    env: options.env,
+  };
+  const builders: Builder[] = createBuilders(context);
+  const hooks = await loadHooks(config.paths.workspace, mode === 'build');
+  const pipelineContext = createHookContext(config, mode, options.changedFile);
+
+  await executeHooks('pipeline.beforeAll', hooks.pipelineBefore, pipelineContext);
+
+  let pipelineError: unknown;
+
+  try {
+    for (const builder of builders) {
+      const builderContext = createHookContext(config, mode, options.changedFile, builder.name);
+      const beforeHooks = hooks.builderBefore.get(builder.name) ?? [];
+      const afterHooks = hooks.builderAfter.get(builder.name) ?? [];
+
+      await executeHooks(`builder.${builder.name}.before`, beforeHooks, builderContext);
+
+      const start = performance.now();
+      let builderError: Error | undefined;
+      let afterHookError: Error | undefined;
+
+      try {
+        if (mode === 'build') {
+          await builder.build(context);
+        } else {
+          await builder.publish(context);
         }
+      } catch (error) {
+        builderError = wrapPipelineError(builder.name, mode, error);
+      }
+
+      try {
+        await executeHooks(`builder.${builder.name}.after`, afterHooks, builderContext);
+      } catch (error) {
+        afterHookError = error as Error;
+      }
+
+      const end = performance.now();
+      const duration = end - start;
+      console.info(
+        `[webstir-frontend] ${mode}:${builder.name} completed in ${duration.toFixed(1)}ms`,
+      );
+
+      if (builderError) {
+        throw builderError;
+      }
+
+      if (afterHookError) {
+        throw afterHookError;
+      }
     }
-
-    if (pipelineError) {
-        throw pipelineError;
+  } catch (error) {
+    pipelineError = error;
+  } finally {
+    try {
+      await executeHooks('pipeline.afterAll', hooks.pipelineAfter, pipelineContext);
+    } catch (hookError) {
+      if (!pipelineError) {
+        pipelineError = hookError;
+      }
     }
+  }
+
+  if (pipelineError) {
+    throw pipelineError;
+  }
 }
 
 function wrapPipelineError(name: string, mode: PipelineMode, error: unknown): Error {
-    if (error instanceof Error) {
-        error.message = `[${mode}:${name}] ${error.message}`;
-        return error;
-    }
+  if (error instanceof Error) {
+    error.message = `[${mode}:${name}] ${error.message}`;
+    return error;
+  }
 
-    return new Error(`[${mode}:${name}] ${String(error)}`);
+  return new Error(`[${mode}:${name}] ${String(error)}`);
 }