@stati/core 1.27.2 → 1.29.0

package/dist/core/utils/paths.utils.js

@@ -183,3 +183,23 @@ export function isPathWithinDirectory(baseDir, targetPath) {
     // We also allow exact match (resolvedTarget === resolvedBase) for the root
     return resolvedTarget === resolvedBase || resolvedTarget.startsWith(normalizedBase);
 }
+/**
+ * The file a page URL is written to, relative to the output directory. The build joins it to
+ * the output directory, which also normalizes separators and `.` segments.
+ *
+ * @param url - The page URL
+ * @returns The output file
+ *
+ * @example
+ * ```typescript
+ * getPageOutputFile('/');          // 'index.html'
+ * getPageOutputFile('/blog/');     // '/blog/index.html'
+ * getPageOutputFile('/blog/post'); // '/blog/post.html'
+ * ```
+ */
+export function getPageOutputFile(url) {
+    if (url === '/') {
+        return 'index.html';
+    }
+    return url.endsWith('/') ? `${url}index.html` : `${url}.html`;
+}

package/dist/core/utils/template-discovery.utils.d.ts

@@ -1,13 +1,37 @@
 import type { StatiConfig, PageModel } from '../../types/index.js';
+/**
+ * Shared template discovery utilities.
+ * Extracted from templates.ts and isg/deps.ts to eliminate duplication.
+ */
+/**
+ * Whether a page was created by Stati rather than loaded from a Markdown file: a page expanded
+ * from a `[param].md` template, or page 2 or later of a paginated listing.
+ *
+ * Virtual pages are never collection members, never make a folder a collection, and are left
+ * out of navigation, search and RSS unless they opt in.
+ *
+ * @param page - The page to check
+ * @returns True for generated pages and for pagination pages after the first
+ */
+export declare function isVirtualPage(page: PageModel): boolean;
+/**
+ * Finds the first page of a paginated listing, which later pages render like.
+ *
+ * @param page - A page with `pagination`
+ * @param allPages - All pages in the site
+ * @returns The listing's first page, or undefined when it is not in the list
+ */
+export declare function getFirstPaginationPage(page: PageModel, allPages: PageModel[]): PageModel | undefined;
 /**
  * Determines if the given page is a collection index page.
  * A collection index page is one whose URL matches a directory path that contains other pages.
+ * Generated pages never are; pagination pages after the first are when their first page is.
  *
  * Rendering and ISG dependency tracking must both call this with the same page list,
  * otherwise they can pick different layouts for the same page.
  *
  * Page URLs are read once per `allPages` array, at the first call; see
- * `directoryPrefixCache` for when changes to the pages are picked up.
+ * `pageListCache` for when changes to the pages are picked up.
  *
  * @param page - The page to check
  * @param allPages - All pages in the site (treated as unchanging after the first call)

package/dist/core/utils/template-discovery.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-discovery.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-discovery.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAoDnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAUrF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBhE"}
+{"version":3,"file":"template-discovery.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-discovery.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAInE;;;GAGG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEtD;AAiED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,SAAS,EAAE,GACpB,SAAS,GAAG,SAAS,CAMvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAoBrF;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsDxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBhE"}

package/dist/core/utils/template-discovery.utils.js

@@ -2,6 +2,23 @@ import { join, dirname, posix } from 'node:path';
 import { pathExists } from './fs.utils.js';
 import { LAYOUT_TEMPLATE } from '../../constants.js';
 import { resolveSrcDir } from './paths.utils.js';
+/**
+ * Shared template discovery utilities.
+ * Extracted from templates.ts and isg/deps.ts to eliminate duplication.
+ */
+/**
+ * Whether a page was created by Stati rather than loaded from a Markdown file: a page expanded
+ * from a `[param].md` template, or page 2 or later of a paginated listing.
+ *
+ * Virtual pages are never collection members, never make a folder a collection, and are left
+ * out of navigation, search and RSS unless they opt in.
+ *
+ * @param page - The page to check
+ * @returns True for generated pages and for pagination pages after the first
+ */
+export function isVirtualPage(page) {
+    return page.generated !== undefined || (page.pagination?.pageNumber ?? 1) > 1;
+}
 /**
  * Directory prefix index per page list, so a build computes it once instead of
  * scanning every page for every page.
@@ -13,51 +30,84 @@ import { resolveSrcDir } from './paths.utils.js';
  * loads a new array and gets a new snapshot. Taking one snapshot keeps rendering and
  * ISG dependency tracking in agreement for the whole build.
  */
