@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/src/core/pages.ts

@@ -1,31 +1,31 @@
 import path from 'node:path';
-import { glob } from 'glob';
 import { pathExists } from '../utils/fs.js';
+import { scanDirectories } from '../utils/glob.js';
 
 export interface PageInfo {
-    readonly name: string;
-    readonly directory: string;
+  readonly name: string;
+  readonly directory: string;
 }
 
 export async function getPages(root: string): Promise<PageInfo[]> {
-    const directories = await getPageDirectories(root);
-    return directories.map((entry) => ({
-        name: entry.name,
-        directory: entry.directory
-    }));
+  const directories = await getPageDirectories(root);
+  return directories.map((entry) => ({
+    name: entry.name,
+    directory: entry.directory,
+  }));
 }
 
 export async function getPageDirectories(root: string): Promise<PageInfo[]> {
-    if (!(await pathExists(root))) {
-        return [];
-    }
+  if (!(await pathExists(root))) {
+    return [];
+  }
 
-    const entries = await glob('*/', { cwd: root, absolute: false, withFileTypes: false });
-    return entries.map((entry) => {
-        const name = entry.endsWith('/') ? entry.slice(0, -1) : entry;
-        return {
-            name,
-            directory: path.join(root, name)
-        };
-    });
+  const entries = await scanDirectories('*/', { cwd: root, absolute: false });
+  return entries.map((entry) => {
+    const name = entry.endsWith('/') ? entry.slice(0, -1) : entry;
+    return {
+      name,
+      directory: path.join(root, name),
+    };
+  });
 }

package/src/hooks.ts

@@ -7,169 +7,179 @@ import type { PipelineMode } from './pipeline.js';
 const CONFIG_CANDIDATES = ['webstir.config.mjs', 'webstir.config.js', 'webstir.config.cjs'];
 
 export interface HookContext {
-    readonly config: FrontendConfig;
-    readonly mode: PipelineMode;
-    readonly workspaceRoot: string;
-    readonly builderName?: string;
-    readonly changedFile?: string;
+  readonly config: FrontendConfig;
+  readonly mode: PipelineMode;
+  readonly workspaceRoot: string;
+  readonly builderName?: string;
+  readonly changedFile?: string;
 }
 
 export type HookHandler = (context: HookContext) => unknown | Promise<unknown>;
 
 export interface ResolvedHooks {
-    readonly pipelineBefore: HookHandler[];
-    readonly pipelineAfter: HookHandler[];
-    readonly builderBefore: Map<string, HookHandler[]>;
-    readonly builderAfter: Map<string, HookHandler[]>;
+  readonly pipelineBefore: HookHandler[];
+  readonly pipelineAfter: HookHandler[];
+  readonly builderBefore: Map<string, HookHandler[]>;
+  readonly builderAfter: Map<string, HookHandler[]>;
 }
 
 interface RawHooks {
-    readonly pipeline?: RawPipelineHooks;
-    readonly builders?: Record<string, RawBuilderHooks | HookHandler | HookHandler[]>;
+  readonly pipeline?: RawPipelineHooks;
+  readonly builders?: Record<string, RawBuilderHooks | HookHandler | HookHandler[]>;
 }
 
 interface RawPipelineHooks {
-    readonly beforeAll?: HookHandler | HookHandler[];
-    readonly afterAll?: HookHandler | HookHandler[];
+  readonly beforeAll?: HookHandler | HookHandler[];
+  readonly afterAll?: HookHandler | HookHandler[];
 }
 
 interface RawBuilderHooks {
-    readonly before?: HookHandler | HookHandler[];
-    readonly after?: HookHandler | HookHandler[];
+  readonly before?: HookHandler | HookHandler[];
+  readonly after?: HookHandler | HookHandler[];
 }
 
 const EMPTY_HOOKS: ResolvedHooks = {
-    pipelineBefore: [],
-    pipelineAfter: [],
-    builderBefore: new Map(),
-    builderAfter: new Map()
+  pipelineBefore: [],
+  pipelineAfter: [],
+  builderBefore: new Map(),
+  builderAfter: new Map(),
 };
 
 export async function loadHooks(workspaceRoot: string, cacheBust: boolean): Promise<ResolvedHooks> {
-    const configPath = findConfigPath(workspaceRoot);
-    if (!configPath) {
-        return EMPTY_HOOKS;
-    }
-
-    let moduleConfig: unknown;
-    try {
-        const fileUrl = pathToFileURL(configPath).href;
-        const url = cacheBust ? `${fileUrl}?update=${Date.now()}` : fileUrl;
-        moduleConfig = await import(url);
-    } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to load hooks from ${configPath}: ${message}`);
-    }
-
-    const exported = (moduleConfig as Record<string, unknown>)?.default ?? moduleConfig;
-    if (!exported || typeof exported !== 'object') {
-        return EMPTY_HOOKS;
-    }
-
-    const rawHooks = (exported as Record<string, unknown>).hooks ?? exported;
-    if (!rawHooks || typeof rawHooks !== 'object') {
-        return EMPTY_HOOKS;
-    }
-
-    return normalizeHooks(rawHooks as RawHooks, configPath);
+  const configPath = findConfigPath(workspaceRoot);
+  if (!configPath) {
+    return EMPTY_HOOKS;
+  }
+
+  let moduleConfig: unknown;
+  try {
+    const fileUrl = pathToFileURL(configPath).href;
+    const url = cacheBust ? `${fileUrl}?update=${Date.now()}` : fileUrl;
+    moduleConfig = await import(url);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load hooks from ${configPath}: ${message}`);
+  }
+
+  const exported = (moduleConfig as Record<string, unknown>)?.default ?? moduleConfig;
+  if (!exported || typeof exported !== 'object') {
+    return EMPTY_HOOKS;
+  }
+
+  const rawHooks = (exported as Record<string, unknown>).hooks ?? exported;
+  if (!rawHooks || typeof rawHooks !== 'object') {
+    return EMPTY_HOOKS;
+  }
+
+  return normalizeHooks(rawHooks as RawHooks, configPath);
 }
 
 export function createHookContext(
-    config: FrontendConfig,
-    mode: PipelineMode,
-    changedFile: string | undefined,
-    builderName?: string
+  config: FrontendConfig,
+  mode: PipelineMode,
+  changedFile: string | undefined,
+  builderName?: string,
 ): HookContext {
-    return {
-        config,
-        mode,
-        workspaceRoot: config.paths.workspace,
-        builderName,
-        changedFile
-    };
+  return {
+    config,
+    mode,
+    workspaceRoot: config.paths.workspace,
+    builderName,
+    changedFile,
+  };
 }
 
