@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/src/builders/staticAssetsBuilder.ts

@@ -7,168 +7,199 @@ import { optimizeImages } from '../assets/imageOptimizer.js';
 import { relativePathWithin } from '../utils/pathMatch.js';
 
 const IMAGE_EXTENSIONS = [
-    EXTENSIONS.png,
-    EXTENSIONS.jpg,
-    EXTENSIONS.jpeg,
-    EXTENSIONS.gif,
-    EXTENSIONS.svg,
-    EXTENSIONS.webp,
-    EXTENSIONS.ico
+  EXTENSIONS.png,
+  EXTENSIONS.jpg,
+  EXTENSIONS.jpeg,
+  EXTENSIONS.gif,
+  EXTENSIONS.svg,
+  EXTENSIONS.webp,
+  EXTENSIONS.ico,
 ] as const;
 
 const FONT_EXTENSIONS = [
-    EXTENSIONS.woff,
-    EXTENSIONS.woff2,
-    EXTENSIONS.ttf,
-    EXTENSIONS.otf,
-    EXTENSIONS.eot
+  EXTENSIONS.woff,
+  EXTENSIONS.woff2,
+  EXTENSIONS.ttf,
+  EXTENSIONS.otf,
+  EXTENSIONS.eot,
 ] as const;
 
 const MEDIA_EXTENSIONS = [
-    EXTENSIONS.mp3,
-    EXTENSIONS.m4a,
-    EXTENSIONS.wav,
-    EXTENSIONS.ogg,
-    EXTENSIONS.mp4,
-    EXTENSIONS.webm,
-    EXTENSIONS.mov
+  EXTENSIONS.mp3,
+  EXTENSIONS.m4a,
+  EXTENSIONS.wav,
+  EXTENSIONS.ogg,
+  EXTENSIONS.mp4,
+  EXTENSIONS.webm,
+  EXTENSIONS.mov,
 ] as const;
 
 const ALLOW_ALL_ROBOTS = 'User-agent: *\nAllow: /\n';
 
 export function createStaticAssetsBuilder(context: BuilderContext): Builder {
-    return {
-        name: 'static-assets',
-        async build(): Promise<void> {
-            await copyStaticAssets(context, false);
-        },
-        async publish(): Promise<void> {
-            await copyStaticAssets(context, true);
-        }
-    };
+  return {
+    name: 'static-assets',
+    async build(): Promise<void> {
+      await copyStaticAssets(context, false);
+    },
+    async publish(): Promise<void> {
+      await copyStaticAssets(context, true);
+    },
+  };
 }
 
 async function copyStaticAssets(context: BuilderContext, isProduction: boolean): Promise<void> {
-    const { config } = context;
-    if (!shouldProcess(context, [
-        { directory: config.paths.src.images, extensions: IMAGE_EXTENSIONS },
-        { directory: config.paths.src.fonts, extensions: FONT_EXTENSIONS },
-        { directory: config.paths.src.media, extensions: MEDIA_EXTENSIONS }
-    ])) {
-        return;
+  const { config } = context;
+  if (
+    !shouldProcess(context, [
+      { directory: config.paths.src.images, extensions: IMAGE_EXTENSIONS },
+      { directory: config.paths.src.fonts, extensions: FONT_EXTENSIONS },
+      { directory: config.paths.src.media, extensions: MEDIA_EXTENSIONS },
+    ])
+  ) {
+    return;
+  }
+
+  const targets = [
+    {
+      source: config.paths.src.images,
+      build: config.paths.build.frontend,
+      dist: config.paths.dist.frontend,
+      folder: FOLDERS.images,
+      extensions: IMAGE_EXTENSIONS,
+    },
+    {
+      source: config.paths.src.fonts,
+      build: config.paths.build.frontend,
+      dist: config.paths.dist.frontend,
+      folder: FOLDERS.fonts,
+      extensions: FONT_EXTENSIONS,
+    },
+    {
+      source: config.paths.src.media,
+      build: config.paths.build.frontend,
+      dist: config.paths.dist.frontend,
+      folder: FOLDERS.media,
+      extensions: MEDIA_EXTENSIONS,
+    },
+  ];
+
+  for (const target of targets) {
+    if (!(await pathExists(target.source))) {
+      continue;
     }
 
-    const targets = [
-        { source: config.paths.src.images, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.images, extensions: IMAGE_EXTENSIONS },
-        { source: config.paths.src.fonts, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.fonts, extensions: FONT_EXTENSIONS },
-        { source: config.paths.src.media, build: config.paths.build.frontend, dist: config.paths.dist.frontend, folder: FOLDERS.media, extensions: MEDIA_EXTENSIONS }
-    ];
-
-    for (const target of targets) {
-        if (!(await pathExists(target.source))) {
-            continue;
+    const changedRelative = relativePathWithin(context.changedFile, target.source);
+    const buildDestination = path.join(target.build, target.folder);
+
+    if (!context.changedFile || !changedRelative) {
+      await emptyDir(buildDestination);
+      await copy(target.source, buildDestination);
+
+      if (isProduction) {
+        const distDestination = path.join(target.dist, target.folder);
+        if (target.folder === FOLDERS.images) {
+          if (config.features.imageOptimization) {
+            await optimizeImages(buildDestination, distDestination);
+          } else {
+            await emptyDir(distDestination);
+            await copy(buildDestination, distDestination);
+          }
+        } else {
+          await emptyDir(distDestination);
+          await copy(buildDestination, distDestination);
         }
+      }
+      continue;
+    }
 
-        const changedRelative = relativePathWithin(context.changedFile, target.source);
-        const buildDestination = path.join(target.build, target.folder);
-
-        if (!context.changedFile || !changedRelative) {
-            await emptyDir(buildDestination);
-            await copy(target.source, buildDestination);
-
-            if (isProduction) {
-                const distDestination = path.join(target.dist, target.folder);
-                if (target.folder === FOLDERS.images) {
-                    if (config.features.imageOptimization) {
-                        await optimizeImages(buildDestination, distDestination);
-                    } else {
-                        await emptyDir(distDestination);
-                        await copy(buildDestination, distDestination);
-                    }
-                } else {
-                    await emptyDir(distDestination);
-                    await copy(buildDestination, distDestination);
-                }
-            }
-            continue;
-        }
+    await copySingleAsset(target.source, buildDestination, changedRelative);
 
-        await copySingleAsset(target.source, buildDestination, changedRelative);
-
-        if (isProduction) {
-            const distDestination = path.join(target.dist, target.folder);
-            if (target.folder === FOLDERS.images) {
-                if (config.features.imageOptimization) {
-                    await optimizeImages(buildDestination, distDestination, [changedRelative]);
-                } else {
-                    await syncImageWithoutOptimization(buildDestination, distDestination, changedRelative);
-                }
-            } else {
-                const sourcePath = path.join(target.source, changedRelative);
-                const destPath = path.join(distDestination, changedRelative);
-                if (await pathExists(sourcePath)) {
-                    await ensureDir(path.dirname(destPath));
-                    await copy(sourcePath, destPath);
-                } else {
-                    await remove(destPath).catch(() => undefined);
-                }
-            }
+    if (isProduction) {
+      const distDestination = path.join(target.dist, target.folder);
+      if (target.folder === FOLDERS.images) {
+        if (config.features.imageOptimization) {
+          await optimizeImages(buildDestination, distDestination, [changedRelative]);
+        } else {
+          await syncImageWithoutOptimization(buildDestination, distDestination, changedRelative);
         }
+      } else {
+        const sourcePath = path.join(target.source, changedRelative);
+        const destPath = path.join(distDestination, changedRelative);
+        if (await pathExists(sourcePath)) {
+          await ensureDir(path.dirname(destPath));
+          await copy(sourcePath, destPath);
+        } else {
+          await remove(destPath).catch(() => undefined);
+        }
+      }
     }
+  }
 
-    await syncRobotsTxt(config, isProduction);
+  await syncRobotsTxt(config, isProduction);
 }
 
-async function copySingleAsset(sourceRoot: string, buildRoot: string, relativePath: string): Promise<void> {
-    const sourcePath = path.join(sourceRoot, relativePath);
-    const destinationPath = path.join(buildRoot, relativePath);
-
-    if (await pathExists(sourcePath)) {
-        await ensureDir(path.dirname(destinationPath));
-        await copy(sourcePath, destinationPath);
-    } else {
-        await remove(destinationPath).catch(() => undefined);
-    }
+async function copySingleAsset(
+  sourceRoot: string,
+  buildRoot: string,
+  relativePath: string,
+): Promise<void> {
+  const sourcePath = path.join(sourceRoot, relativePath);
+  const destinationPath = path.join(buildRoot, relativePath);
+
+  if (await pathExists(sourcePath)) {
+    await ensureDir(path.dirname(destinationPath));
+    await copy(sourcePath, destinationPath);
+  } else {
+    await remove(destinationPath).catch(() => undefined);
+  }
 }
 
-async function syncImageWithoutOptimization(buildRoot: string, distRoot: string, relativePath: string): Promise<void> {
-    const sourcePath = path.join(buildRoot, relativePath);
-    const destinationPath = path.join(distRoot, relativePath);
-
-    if (await pathExists(sourcePath)) {
-        await ensureDir(path.dirname(destinationPath));
-        await copy(sourcePath, destinationPath);
-    } else {
-        await remove(destinationPath).catch(() => undefined);
-    }
-
-    await Promise.all([
-        remove(`${destinationPath}${EXTENSIONS.webp}`).catch(() => undefined),
-        remove(`${destinationPath}${EXTENSIONS.avif}`).catch(() => undefined)
-    ]);
+async function syncImageWithoutOptimization(
+  buildRoot: string,
+  distRoot: string,
+  relativePath: string,
+): Promise<void> {
+  const sourcePath = path.join(buildRoot, relativePath);
+  const destinationPath = path.join(distRoot, relativePath);
+
+  if (await pathExists(sourcePath)) {
+    await ensureDir(path.dirname(destinationPath));
+    await copy(sourcePath, destinationPath);
+  } else {
+    await remove(destinationPath).catch(() => undefined);
+  }
+
+  await Promise.all([
+    remove(`${destinationPath}${EXTENSIONS.webp}`).catch(() => undefined),
+    remove(`${destinationPath}${EXTENSIONS.avif}`).catch(() => undefined),
+  ]);
 }
 
-async function syncRobotsTxt(config: BuilderContext['config'], isProduction: boolean): Promise<void> {
-    const sourcePath = path.join(config.paths.src.frontend, FILES.robotsTxt);
-    const buildPath = path.join(config.paths.build.frontend, FILES.robotsTxt);
-
-    if (await pathExists(sourcePath)) {
-        await ensureDir(path.dirname(buildPath));
-        await copy(sourcePath, buildPath);
-
-        if (isProduction) {
-            const distPath = path.join(config.paths.dist.frontend, FILES.robotsTxt);
-            await ensureDir(path.dirname(distPath));
-            await copy(sourcePath, distPath);
-        }
-    } else {
-        await ensureDir(path.dirname(buildPath));
-        await writeFile(buildPath, ALLOW_ALL_ROBOTS);
-
-        if (isProduction) {
-            const distPath = path.join(config.paths.dist.frontend, FILES.robotsTxt);
-            await ensureDir(path.dirname(distPath));
-            await writeFile(distPath, ALLOW_ALL_ROBOTS);
-        }
+async function syncRobotsTxt(
+  config: BuilderContext['config'],
+  isProduction: boolean,
+): Promise<void> {
+  const sourcePath = path.join(config.paths.src.frontend, FILES.robotsTxt);
+  const buildPath = path.join(config.paths.build.frontend, FILES.robotsTxt);
+
+  if (await pathExists(sourcePath)) {
+    await ensureDir(path.dirname(buildPath));
+    await copy(sourcePath, buildPath);
+
+    if (isProduction) {
+      const distPath = path.join(config.paths.dist.frontend, FILES.robotsTxt);
+      await ensureDir(path.dirname(distPath));
+      await copy(sourcePath, distPath);
+    }
+  } else {
+    await ensureDir(path.dirname(buildPath));
+    await writeFile(buildPath, ALLOW_ALL_ROBOTS);
+
+    if (isProduction) {
+      const distPath = path.join(config.paths.dist.frontend, FILES.robotsTxt);
+      await ensureDir(path.dirname(distPath));
+      await writeFile(distPath, ALLOW_ALL_ROBOTS);
     }
+  }
 }

package/src/builders/types.ts

@@ -1,15 +1,16 @@
 import type { EnableFlags, FrontendConfig } from '../types.js';
 
 export interface BuilderContext {
-    readonly config: FrontendConfig;
-    readonly changedFile?: string;
-    readonly enable?: EnableFlags;
+  readonly config: FrontendConfig;
+  readonly changedFile?: string;
+  readonly enable?: EnableFlags;
+  readonly env?: Record<string, string | undefined>;
 }
 
 export interface Builder {
-    readonly name: string;
-    build(context: BuilderContext): Promise<void>;
-    publish(context: BuilderContext): Promise<void>;
+  readonly name: string;
+  build(context: BuilderContext): Promise<void>;
+  publish(context: BuilderContext): Promise<void>;
 }
 
 export type BuilderFactory = (context: BuilderContext) => Builder;

package/src/cli.ts

@@ -1,108 +1,84 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { Command } from 'commander';
 import { runAddPage, runBuild, runPublish, runRebuild } from './operations.js';
-import { WatchDaemon } from './watch/watchDaemon.js';
 
 const program = new Command();
 
-program
-    .name('webstir-frontend')
-    .description('Webstir frontend build orchestrator');
-
-program
-    .command('build')
-    .description('Build frontend assets for development workflows')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .option('-c, --changed-file <path>', 'Optional path filter for incremental builds')
-    .action(async (cmd) => {
-        try {
-            await runBuild({
-                workspaceRoot: cmd.workspace,
-                changedFile: cmd.changedFile ?? undefined
-            });
-        } catch (error) {
-            handleError(error);
-        }
-    });
+program.name('webstir-frontend').description('Webstir frontend build orchestrator');
 
 program
-    .command('publish')
-    .description('Build production assets into the dist directory')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .option('-m, --mode <mode>', 'Publish mode: bundle or ssg', 'bundle')
-    .action(async (cmd) => {
-        try {
-            await runPublish({
-                workspaceRoot: cmd.workspace,
-                publishMode: cmd.mode === 'ssg' ? 'ssg' : 'bundle'
-            });
-        } catch (error) {
-            handleError(error);
-        }
-    });
+  .command('build')
+  .description('Build frontend assets for development workflows')
+  .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
+  .option('-c, --changed-file <path>', 'Optional path filter for incremental builds')
+  .action(async (cmd) => {
+    try {
+      await runBuild({
+        workspaceRoot: cmd.workspace,
+        changedFile: cmd.changedFile ?? undefined,
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
 
 program
-    .command('rebuild')
-    .description('Rebuild frontend assets in response to file changes')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .requiredOption('-c, --changed-file <path>', 'Path to the changed file triggering the rebuild')
-    .action(async (cmd) => {
-        try {
-            await runRebuild({
-                workspaceRoot: cmd.workspace,
-                changedFile: cmd.changedFile ?? undefined
-            });
-        } catch (error) {
-            handleError(error);
-        }
-    });
+  .command('publish')
+  .description('Build production assets into the dist directory')
+  .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
+  .option('-m, --mode <mode>', 'Publish mode: bundle or ssg', 'bundle')
+  .action(async (cmd) => {
+    try {
+      await runPublish({
+        workspaceRoot: cmd.workspace,
+        publishMode: cmd.mode === 'ssg' ? 'ssg' : 'bundle',
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
 
 program
-    .command('add-page <name>')
-    .description('Scaffold a new frontend page (HTML/CSS/TS)')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .option('-m, --mode <mode>', 'Page mode: standard or ssg (defaults to ssg when webstir.mode=ssg)')
-    .action(async (name, cmd) => {
-        try {
-            const rawMode = typeof cmd.mode === 'string' ? cmd.mode.toLowerCase() : undefined;
-            await runAddPage({
-                workspaceRoot: cmd.workspace,
-                pageName: name,
-                ssg: rawMode === 'ssg' ? true : rawMode === 'standard' ? false : undefined
-            });
-        } catch (error) {
-            handleError(error);
-        }
-    });
+  .command('rebuild')
+  .description('Rebuild frontend assets in response to file changes')
+  .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
+  .requiredOption('-c, --changed-file <path>', 'Path to the changed file triggering the rebuild')
+  .action(async (cmd) => {
+    try {
+      await runRebuild({
+        workspaceRoot: cmd.workspace,
+        changedFile: cmd.changedFile ?? undefined,
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
 
 program
-    .command('watch-daemon')
-    .description('Run the persistent frontend watch daemon')
-    .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
-    .option('--no-auto-start', 'Defer startup until a start command is received')
-    .option('-v, --verbose', 'Enable verbose watch diagnostics')
-    .option('--hmr-verbose', 'Log detailed hot-update diagnostics')
-    .action(async (cmd) => {
-        try {
-            const daemon = new WatchDaemon({
-                workspaceRoot: cmd.workspace,
-                autoStart: cmd.autoStart,
-                verbose: cmd.verbose === true,
-                hmrVerbose: cmd.hmrVerbose === true
-            });
-            await daemon.run();
-        } catch (error) {
-            handleError(error);
-        }
-    });
+  .command('add-page <name>')
+  .description('Scaffold a new frontend page (HTML/CSS/TS)')
+  .requiredOption('-w, --workspace <path>', 'Absolute path to the workspace root')
+  .option('-m, --mode <mode>', 'Page mode: standard or ssg (defaults to ssg when webstir.mode=ssg)')
+  .action(async (name, cmd) => {
+    try {
+      const rawMode = typeof cmd.mode === 'string' ? cmd.mode.toLowerCase() : undefined;
+      await runAddPage({
+        workspaceRoot: cmd.workspace,
+        pageName: name,
+        ssg: rawMode === 'ssg' ? true : rawMode === 'standard' ? false : undefined,
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
 
 program.parseAsync(process.argv).catch(handleError);
 
 function handleError(error: unknown): void {
-    if (error instanceof Error) {
-        console.error(error.message);
-    } else {
-        console.error('Unknown error', error);
-    }
-    process.exitCode = 1;
+  if (error instanceof Error) {
+    console.error(error.message);
+  } else {
+    console.error('Unknown error', error);
+  }
+  process.exitCode = 1;
 }

package/src/config/manifest.ts

@@ -1,24 +1,26 @@
-import { promises as fs } from 'fs';
-import path from 'path';
+import { rename } from 'node:fs/promises';
+import path from 'node:path';
+
 import { frontendConfigSchema, type FrontendConfigInput } from './schema.js';
+import { ensureDir, readFile, writeFile } from '../utils/fs.js';
 
 export interface WriteManifestOptions {
-    readonly outputPath: string;
-    readonly data: FrontendConfigInput;
+  readonly outputPath: string;
+  readonly data: FrontendConfigInput;
 }
 
 export async function writeConfigManifest(options: WriteManifestOptions): Promise<void> {
-    const parsed = frontendConfigSchema.parse(options.data);
-    const directory = path.dirname(options.outputPath);
-    await fs.mkdir(directory, { recursive: true });
-    const serialized = JSON.stringify(parsed, undefined, 2);
-    const tempPath = path.join(directory, `.webstir-frontend-${process.pid}-${Date.now()}.tmp`);
-    await fs.writeFile(tempPath, serialized, 'utf8');
-    await fs.rename(tempPath, options.outputPath);
+  const parsed = frontendConfigSchema.parse(options.data);
+  const directory = path.dirname(options.outputPath);
+  await ensureDir(directory);
+  const serialized = JSON.stringify(parsed, undefined, 2);
+  const tempPath = path.join(directory, `.webstir-frontend-${process.pid}-${Date.now()}.tmp`);
+  await writeFile(tempPath, serialized);
+  await rename(tempPath, options.outputPath);
 }
 
 export async function readConfigManifest(manifestPath: string): Promise<FrontendConfigInput> {
-    const json = await fs.readFile(manifestPath, 'utf8');
-    const parsed = JSON.parse(json) as unknown;
-    return frontendConfigSchema.parse(parsed);
+  const json = await readFile(manifestPath);
+  const parsed = JSON.parse(json) as unknown;
+  return frontendConfigSchema.parse(parsed);
 }

package/src/config/paths.ts

@@ -1,14 +1,14 @@
-import path from 'path';
-import { promises as fs } from 'fs';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
 import { FOLDERS } from '../core/constants.js';
 
 export const FRONTEND_MANIFEST_FILENAME = 'frontend-manifest.json';
 
 export function resolveManifestPath(workspaceRoot: string): string {
-    return path.join(workspaceRoot, FOLDERS.webstir, FRONTEND_MANIFEST_FILENAME);
+  return path.join(workspaceRoot, FOLDERS.webstir, FRONTEND_MANIFEST_FILENAME);
 }
 
 export async function ensureWebstirDirectory(workspaceRoot: string): Promise<void> {
-    const webstirPath = path.join(workspaceRoot, FOLDERS.webstir);
-    await fs.mkdir(webstirPath, { recursive: true });
+  const webstirPath = path.join(workspaceRoot, FOLDERS.webstir);
+  await fs.mkdir(webstirPath, { recursive: true });
 }