-const directoryPrefixCache = new WeakMap();
-function getDirectoryPrefixIndex(allPages) {
-    const cached = directoryPrefixCache.get(allPages);
+const pageListCache = new WeakMap();
+function getPageListIndex(allPages) {
+    const cached = pageListCache.get(allPages);
     if (cached) {
         return cached;
     }
-    const index = new Map();
-    for (const { url } of allPages) {
+    const prefixes = new Map();
+    const byUrl = new Map();
+    for (const page of allPages) {
+        if (!byUrl.has(page.url)) {
+            byUrl.set(page.url, page);
+        }
+        // Generated and pagination pages don't turn the folders they live in into collections
+        if (isVirtualPage(page)) {
+            continue;
+        }
+        const { url } = page;
         // Every prefix ending at a '/' is a directory this URL lives in (or is, for trailing-slash URLs)
         for (let i = url.indexOf('/'); i !== -1; i = url.indexOf('/', i + 1)) {
             const prefix = url.slice(0, i + 1);
-            const existing = index.get(prefix);
+            const existing = prefixes.get(prefix);
             if (existing === undefined) {
-                index.set(prefix, url);
+                prefixes.set(prefix, url);
             }
             else if (existing !== null && existing !== url) {
-                index.set(prefix, null);
+                prefixes.set(prefix, null);
             }
         }
     }
-    directoryPrefixCache.set(allPages, index);
+    const index = { prefixes, byUrl };
+    pageListCache.set(allPages, index);
     return index;
 }
+/**
+ * Finds the first page of a paginated listing, which later pages render like.
+ *
+ * @param page - A page with `pagination`
+ * @param allPages - All pages in the site
+ * @returns The listing's first page, or undefined when it is not in the list
+ */
+export function getFirstPaginationPage(page, allPages) {
+    const firstUrl = page.pagination?.urls[0];
+    if (firstUrl === undefined || firstUrl === page.url) {
+        return undefined;
+    }
+    return getPageListIndex(allPages).byUrl.get(firstUrl);
+}
 /**
  * Determines if the given page is a collection index page.
  * A collection index page is one whose URL matches a directory path that contains other pages.
+ * Generated pages never are; pagination pages after the first are when their first page is.
  *
  * Rendering and ISG dependency tracking must both call this with the same page list,
  * otherwise they can pick different layouts for the same page.
  *
  * Page URLs are read once per `allPages` array, at the first call; see
- * `directoryPrefixCache` for when changes to the pages are picked up.
+ * `pageListCache` for when changes to the pages are picked up.
  *
  * @param page - The page to check
  * @param allPages - All pages in the site (treated as unchanging after the first call)
  * @returns True if the page is a collection index page
  */
 export function isCollectionIndexPage(page, allPages) {
+    if (page.generated) {
+        return false;
+    }
+    // Later pages of a listing render with the layout of its first page
+    if ((page.pagination?.pageNumber ?? 1) > 1) {
+        const first = getFirstPaginationPage(page, allPages);
+        return first !== undefined && !isVirtualPage(first) && isCollectionIndexPage(first, allPages);
+    }
     // Root index page is always a collection index
     if (page.url === '/') {
         return true;
     }
     // The page is an index when a different page's URL lives under this page's URL as a directory
     const pageUrlAsDir = page.url.endsWith('/') ? page.url : page.url + '/';
-    const containingUrl = getDirectoryPrefixIndex(allPages).get(pageUrlAsDir);
+    const containingUrl = getPageListIndex(allPages).prefixes.get(pageUrlAsDir);
     return containingUrl === null || (containingUrl !== undefined && containingUrl !== page.url);
 }
 /**

package/dist/images/config.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Validation and defaults for the `images` configuration block.
+ * @module images/config
+ */
+import type { ImageVariantFormat, OgImageFontConfig, StatiConfig } from '../types/index.js';
+/** Responsive image options with defaults applied. */
+export interface ResolvedResponsiveConfig {
+    /** Candidate widths, ascending and unique */
+    widths: number[];
+    formats: ImageVariantFormat[];
+    quality: {
+        avif: number;
+        webp: number;
+        jpeg: number;
+        png?: number;
+    };
+    sizes: string;
+}
+/** Open Graph image options with defaults applied. */
+export interface ResolvedOgConfig {
+    template: string;
+    width: number;
+    height: number;
+    format: 'png' | 'jpeg';
+    fonts: OgImageFontConfig[];
+    exclude: string[];
+}
+/** The `images` block with defaults applied. */
+export interface ResolvedImagesConfig {
+    eagerFirst: boolean;
+    /** `null` when responsive images are off */
+    responsive: ResolvedResponsiveConfig | null;
+    /** `null` when Open Graph images are off */
+    og: ResolvedOgConfig | null;
+    dev: 'fast' | 'full';
+}
+/**
+ * Validates the `images` configuration block.
+ *
+ * @param images - The `images` value from the config
+ * @throws {ConfigValidationError} When an option has the wrong type or value
+ */
+export declare function validateImagesConfig(images: unknown): void;
+/**
+ * Applies defaults to the `images` configuration block.
+ * Expects a block that passed {@link validateImagesConfig}.
+ *
+ * @param images - The `images` value from the config
+ * @returns The resolved options, or `null` when images are turned off with `images: false`
+ */
+export declare function resolveImagesConfig(images: StatiConfig['images']): ResolvedImagesConfig | null;
+//# sourceMappingURL=config.d.ts.map

package/dist/images/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/images/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAY5F,sDAAsD;AACtD,MAAM,WAAW,wBAAwB;IACvC,6CAA6C;IAC7C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,sDAAsD;AACtD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,gDAAgD;AAChD,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,4CAA4C;IAC5C,UAAU,EAAE,wBAAwB,GAAG,IAAI,CAAC;IAC5C,4CAA4C;IAC5C,EAAE,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC5B,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB;AA6JD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAqB1D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,oBAAoB,GAAG,IAAI,CA0C9F"}

package/dist/images/config.js

@@ -0,0 +1,200 @@
+/**
+ * Validation and defaults for the `images` configuration block.
+ * @module images/config
+ */
+import { ConfigValidationError } from '../config/errors.js';
+import { DEFAULT_IMAGE_FORMATS, DEFAULT_IMAGE_QUALITY, DEFAULT_IMAGE_SIZES, DEFAULT_IMAGE_WIDTHS, DEFAULT_OG_HEIGHT, DEFAULT_OG_TEMPLATE, DEFAULT_OG_WIDTH, } from '../constants.js';
+const IMAGES_KEYS = ['eagerFirst', 'responsive', 'og', 'dev'];
+const RESPONSIVE_KEYS = ['widths', 'formats', 'quality', 'sizes'];
+const QUALITY_KEYS = ['avif', 'webp', 'jpeg', 'png'];
+const OG_KEYS = ['template', 'width', 'height', 'format', 'fonts', 'exclude'];
+const FONT_KEYS = ['name', 'path', 'weight', 'style'];
+const VARIANT_FORMATS = ['avif', 'webp'];
+const MAX_IMAGE_WIDTH = 16384;
+const MAX_OG_SIZE = 4096;
+function fail(message) {
+    throw new ConfigValidationError(message);
+}
+function describe(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function checkKeys(value, allowed, path) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            fail(`Unknown option ${path}.${key}. Allowed options: ${allowed.join(', ')}.`);
+        }
+    }
+}
+function isIntegerInRange(value, min, max) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= min && value <= max;
+}
+function validateResponsive(value) {
+    if (typeof value === 'boolean')
+        return;
+    if (!isPlainObject(value)) {
+        fail(`images.responsive must be true, false or an object (got ${describe(value)}).`);
+    }
+    checkKeys(value, RESPONSIVE_KEYS, 'images.responsive');
+    if (value.widths !== undefined) {
+        if (!Array.isArray(value.widths) ||
+            value.widths.length === 0 ||
+            !value.widths.every((w) => isIntegerInRange(w, 1, MAX_IMAGE_WIDTH))) {
+            fail(`images.responsive.widths must be a non-empty array of whole pixel widths between 1 and ${MAX_IMAGE_WIDTH} (got ${describe(value.widths)}).`);
+        }
+    }
+    if (value.formats !== undefined) {
+        if (!Array.isArray(value.formats) ||
+            !value.formats.every((f) => typeof f === 'string' && VARIANT_FORMATS.includes(f))) {
+            fail(`images.responsive.formats must be an array of 'avif' and 'webp' (got ${describe(value.formats)}).`);
+        }
+    }
+    if (value.quality !== undefined) {
+        if (!isPlainObject(value.quality)) {
+            fail(`images.responsive.quality must be an object (got ${describe(value.quality)}).`);
+        }
+        checkKeys(value.quality, QUALITY_KEYS, 'images.responsive.quality');
+        for (const [format, quality] of Object.entries(value.quality)) {
+            if (quality !== undefined && !isIntegerInRange(quality, 1, 100)) {
+                fail(`images.responsive.quality.${format} must be a whole number between 1 and 100 (got ${describe(quality)}).`);
+            }
+        }
+    }
+    if (value.sizes !== undefined && (typeof value.sizes !== 'string' || !value.sizes.trim())) {
+        fail(`images.responsive.sizes must be a non-empty string (got ${describe(value.sizes)}).`);
+    }
+}
+function validateFont(font, index) {
+    const path = `images.og.fonts[${index}]`;
+    if (!isPlainObject(font)) {
+        fail(`${path} must be an object with name and path (got ${describe(font)}).`);
+    }
+    checkKeys(font, FONT_KEYS, path);
+    if (typeof font.name !== 'string' || !font.name.trim()) {
+        fail(`${path}.name must be a non-empty string.`);
+    }
+    if (typeof font.path !== 'string' || !font.path.trim()) {
+        fail(`${path}.path must be a non-empty string.`);
+    }
+    if (font.weight !== undefined && !isIntegerInRange(font.weight, 100, 900)) {
+        fail(`${path}.weight must be a whole number between 100 and 900 (got ${describe(font.weight)}).`);
+    }
+    if (font.style !== undefined && font.style !== 'normal' && font.style !== 'italic') {
+        fail(`${path}.style must be 'normal' or 'italic' (got ${describe(font.style)}).`);
+    }
+}
+function validateOg(value) {
+    if (typeof value === 'boolean')
+        return;
+    if (!isPlainObject(value)) {
+        fail(`images.og must be true, false or an object (got ${describe(value)}).`);
+    }
+    checkKeys(value, OG_KEYS, 'images.og');
+    if (value.template !== undefined) {
+        if (typeof value.template !== 'string' ||
+            !value.template.endsWith('.eta') ||
+            /[/\\]/.test(value.template)) {
+            fail(`images.og.template must be a file name ending in .eta, such as 'og.eta' (got ${describe(value.template)}).`);
+        }
+    }
+    for (const dimension of ['width', 'height']) {
+        if (value[dimension] !== undefined && !isIntegerInRange(value[dimension], 1, MAX_OG_SIZE)) {
+            fail(`images.og.${dimension} must be a whole number of pixels between 1 and ${MAX_OG_SIZE} (got ${describe(value[dimension])}).`);
+        }
+    }
+    if (value.format !== undefined && value.format !== 'png' && value.format !== 'jpeg') {
+        fail(`images.og.format must be 'png' or 'jpeg' (got ${describe(value.format)}).`);
+    }
+    if (value.fonts !== undefined) {
+        if (!Array.isArray(value.fonts)) {
+            fail(`images.og.fonts must be an array (got ${describe(value.fonts)}).`);
+        }
+        value.fonts.forEach(validateFont);
+    }
+    if (value.exclude !== undefined) {
+        if (!Array.isArray(value.exclude) || !value.exclude.every((p) => typeof p === 'string')) {
+            fail(`images.og.exclude must be an array of URL glob patterns (got ${describe(value.exclude)}).`);
+        }
+    }
+}
+/**
+ * Validates the `images` configuration block.
+ *
+ * @param images - The `images` value from the config
+ * @throws {ConfigValidationError} When an option has the wrong type or value
+ */
+export function validateImagesConfig(images) {
+    if (images === undefined || images === false) {
+        return;
+    }
+    if (!isPlainObject(images)) {
+        fail(`images must be an object or false (got ${describe(images)}).`);
+    }
+    checkKeys(images, IMAGES_KEYS, 'images');
+    if (images.eagerFirst !== undefined && typeof images.eagerFirst !== 'boolean') {
+        fail(`images.eagerFirst must be true or false (got ${describe(images.eagerFirst)}).`);
+    }
+    if (images.dev !== undefined && images.dev !== 'fast' && images.dev !== 'full') {
+        fail(`images.dev must be 'fast' or 'full' (got ${describe(images.dev)}).`);
+    }
+    if (images.responsive !== undefined) {
+        validateResponsive(images.responsive);
+    }
+    if (images.og !== undefined) {
+        validateOg(images.og);
+    }
+}
+/**
+ * Applies defaults to the `images` configuration block.
+ * Expects a block that passed {@link validateImagesConfig}.
+ *
+ * @param images - The `images` value from the config
+ * @returns The resolved options, or `null` when images are turned off with `images: false`
+ */
+export function resolveImagesConfig(images) {
+    if (images === false) {
+        return null;
+    }
+    const config = images ?? {};
+    let responsive = null;
+    if (config.responsive) {
+        const options = config.responsive === true ? {} : config.responsive;
+        const quality = options.quality ?? {};
+        responsive = {
+            widths: [...new Set(options.widths ?? DEFAULT_IMAGE_WIDTHS)].sort((a, b) => a - b),
+            formats: [...new Set(options.formats ?? DEFAULT_IMAGE_FORMATS)],
+            quality: {
+                avif: quality.avif ?? DEFAULT_IMAGE_QUALITY.avif,
+                webp: quality.webp ?? DEFAULT_IMAGE_QUALITY.webp,
+                jpeg: quality.jpeg ?? DEFAULT_IMAGE_QUALITY.jpeg,
+                ...(quality.png !== undefined && { png: quality.png }),
+            },
+            sizes: options.sizes ?? DEFAULT_IMAGE_SIZES,
+        };
+    }
+    let og = null;
+    if (config.og) {
+        const options = config.og === true ? {} : config.og;
+        og = {
+            template: options.template ?? DEFAULT_OG_TEMPLATE,
+            width: options.width ?? DEFAULT_OG_WIDTH,
+            height: options.height ?? DEFAULT_OG_HEIGHT,
+            format: options.format ?? 'png',
+            fonts: options.fonts ?? [],
+            exclude: options.exclude ?? [],
+        };
+    }
+    return {
+        eagerFirst: config.eagerFirst ?? true,
+        responsive,
+        og,
+        dev: config.dev ?? 'fast',
+    };
+}

