@webstir-io/webstir-frontend 0.1.40 → 0.1.41

package/dist/config/schema.js

@@ -9,7 +9,7 @@ export const frontendPathSchema = z.object({
         content: z.string(),
         images: z.string(),
         fonts: z.string(),
-        media: z.string()
+        media: z.string(),
     }),
     build: z.object({
         root: z.string(),
@@ -19,7 +19,7 @@ export const frontendPathSchema = z.object({
         content: z.string(),
         images: z.string(),
         fonts: z.string(),
-        media: z.string()
+        media: z.string(),
     }),
     dist: z.object({
         root: z.string(),
@@ -29,16 +29,17 @@ export const frontendPathSchema = z.object({
         content: z.string(),
         images: z.string(),
         fonts: z.string(),
-        media: z.string()
-    })
+        media: z.string(),
+    }),
 });
 export const frontendFeatureFlagsSchema = z.object({
     htmlSecurity: z.boolean().default(true),
+    externalResourceIntegrity: z.boolean().default(false),
     imageOptimization: z.boolean().default(true),
-    precompression: z.boolean().default(true)
+    precompression: z.boolean().default(true),
 });
 export const frontendConfigSchema = z.object({
     version: z.literal(1),
     paths: frontendPathSchema,
-    features: frontendFeatureFlagsSchema
+    features: frontendFeatureFlagsSchema,
 });

package/dist/config/setup.js

@@ -6,7 +6,7 @@ export async function prepareWorkspaceConfig(workspaceRoot) {
     await ensureWebstirDirectory(workspaceRoot);
     await writeConfigManifest({
         outputPath: resolveManifestPath(workspaceRoot),
-        data: config
+        data: config,
     });
     return config;
 }

package/dist/config/workspace.js

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
-import path from 'path';
+import path from 'node:path';
 import { FOLDERS } from '../core/constants.js';
 import { frontendFeatureFlagsSchema } from './schema.js';
 const DEFAULT_FEATURE_FLAGS = {
     htmlSecurity: true,
+    externalResourceIntegrity: false,
     imageOptimization: true,
-    precompression: true
+    precompression: true,
 };
 export function buildConfig(workspaceRoot) {
     const srcRoot = path.join(workspaceRoot, FOLDERS.src);
@@ -27,7 +28,7 @@ export function buildConfig(workspaceRoot) {
                 content: srcContentRoot,
                 images: path.join(frontendRoot, FOLDERS.images),
                 fonts: path.join(frontendRoot, FOLDERS.fonts),
-                media: path.join(frontendRoot, FOLDERS.media)
+                media: path.join(frontendRoot, FOLDERS.media),
             },
             build: {
                 root: buildRoot,
@@ -37,7 +38,7 @@ export function buildConfig(workspaceRoot) {
                 content: path.join(buildFrontend, FOLDERS.pages, 'docs'),
                 images: path.join(buildFrontend, FOLDERS.images),
                 fonts: path.join(buildFrontend, FOLDERS.fonts),
-                media: path.join(buildFrontend, FOLDERS.media)
+                media: path.join(buildFrontend, FOLDERS.media),
             },
             dist: {
                 root: distRoot,
@@ -47,10 +48,10 @@ export function buildConfig(workspaceRoot) {
                 content: path.join(distFrontend, FOLDERS.pages, 'docs'),
                 images: path.join(distFrontend, FOLDERS.images),
                 fonts: path.join(distFrontend, FOLDERS.fonts),
-                media: path.join(distFrontend, FOLDERS.media)
-            }
+                media: path.join(distFrontend, FOLDERS.media),
+            },
         },
-        features: loadFeatureFlags(frontendRoot)
+        features: loadFeatureFlags(frontendRoot),
     };
 }
 function resolveContentRoot(workspaceRoot, frontendRoot) {
@@ -111,8 +112,9 @@ function loadFeatureFlags(frontendRoot) {
         const overrides = frontendFeatureFlagsSchema.parse(overridesSource);
         return {
             htmlSecurity: overrides.htmlSecurity,
+            externalResourceIntegrity: overrides.externalResourceIntegrity,
             imageOptimization: overrides.imageOptimization,
-            precompression: overrides.precompression
+            precompression: overrides.precompression,
         };
     }
     catch (error) {
@@ -127,5 +129,5 @@ function extractOverrideSource(value) {
             return container;
         }
     }
-    return (value && typeof value === 'object') ? value : {};
+    return value && typeof value === 'object' ? value : {};
 }