-export async function executeHooks(label: string, handlers: HookHandler[], context: HookContext): Promise<void> {
-    for (const handler of handlers) {
-        try {
-            await handler(context);
-        } catch (error) {
-            throw wrapHookError(label, error);
-        }
+export async function executeHooks(
+  label: string,
+  handlers: HookHandler[],
+  context: HookContext,
+): Promise<void> {
+  for (const handler of handlers) {
+    try {
+      await handler(context);
+    } catch (error) {
+      throw wrapHookError(label, error);
     }
+  }
 }
 
 function wrapHookError(label: string, error: unknown): Error {
-    if (error instanceof Error) {
-        error.message = `[hook:${label}] ${error.message}`;
-        return error;
-    }
+  if (error instanceof Error) {
+    error.message = `[hook:${label}] ${error.message}`;
+    return error;
+  }
 
-    return new Error(`[hook:${label}] ${String(error)}`);
+  return new Error(`[hook:${label}] ${String(error)}`);
 }
 
 function normalizeHooks(raw: RawHooks, configPath: string): ResolvedHooks {
-    const pipeline = raw.pipeline ?? {};
-    const pipelineBefore = normalizeHandlerSet(pipeline.beforeAll, `${configPath} pipeline.beforeAll`);
-    const pipelineAfter = normalizeHandlerSet(pipeline.afterAll, `${configPath} pipeline.afterAll`);
-
-    const builderBefore = new Map<string, HookHandler[]>();
-    const builderAfter = new Map<string, HookHandler[]>();
-
-    const builders = raw.builders ?? {};
-    for (const [name, value] of Object.entries(builders)) {
-        if (typeof value === 'function' || Array.isArray(value)) {
-            builderBefore.set(name, normalizeHandlerSet(value, `${configPath} builders.${name}`));
-            continue;
-        }
-
-        if (!value || typeof value !== 'object') {
-            continue;
-        }
-
-        const before = normalizeHandlerSet(value.before, `${configPath} builders.${name}.before`);
-        const after = normalizeHandlerSet(value.after, `${configPath} builders.${name}.after`);
-        if (before.length > 0) {
-            builderBefore.set(name, before);
-        }
-        if (after.length > 0) {
-            builderAfter.set(name, after);
-        }
+  const pipeline = raw.pipeline ?? {};
+  const pipelineBefore = normalizeHandlerSet(
+    pipeline.beforeAll,
+    `${configPath} pipeline.beforeAll`,
+  );
+  const pipelineAfter = normalizeHandlerSet(pipeline.afterAll, `${configPath} pipeline.afterAll`);
+
+  const builderBefore = new Map<string, HookHandler[]>();
+  const builderAfter = new Map<string, HookHandler[]>();
+
+  const builders = raw.builders ?? {};
+  for (const [name, value] of Object.entries(builders)) {
+    if (typeof value === 'function' || Array.isArray(value)) {
+      builderBefore.set(name, normalizeHandlerSet(value, `${configPath} builders.${name}`));
+      continue;
     }
 
-    return {
-        pipelineBefore,
-        pipelineAfter,
-        builderBefore,
-        builderAfter
-    };
-}
+    if (!value || typeof value !== 'object') {
+      continue;
+    }
 
-function normalizeHandlerSet(value: HookHandler | HookHandler[] | undefined, label: string): HookHandler[] {
-    if (value === undefined) {
-        return [];
+    const before = normalizeHandlerSet(value.before, `${configPath} builders.${name}.before`);
+    const after = normalizeHandlerSet(value.after, `${configPath} builders.${name}.after`);
+    if (before.length > 0) {
+      builderBefore.set(name, before);
+    }
+    if (after.length > 0) {
+      builderAfter.set(name, after);
     }
+  }
+
+  return {
+    pipelineBefore,
+    pipelineAfter,
+    builderBefore,
+    builderAfter,
+  };
+}
+
+function normalizeHandlerSet(
+  value: HookHandler | HookHandler[] | undefined,
+  label: string,
+): HookHandler[] {
+  if (value === undefined) {
+    return [];
+  }
 
-    const handlers = Array.isArray(value) ? value : [value];
-    const normalized: HookHandler[] = [];
+  const handlers = Array.isArray(value) ? value : [value];
+  const normalized: HookHandler[] = [];
 
-    for (const handler of handlers) {
-        if (typeof handler !== 'function') {
-            throw new Error(`Invalid hook handler in ${label}; expected function`);
-        }
-        normalized.push(handler);
+  for (const handler of handlers) {
+    if (typeof handler !== 'function') {
+      throw new Error(`Invalid hook handler in ${label}; expected function`);
     }
+    normalized.push(handler);
+  }
 
-    return normalized;
+  return normalized;
 }
 
 function findConfigPath(workspaceRoot: string): string | undefined {
-    for (const candidate of CONFIG_CANDIDATES) {
-        const fullPath = path.join(workspaceRoot, candidate);
-        if (fs.existsSync(fullPath)) {
-            return fullPath;
-        }
+  for (const candidate of CONFIG_CANDIDATES) {
+    const fullPath = path.join(workspaceRoot, candidate);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
     }
+  }
 
-    return undefined;
+  return undefined;
 }

package/src/html/criticalCss.ts

@@ -6,13 +6,15 @@ import { pathExists, readFile, stat } from '../utils/fs.js';
 import { resolvePageAssetUrl } from '../utils/pagePaths.js';
 
 const INLINE_THRESHOLD_BYTES = 6 * 1024;
-const csso = ((cssoModule as unknown as { default?: typeof cssoModule }).default ?? cssoModule) as typeof cssoModule;
+const csso = ((cssoModule as unknown as { default?: typeof cssoModule }).default ??
+  cssoModule) as typeof cssoModule;
 
 function minifyCriticalCss(css: string): string {
-    return csso.minify(css).css;
+  return csso.minify(css).css;
 }
 
-const APP_SHELL_CRITICAL_CSS = minifyCriticalCss(`
+const APP_SHELL_CRITICAL_CSS = minifyCriticalCss(
+  `
 @layer tokens {
     :root {
         --ws-header-control-size: 2.6rem;
@@ -83,8 +85,10 @@ const APP_SHELL_CRITICAL_CSS = minifyCriticalCss(`
         height: calc(var(--ws-header-sticky-offset) - 1px);
     }
 }
-`.trim());
-const DOCS_SHELL_CRITICAL_CSS = minifyCriticalCss(`
+`.trim(),
+);
+const DOCS_SHELL_CRITICAL_CSS = minifyCriticalCss(
+  `
 @layer overrides {
     .docs-layout {
         --ws-docs-sidebar-width: clamp(14rem, 20vw, 18rem);
@@ -130,85 +134,88 @@ const DOCS_SHELL_CRITICAL_CSS = minifyCriticalCss(`
         }
     }
 }
-`.trim());
+`.trim(),
+);
 
 export async function inlineCriticalCss(
-    document: CheerioAPI,
-    pageName: string,
-    pagesRoot: string,
-    pagesUrlPrefix: string,
-    cssFile?: string
+  document: CheerioAPI,
+  pageName: string,
+  pagesRoot: string,
+  pagesUrlPrefix: string,
+  cssFile?: string,
 ): Promise<void> {
-    if (!cssFile) {
-        return;
-    }
-
-    const cssPath = path.join(pagesRoot, pageName, cssFile);
-    if (!(await pathExists(cssPath))) {
-        return;
-    }
-
-    const info = await stat(cssPath).catch(() => null);
-    if (!info || !info.isFile() || info.size > INLINE_THRESHOLD_BYTES) {
-        return;
-    }
-
-    const cssContent = minifyCriticalCss(await readFile(cssPath));
-    const head = document('head').first();
-    if (head.length === 0) {
-        return;
-    }
-
-    const href = resolvePageAssetUrl(pagesUrlPrefix, pageName, cssFile);
-    document(`link[href="${href}"]`).remove();
-
-    if (cssFile.endsWith(EXTENSIONS.css)) {
-        document(`link[rel="preload"][href="${href}"]`).remove();
-    }
-
-    head.append(`\n<style data-critical>\n${cssContent}\n</style>\n`);
+  if (!cssFile) {
+    return;
+  }
+
+  const cssPath = path.join(pagesRoot, pageName, cssFile);
+  if (!(await pathExists(cssPath))) {
+    return;
+  }
+
+  const info = await stat(cssPath).catch(() => null);
+  if (!info || !info.isFile() || info.size > INLINE_THRESHOLD_BYTES) {
+    return;
+  }
+
+  const cssContent = minifyCriticalCss(await readFile(cssPath));
+  const head = document('head').first();
+  if (head.length === 0) {
+    return;
+  }
+
+  const href = resolvePageAssetUrl(pagesUrlPrefix, pageName, cssFile);
+  document(`link[href="${href}"]`).remove();
+
+  if (cssFile.endsWith(EXTENSIONS.css)) {
+    document(`link[rel="preload"][href="${href}"]`).remove();
+  }
+
+  head.append(`\n<style data-critical>\n${cssContent}\n</style>\n`);
 }
 
 export function ensureAppShellCriticalCss(document: CheerioAPI, appCssHref: string): void {
-    const head = document('head').first();
-    if (head.length === 0) {
-        return;
-    }
-
-    const existing = head.find('style[data-critical="app"]').first();
-    if (existing.length > 0) {
-        return;
-    }
-
-    const stylesheet = document(`link[rel="stylesheet"][href="${appCssHref}"]`).first();
-    const styleTag = `<style data-critical="app">\n${APP_SHELL_CRITICAL_CSS}\n</style>`;
-    if (stylesheet.length > 0) {
-        stylesheet.before(styleTag);
-    } else {
-        head.append(styleTag);
-    }
+  const head = document('head').first();
+  if (head.length === 0) {
+    return;
+  }
+
+  const existing = head.find('style[data-critical="app"]').first();
+  if (existing.length > 0) {
+    return;
+  }
+
+  const stylesheet = document(`link[rel="stylesheet"][href="${appCssHref}"]`).first();
+  const styleTag = `<style data-critical="app">\n${APP_SHELL_CRITICAL_CSS}\n</style>`;
+  if (stylesheet.length > 0) {
+    stylesheet.before(styleTag);
+  } else {
+    head.append(styleTag);
+  }
 }
 
 export function ensureDocsShellCriticalCss(document: CheerioAPI): void {
-    const head = document('head').first();
-    if (head.length === 0) {
-        return;
-    }
-
-    const existing = head.find('style[data-critical="docs"]').first();
-    if (existing.length > 0) {
-        return;
-    }
-
-    const docsStylesheet = document('link[rel="stylesheet"]').filter((_, element) => {
-        const href = document(element).attr('href');
-        return typeof href === 'string' && href.includes('/docs/');
-    }).first();
-
-    const styleTag = `<style data-critical="docs">\n${DOCS_SHELL_CRITICAL_CSS}\n</style>`;
-    if (docsStylesheet.length > 0) {
-        docsStylesheet.before(styleTag);
-    } else {
-        head.append(styleTag);
-    }
+  const head = document('head').first();
+  if (head.length === 0) {
+    return;
+  }
+
+  const existing = head.find('style[data-critical="docs"]').first();
+  if (existing.length > 0) {
+    return;
+  }
+
+  const docsStylesheet = document('link[rel="stylesheet"]')
+    .filter((_, element) => {
+      const href = document(element).attr('href');
+      return typeof href === 'string' && href.includes('/docs/');
+    })
+    .first();
+
+  const styleTag = `<style data-critical="docs">\n${DOCS_SHELL_CRITICAL_CSS}\n</style>`;
+  if (docsStylesheet.length > 0) {
+    docsStylesheet.before(styleTag);
+  } else {
+    head.append(styleTag);
+  }
 }