package/dist/images/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Image pipeline exports
+ * Intrinsic sizes, lazy loading and co-located images in core, plus the plumbing for
+ * responsive variants and Open Graph images rendered by `@stati/images`.
+ */
+export { resolveImagesConfig, validateImagesConfig } from './config.js';
+export type { ResolvedImagesConfig, ResolvedResponsiveConfig, ResolvedOgConfig } from './config.js';
+export { ImageRuntime, PageImages, validateOgBaseUrl } from './runtime.js';
+export type { StatiImageOptions, SettleResult, ImageRuntimeOptions } from './runtime.js';
+export { installImageRule, selectEagerImage } from './markdown-rule.js';
+export { findOgTemplatePath, clearOgTemplateCache } from './og.js';
+export { loadImageProvider, resolveImagesPackage, missingPackageMessage } from './provider.js';
+export { probeImage } from './utils/index.js';
+export type { ImageProbeResult } from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/images/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/images/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxE,YAAY,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/images/index.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Image pipeline exports
+ * Intrinsic sizes, lazy loading and co-located images in core, plus the plumbing for
+ * responsive variants and Open Graph images rendered by `@stati/images`.
+ */
+export { resolveImagesConfig, validateImagesConfig } from './config.js';
+export { ImageRuntime, PageImages, validateOgBaseUrl } from './runtime.js';
+export { installImageRule, selectEagerImage } from './markdown-rule.js';
+export { findOgTemplatePath, clearOgTemplateCache } from './og.js';
+export { loadImageProvider, resolveImagesPackage, missingPackageMessage } from './provider.js';
+export { probeImage } from './utils/index.js';