package/dist/core/constants.d.ts

@@ -24,7 +24,7 @@ export declare const FOLDERS: {
 };
 export declare const FILES: {
     readonly packageJson: "package.json";
-    readonly packageLockJson: "package-lock.json";
+    readonly bunLock: "bun.lock";
     readonly tsBuildInfo: ".tsbuildinfo";
     readonly baseTsConfigJson: "base.tsconfig.json";
     readonly manifestJson: "manifest.json";

package/dist/core/constants.js

@@ -20,11 +20,11 @@ export const FOLDERS = {
     nodeModules: 'node_modules',
     seed: 'seed',
     demo: 'demo',
-    temp: 'temp'
+    temp: 'temp',
 };
 export const FILES = {
     packageJson: 'package.json',
-    packageLockJson: 'package-lock.json',
+    bunLock: 'bun.lock',
     tsBuildInfo: '.tsbuildinfo',
     baseTsConfigJson: 'base.tsconfig.json',
     manifestJson: 'manifest.json',
@@ -33,7 +33,7 @@ export const FILES = {
     indexHtml: 'index.html',
     refreshJs: 'refresh.js',
     hmrJs: 'hmr.js',
-    robotsTxt: 'robots.txt'
+    robotsTxt: 'robots.txt',
 };
 export const EXTENSIONS = {
     html: '.html',
@@ -63,8 +63,8 @@ export const EXTENSIONS = {
     ogg: '.ogg',
     mp4: '.mp4',
     webm: '.webm',
-    mov: '.mov'
+    mov: '.mov',
 };
 export const FILE_NAMES = {
-    htmlAppTemplate: 'app.html'
+    htmlAppTemplate: 'app.html',
 };

package/dist/core/diagnostics.js

@@ -2,7 +2,7 @@ export const STRUCTURED_DIAGNOSTIC_PREFIX = 'WEBSTIR_DIAGNOSTIC ';
 export function emitDiagnostic(event) {
     const payload = {
         type: 'diagnostic',
-        ...event
+        ...event,
     };
     const logMessage = `[webstir-frontend][${event.code}] ${event.message}`;
     switch (event.severity) {

package/dist/core/pages.js

@@ -1,23 +1,23 @@
 import path from 'node:path';
-import { glob } from 'glob';
 import { pathExists } from '../utils/fs.js';
+import { scanDirectories } from '../utils/glob.js';
 export async function getPages(root) {
     const directories = await getPageDirectories(root);
     return directories.map((entry) => ({
         name: entry.name,
-        directory: entry.directory
+        directory: entry.directory,
     }));
 }
 export async function getPageDirectories(root) {
     if (!(await pathExists(root))) {
         return [];
     }
-    const entries = await glob('*/', { cwd: root, absolute: false, withFileTypes: false });
+    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)
+            directory: path.join(root, name),
         };
     });
 }

package/dist/hooks.js

@@ -6,7 +6,7 @@ const EMPTY_HOOKS = {
     pipelineBefore: [],
     pipelineAfter: [],
     builderBefore: new Map(),
-    builderAfter: new Map()
+    builderAfter: new Map(),
 };
 export async function loadHooks(workspaceRoot, cacheBust) {
     const configPath = findConfigPath(workspaceRoot);
@@ -39,7 +39,7 @@ export function createHookContext(config, mode, changedFile, builderName) {
         mode,
         workspaceRoot: config.paths.workspace,
         builderName,
-        changedFile
+        changedFile,
     };
 }
 export async function executeHooks(label, handlers, context) {
@@ -87,7 +87,7 @@ function normalizeHooks(raw, configPath) {
         pipelineBefore,
         pipelineAfter,
         builderBefore,
-        builderAfter
+        builderAfter,
     };
 }
 function normalizeHandlerSet(value, label) {

package/dist/html/criticalCss.js

@@ -4,7 +4,8 @@ import { EXTENSIONS } from '../core/constants.js';
 import { pathExists, readFile, stat } from '../utils/fs.js';
 import { resolvePageAssetUrl } from '../utils/pagePaths.js';
 const INLINE_THRESHOLD_BYTES = 6 * 1024;
-const csso = (cssoModule.default ?? cssoModule);
+const csso = (cssoModule.default ??
+    cssoModule);
 function minifyCriticalCss(css) {
     return csso.minify(css).css;
 }
@@ -178,10 +179,12 @@ export function ensureDocsShellCriticalCss(document) {
     if (existing.length > 0) {
         return;
     }
-    const docsStylesheet = document('link[rel="stylesheet"]').filter((_, element) => {
+    const docsStylesheet = document('link[rel="stylesheet"]')
+        .filter((_, element) => {
         const href = document(element).attr('href');
         return typeof href === 'string' && href.includes('/docs/');
-    }).first();
+    })
+        .first();
     const styleTag = `<style data-critical="docs">\n${DOCS_SHELL_CRITICAL_CSS}\n</style>`;
     if (docsStylesheet.length > 0) {
         docsStylesheet.before(styleTag);

package/dist/html/htmlSecurity.d.ts

@@ -1,5 +1,10 @@
 import type { CheerioAPI } from 'cheerio';
+export interface SubresourceIntegrityOptions {
+    readonly allowExternalFetch?: boolean;
+    readonly fetcher?: typeof fetch;
+}
 export interface SubresourceIntegrityResult {
     readonly failures: string[];
+    readonly skippedExternalResources: string[];
 }
-export declare function addSubresourceIntegrity(document: CheerioAPI): Promise<SubresourceIntegrityResult>;
+export declare function addSubresourceIntegrity(document: CheerioAPI, options?: SubresourceIntegrityOptions): Promise<SubresourceIntegrityResult>;

package/dist/html/htmlSecurity.js

@@ -1,22 +1,29 @@
-import { createHash } from 'node:crypto';
 const HTTP_TIMEOUT_MS = 5000;
-export async function addSubresourceIntegrity(document) {
+export async function addSubresourceIntegrity(document, options = {}) {
     const failures = [];
+    const skippedExternalResources = [];
     await Promise.all([
-        processScripts(document, failures),
-        processStylesheets(document, failures)
+        processScripts(document, failures, skippedExternalResources, options),
+        processStylesheets(document, failures, skippedExternalResources, options),
     ]);
-    return { failures };
+    return { failures, skippedExternalResources };
 }
-async function processScripts(document, failures) {
+async function processScripts(document, failures, skippedExternalResources, options) {
     const scripts = document('script[src]').toArray();
     await Promise.all(scripts.map(async (element) => {
         const script = document(element);
         const src = script.attr('src');
-        if (!src || !isExternal(src) || script.attr('integrity')) {
+        if (!src || script.attr('integrity')) {
             return;
         }
-        const sri = await fetchIntegrity(src);
+        if (!isExternal(src)) {
+            return;
+        }
+        if (!options.allowExternalFetch) {
+            skippedExternalResources.push(src);
+            return;
+        }
+        const sri = await fetchIntegrity(src, options.fetcher ?? fetch);
         if (!sri) {
             failures.push(src);
             return;
@@ -27,15 +34,22 @@ async function processScripts(document, failures) {
         }
     }));
 }
-async function processStylesheets(document, failures) {
+async function processStylesheets(document, failures, skippedExternalResources, options) {
     const links = document('link[rel="stylesheet"][href]').toArray();
     await Promise.all(links.map(async (element) => {
         const link = document(element);
         const href = link.attr('href');
-        if (!href || !isExternal(href) || link.attr('integrity')) {
+        if (!href || link.attr('integrity')) {
+            return;
+        }
+        if (!isExternal(href)) {
+            return;
+        }
+        if (!options.allowExternalFetch) {
+            skippedExternalResources.push(href);
             return;
         }
-        const sri = await fetchIntegrity(href);
+        const sri = await fetchIntegrity(href, options.fetcher ?? fetch);
         if (!sri) {
             failures.push(href);
             return;
@@ -49,18 +63,18 @@ async function processStylesheets(document, failures) {
 function isExternal(url) {
     return url.startsWith('http://') || url.startsWith('https://') || url.startsWith('//');
 }
-async function fetchIntegrity(url) {
+async function fetchIntegrity(url, fetcher) {
     try {
         const normalizedUrl = url.startsWith('//') ? `https:${url}` : url;
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
         try {
-            const response = await fetch(normalizedUrl, { signal: controller.signal });
+            const response = await fetcher(normalizedUrl, { signal: controller.signal });
             if (!response.ok) {
                 return null;
             }
             const arrayBuffer = await response.arrayBuffer();
-            const hash = createHash('sha384').update(Buffer.from(arrayBuffer)).digest('base64');
+            const hash = new Bun.CryptoHasher('sha384').update(Buffer.from(arrayBuffer)).digest('base64');
             return `sha384-${hash}`;
         }
         finally {

package/dist/html/lazyLoad.js

@@ -1,5 +1,5 @@
 const DEFAULT_OPTIONS = {
-    skip: 1
+    skip: 1,
 };
 export function applyLazyLoading(document, options = DEFAULT_OPTIONS) {
     const { skip } = options;

package/dist/html/pageScaffold.js

@@ -10,7 +10,7 @@ export async function createPageScaffold(options) {
     const mode = options.mode ?? 'standard';
     const writes = [
         writeFile(path.join(pageDir, `${FILES.index}${EXTENSIONS.html}`), buildHtmlTemplate(options.pageName, mode)),
-        writeFile(path.join(pageDir, `${FILES.index}${EXTENSIONS.css}`), buildCssTemplate(options.pageName))
+        writeFile(path.join(pageDir, `${FILES.index}${EXTENSIONS.css}`), buildCssTemplate(options.pageName)),
     ];
     if (mode === 'standard') {
         writes.push(writeFile(path.join(pageDir, `${FILES.index}${EXTENSIONS.ts}`), buildScriptTemplate()));

package/dist/html/resourceHints.js

@@ -6,7 +6,7 @@ export function injectResourceHints(document, currentPage, pagesUrlPrefix, useRo
         return {
             added: 0,
             candidates: pages,
-            missingHead: pages.length > 0
+            missingHead: pages.length > 0,
         };
     }
     if (pages.length === 0) {
@@ -35,7 +35,10 @@ function normalizePageName(href, pagesUrlPrefix) {
         return null;
     }
     const lower = href.toLowerCase();
-    if (lower.startsWith('http://') || lower.startsWith('https://') || lower.startsWith('mailto:') || lower.startsWith('#')) {
+    if (lower.startsWith('http://') ||
+        lower.startsWith('https://') ||
+        lower.startsWith('mailto:') ||
+        lower.startsWith('#')) {
         return null;
     }
     let path = href.split('#')[0]?.split('?')[0] ?? '';

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './operations.js';
+export * from './inspect.js';
 export * from './config/manifest.js';
 export * from './config/schema.js';
+export * from './runtime/index.js';
 export * from './types.js';
 export { frontendProvider } from './provider.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from './operations.js';
+export * from './inspect.js';
 export * from './config/manifest.js';
 export * from './config/schema.js';
+export * from './runtime/index.js';
 export * from './types.js';
 export { frontendProvider } from './provider.js';

package/dist/inspect.d.ts

@@ -0,0 +1,2 @@
+import type { FrontendWorkspaceInspectResult } from './types.js';
+export declare function inspectFrontendWorkspace(workspaceRoot: string): Promise<FrontendWorkspaceInspectResult>;

package/dist/inspect.js

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import { FILES, FILE_NAMES } from './core/constants.js';
+import { getPageDirectories } from './core/pages.js';
+import { buildConfig } from './config/workspace.js';
+import { pathExists, readJson } from './utils/fs.js';
+const PAGE_SCRIPT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+export async function inspectFrontendWorkspace(workspaceRoot) {
+    const config = buildConfig(workspaceRoot);
+    const packageJson = await readWorkspacePackageInspect(workspaceRoot);
+    const appShell = await inspectAppShell(config.paths.src.app);
+    const pages = await inspectPages(config.paths.src.pages);
+    const content = await inspectContent(config.paths.src.content);
+    return {
+        workspaceRoot,
+        config,
+        packageJson,
+        appShell,
+        pages,
+        content,
+    };
+}
+async function readWorkspacePackageInspect(workspaceRoot) {
+    const packagePath = path.join(workspaceRoot, FILES.packageJson);
+    const pkg = await readJson(packagePath);
+    const enable = pkg?.webstir?.enable;
+    return {
+        path: packagePath,
+        exists: pkg !== null,
+        mode: pkg?.webstir?.mode,
+        enable: {
+            raw: enable,
+            known: normalizeKnownEnableFlags(enable),
+        },
+    };
+}
+async function inspectAppShell(appRoot) {
+    const templatePath = path.join(appRoot, FILE_NAMES.htmlAppTemplate);
+    const stylesheetPath = path.join(appRoot, 'app.css');
+    const scriptPath = await resolveFirstExistingPath(appRoot, 'app', PAGE_SCRIPT_EXTENSIONS);
+    const [exists, templateExists, stylesheetExists, scriptExists] = await Promise.all([
+        pathExists(appRoot),
+        pathExists(templatePath),
+        pathExists(stylesheetPath),
+        pathExists(scriptPath),
+    ]);
+    return {
+        root: appRoot,
+        exists,
+        templatePath,
+        templateExists,
+        stylesheetPath,
+        stylesheetExists,
+        scriptPath,
+        scriptExists,
+    };
+}
+async function inspectPages(pagesRoot) {
+    const pages = await getPageDirectories(pagesRoot);
+    return await Promise.all(pages.map(async (page) => {
+        const htmlPath = path.join(page.directory, FILES.indexHtml);
+        const stylesheetPath = path.join(page.directory, `${FILES.index}.css`);
+        const scriptPath = await resolveFirstExistingPath(page.directory, FILES.index, PAGE_SCRIPT_EXTENSIONS);
+        const [htmlExists, stylesheetExists, scriptExists] = await Promise.all([
+            pathExists(htmlPath),
+            pathExists(stylesheetPath),
+            pathExists(scriptPath),
+        ]);
+        return {
+            name: page.name,
+            directory: page.directory,
+            htmlPath,
+            htmlExists,
+            stylesheetPath,
+            stylesheetExists,
+            scriptPath,
+            scriptExists,
+        };
+    }));
+}
+async function inspectContent(contentRoot) {
+    const sidebarOverridePath = path.join(contentRoot, '_sidebar.json');
+    const [exists, sidebarOverrideExists] = await Promise.all([
+        pathExists(contentRoot),
+        pathExists(sidebarOverridePath),
+    ]);
+    return {
+        root: contentRoot,
+        exists,
+        sidebarOverridePath,
+        sidebarOverrideExists,
+    };
+}
+async function resolveFirstExistingPath(root, baseName, extensions) {
+    for (const extension of extensions) {
+        const candidate = path.join(root, `${baseName}${extension}`);
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return path.join(root, `${baseName}${extensions[0] ?? ''}`);
+}
+function normalizeKnownEnableFlags(value) {
+    return {
+        spa: value?.spa === true,
+        clientNav: value?.clientNav === true,
+        backend: value?.backend === true,
+        search: value?.search === true,
+        contentNav: value?.contentNav === true,
+    };
+}

package/dist/modes/ssg/metadata.js

@@ -22,7 +22,7 @@ export async function ensureSsgViewMetadataForPage(options) {
         name: viewName,
         path: viewPath,
         renderMode: 'ssg',
-        staticPaths: [viewPath]
+        staticPaths: [viewPath],
     };
     if (existingIndex >= 0) {
         existingViews[existingIndex] = nextView;
@@ -36,9 +36,9 @@ export async function ensureSsgViewMetadataForPage(options) {
             ...webstir,
             moduleManifest: {
                 ...moduleConfig,
-                views: existingViews
-            }
-        }
+                views: existingViews,
+            },
+        },
     };
     await writeJson(pkgPath, nextPkg);
 }

package/dist/modes/ssg/routing.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import { glob } from 'glob';
 import { FOLDERS, FILES } from '../../core/constants.js';
 import { copy, ensureDir, pathExists, readJson } from '../../utils/fs.js';
+import { scanGlob } from '../../utils/glob.js';
 import { getPageDirectories } from '../../core/pages.js';
 import { assertNoSsgRoutesInModuleConfig } from './validation.js';
 import { runSsgSeo } from './seo.js';
@@ -53,10 +53,7 @@ async function applyDocsContentAliases(distRoot, distPagesRoot) {
     if (!(await pathExists(docsRoot))) {
         return;
     }
-    const indexes = await glob('docs/**/index.html', {
-        cwd: distPagesRoot,
-        nodir: true
-    });
+    const indexes = await scanGlob('docs/**/index.html', { cwd: distPagesRoot });
     for (const relativeIndex of indexes) {
         const sourceIndex = path.join(distPagesRoot, relativeIndex);
         if (!(await pathExists(sourceIndex))) {

package/dist/modes/ssg/seo.js

@@ -1,8 +1,8 @@
 import path from 'node:path';
-import { glob } from 'glob';
 import { load } from 'cheerio';
 import { ensureDir, pathExists, readFile, writeFile } from '../../utils/fs.js';
 import { FILES } from '../../core/constants.js';
+import { scanGlob } from '../../utils/glob.js';
 export async function runSsgSeo(distRoot, options = {}) {
     const pages = await discoverHtmlPages(distRoot);
     await validateInternalLinks(pages, distRoot);
@@ -13,14 +13,14 @@ async function discoverHtmlPages(distRoot) {
     if (!(await pathExists(distRoot))) {
         return [];
     }
-    const files = await glob('**/index.html', { cwd: distRoot, nodir: true, ignore: ['pages/**'] });
+    const files = (await scanGlob('**/index.html', { cwd: distRoot })).filter((relative) => !relative.split(path.sep).join('/').startsWith('pages/'));
     const pages = files
         .map((relative) => {
         const normalized = relative.split(path.sep).join('/');
         const urlPath = toUrlPath(normalized);
         return {
             filePath: path.join(distRoot, relative),
-            urlPath
+            urlPath,
         };
     })
         .filter((page) => Boolean(page.urlPath));
@@ -165,10 +165,10 @@ async function writeSitemap(distRoot, pages, siteUrl) {
         .join('\n');
     const xml = [
         '<?xml version="1.0" encoding="UTF-8"?>',
-        comment + '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        `${comment}<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">`,
         entries,
         '</urlset>',
-        ''
+        '',
     ].join('\n');
     const outputPath = path.join(distRoot, 'sitemap.xml');
     await ensureDir(path.dirname(outputPath));