package/dist/images/manifest.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The images manifest, `.stati/images/manifest.json`: which files each image job produced,
+ * and cached hashes and probes of source images.
+ * @module images/manifest
+ */
+import type { SourceInfo } from './sources.js';
+/**
+ * Persisted state of the image pipeline.
+ */
+export interface ImagesManifest {
+    version: number;
+    /** Cached facts about source images, keyed by absolute path */
+    sources: Record<string, SourceInfo>;
+    /** Files each job wrote, relative to the output directory, keyed by job key */
+    outputs: Record<string, {
+        files: string[];
+    }>;
+}
+/**
+ * Creates an empty images manifest.
+ */
+export declare function createEmptyImagesManifest(): ImagesManifest;
+/**
+ * Path of the images manifest inside the cache directory.
+ */
+export declare function getImagesManifestPath(cacheDir: string): string;
+/**
+ * Loads the images manifest. A missing, unreadable or outdated manifest yields an empty one,
+ * which only means images are checked again.
+ */
+export declare function loadImagesManifest(cacheDir: string): Promise<ImagesManifest>;
+/**
+ * Saves the images manifest.
+ */
+export declare function saveImagesManifest(cacheDir: string, manifest: ImagesManifest): Promise<void>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/images/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/images/manifest.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAK/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC9C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,cAAc,CAE1D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;AAMD;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAqClF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC,CAIf"}

package/dist/images/manifest.js

@@ -0,0 +1,69 @@
+/**
+ * The images manifest, `.stati/images/manifest.json`: which files each image job produced,
+ * and cached hashes and probes of source images.
+ * @module images/manifest
+ */
+import { join } from 'node:path';
+import { ensureDir, readFile, writeFile } from '../core/utils/index.js';
+import { IMAGES_CACHE_SUBDIR, MANIFEST_FILENAME } from '../constants.js';
+/** Bumped when the manifest layout changes; older manifests are discarded. */
+const IMAGES_MANIFEST_VERSION = 1;
+/**
+ * Creates an empty images manifest.
+ */
+export function createEmptyImagesManifest() {
+    return { version: IMAGES_MANIFEST_VERSION, sources: {}, outputs: {} };
+}
+/**
+ * Path of the images manifest inside the cache directory.
+ */
+export function getImagesManifestPath(cacheDir) {
+    return join(cacheDir, IMAGES_CACHE_SUBDIR, MANIFEST_FILENAME);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+/**
+ * Loads the images manifest. A missing, unreadable or outdated manifest yields an empty one,
+ * which only means images are checked again.
+ */
+export async function loadImagesManifest(cacheDir) {
+    try {
+        const content = await readFile(getImagesManifestPath(cacheDir));
+        if (!content)
+            return createEmptyImagesManifest();
+        const parsed = JSON.parse(content);
+        if (parsed?.version !== IMAGES_MANIFEST_VERSION ||
+            typeof parsed.sources !== 'object' ||
+            typeof parsed.outputs !== 'object') {
+            return createEmptyImagesManifest();
+        }
+        const outputs = {};
+        for (const [key, record] of Object.entries(parsed.outputs ?? {})) {
+            if (record && isStringArray(record.files)) {
+                outputs[key] = { files: record.files };
+            }
+        }
+        const sources = {};
+        for (const [path, info] of Object.entries(parsed.sources ?? {})) {
+            if (info &&
+                typeof info.size === 'number' &&
+                typeof info.mtimeMs === 'number' &&
+                typeof info.hash === 'string') {
+                sources[path] = info;
+            }
+        }
+        return { version: IMAGES_MANIFEST_VERSION, sources, outputs };
+    }
+    catch {
+        return createEmptyImagesManifest();
+    }
+}
+/**
+ * Saves the images manifest.
+ */
+export async function saveImagesManifest(cacheDir, manifest) {
+    const path = getImagesManifestPath(cacheDir);
+    await ensureDir(join(cacheDir, IMAGES_CACHE_SUBDIR));
+    await writeFile(path, JSON.stringify(manifest, null, 2), 'utf-8');
+}

package/dist/images/markdown-rule.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The markdown-it `image` rule that adds dimensions, lazy loading and responsive variants.
+ * @module images/markdown-rule
+ */
+import type MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token.mjs';
+/** Key of the page's image state in the markdown-it `env`. */
+export declare const IMAGES_ENV_KEY = "statiImages";
+/**
+ * Installs the image rule. It holds no per-page state: each render passes its page's image
+ * state in `env`, and renders without it fall through to the previous rule. Installed before
+ * plugins and `markdown.configure`, so a custom image rule there replaces it.
+ *
+ * @param md - The markdown-it instance
+ */
+export declare function installImageRule(md: MarkdownIt): void;
+/**
+ * Picks the image `eagerFirst` loads eagerly: the document's first image, when it sits in
+ * one of the first top-level blocks. A first image further down is not the page's largest
+ * contentful paint, so it stays lazy.
+ *
+ * @param tokens - Parsed block tokens
+ * @returns The image token, or undefined
+ */
+export declare function selectEagerImage(tokens: Token[]): Token | undefined;
+//# sourceMappingURL=markdown-rule.d.ts.map

package/dist/images/markdown-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-rule.d.ts","sourceRoot":"","sources":["../../src/images/markdown-rule.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,UAAU,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,2BAA2B,CAAC;AAGnD,8DAA8D;AAC9D,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAO5C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAwBrD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,SAAS,CAanE"}