@t09tanaka/stoneage 0.1.0

package/dist/images.js

@@ -0,0 +1,292 @@
+import { mkdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { publicAssetOutputPath } from "./paths.js";
+/**
+ * Number of distinct source images that could not be optimized because no image
+ * converter (sharp) was available. Lets callers surface an actionable warning
+ * instead of silently shipping unoptimized images.
+ */
+export function countConverterUnavailable(result) {
+    const sources = new Set();
+    for (const skipped of result.skipped) {
+        if (skipped.reason === "converter-unavailable") {
+            sources.add(skipped.source);
+        }
+    }
+    return sources.size;
+}
+/**
+ * Resolve whether the optional `sharp` dependency can be loaded in the current
+ * environment. Returns false when sharp is not installed or its native binary
+ * is unavailable for the current platform.
+ */
+export async function isSharpAvailable(loadConverter = loadSharpConverter) {
+    return Boolean(await loadConverter());
+}
+export async function optimizeImages(options) {
+    const skipped = [];
+    const widths = [...new Set(options.widths)].sort((left, right) => left - right);
+    const variantTasks = [];
+    let converter = options.converter;
+    let converterLoaded = Boolean(converter);
+    async function getConverter() {
+        if (!converterLoaded) {
+            converterLoaded = true;
+            converter = options.loadConverter ? await options.loadConverter() : await loadSharpConverter();
+        }
+        return converter;
+    }
+    for (const image of options.images) {
+        if (!isResizableInput(image.source)) {
+            skipped.push({ source: image.source, reason: "unsupported-format" });
+            continue;
+        }
+        const sourceStats = options.skipExisting ? await stat(image.source) : undefined;
+        for (const format of options.formats) {
+            for (const width of widths) {
+                const publicPath = variantPublicPath(image.publicPath, width, format);
+                const outputPath = join(options.outDir, publicAssetOutputPath(publicPath));
+                if (sourceStats) {
+                    const existingStats = await currentExistingVariant(outputPath, sourceStats.mtimeMs);
+                    if (existingStats) {
+                        skipped.push({
+                            source: image.source,
+                            publicPath,
+                            width,
+                            format,
+                            bytes: existingStats.size,
+                            reason: "existing-current",
+                        });
+                        continue;
+                    }
+                }
+                variantTasks.push({
+                    image,
+                    publicPath,
+                    outputPath,
+                    width,
+                    format,
+                });
+            }
+        }
+    }
+    if (variantTasks.length === 0) {
+        return {
+            generated: [],
+            skipped,
+        };
+    }
+    const resolvedConverter = await getConverter();
+    if (!resolvedConverter) {
+        const skippedSources = new Set();
+        for (const task of variantTasks) {
+            if (skippedSources.has(task.image.source)) {
+                continue;
+            }
+            skippedSources.add(task.image.source);
+            skipped.push({
+                source: task.image.source,
+                reason: "converter-unavailable",
+            });
+        }
+        return {
+            generated: [],
+            skipped,
+        };
+    }
+    const generated = await mapConcurrent(variantTasks, 8, async (task) => {
+        await mkdir(dirname(task.outputPath), { recursive: true });
+        await resolvedConverter({
+            source: task.image.source,
+            outputPath: task.outputPath,
+            width: task.width,
+            format: task.format,
+        });
+        return {
+            source: task.image.source,
+            publicPath: task.publicPath,
+            width: task.width,
+            format: task.format,
+            bytes: (await stat(task.outputPath)).size,
+        };
+    });
+    return {
+        generated,
+        skipped,
+    };
+}
+async function mapConcurrent(items, concurrency, worker) {
+    const limit = Math.max(1, Math.floor(concurrency));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await worker(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+    return results;
+}
+export function imagesForSource(resultOrImages, sourceOrPublicPath) {
+    const images = Array.isArray(resultOrImages) ? resultOrImages : resultOrImages.generated;
+    return images.filter((image) => image.source === sourceOrPublicPath ||
+        image.publicPath === sourceOrPublicPath ||
+        image.publicPath === variantPublicPath(sourceOrPublicPath, image.width, image.format));
+}
+export function srcsetFor(images) {
+    return images
+        .slice()
+        .sort((left, right) => left.width - right.width)
+        .map((image) => `${image.publicPath} ${image.width}w`)
+        .join(", ");
+}
+export function pictureSourcesFor(images, formats = ["avif", "webp", "jpeg", "png"]) {
+    return formats
+        .map((format) => {
+        const srcset = srcsetFor(images.filter((image) => image.format === format));
+        return srcset
+            ? {
+                format,
+                type: `image/${format}`,
+                srcset,
+            }
+            : undefined;
+    })
+        .filter((source) => Boolean(source));
+}
+export function pictureAttrsFor(images, fallback) {
+    const fallbackImage = selectFallbackImage(images, fallback.fallbackFormat);
+    const sources = pictureSourcesFor(images.filter((image) => image.format !== fallbackImage?.format), fallback.formats).map((source) => withOptionalSizes(source, fallback.sizes));
+    return {
+        sources,
+        img: {
+            src: fallbackImage?.publicPath ?? fallback.src,
+            ...(fallbackImage
+                ? { srcset: srcsetFor(images.filter((image) => image.format === fallbackImage.format)) }
+                : {}),
+            ...optionalSizes(fallback.sizes),
+            width: fallback.width,
+            height: fallback.height,
+            ...(fallback.loading ? { loading: fallback.loading } : {}),
+            ...(fallback.decoding ? { decoding: fallback.decoding } : {}),
+            alt: fallback.alt,
+        },
+    };
+}
+export function pictureHtmlFor(images, fallback) {
+    return renderPicture(pictureAttrsFor(images, fallback));
+}
+export function renderPicture(attrs) {
+    const sources = attrs.sources
+        .map((source) => renderElement("source", [
+        ["type", source.type],
+        ["srcset", source.srcset],
+        ["sizes", source.sizes],
+    ]))
+        .join("");
+    const img = renderElement("img", [
+        ["src", attrs.img.src],
+        ["srcset", attrs.img.srcset],
+        ["sizes", attrs.img.sizes],
+        ["width", attrs.img.width],
+        ["height", attrs.img.height],
+        ["loading", attrs.img.loading],
+        ["decoding", attrs.img.decoding],
+        ["alt", attrs.img.alt],
+    ]);
+    return `<picture>${sources}${img}</picture>`;
+}
+export async function loadSharpConverter() {
+    // Escape hatch (primarily for tests) to simulate a missing optional sharp
+    // dependency without uninstalling it.
+    if (process.env.STONEAGE_DISABLE_SHARP) {
+        return undefined;
+    }
+    try {
+        const importOptional = new Function("specifier", "return import(specifier)");
+        const mod = (await importOptional("sharp"));
+        return async ({ source, outputPath, width, format }) => {
+            await mod.default(source).resize(width).toFormat(format).toFile(outputPath);
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function variantPublicPath(publicPath, width, format) {
+    const cleanPath = publicPath.split(/[?#]/, 1)[0] ?? publicPath;
+    const extension = extname(cleanPath);
+    const base = cleanPath.slice(0, cleanPath.length - extension.length);
+    return `${base}-${width}.${format}`;
+}
+async function currentExistingVariant(outputPath, sourceMtimeMs) {
+    try {
+        const outputStats = await stat(outputPath);
+        return outputStats.mtimeMs >= sourceMtimeMs ? outputStats : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isResizableInput(path) {
+    const extension = extname(basename(path)).toLowerCase();
+    return extension === ".jpg" || extension === ".jpeg" || extension === ".png" || extension === ".webp";
+}
+function selectFallbackImage(images, fallbackFormat) {
+    if (fallbackFormat) {
+        const preferred = largestImageForFormat(images, fallbackFormat);
+        if (preferred) {
+            return preferred;
+        }
+    }
+    return images.reduce((selected, image) => {
+        if (!selected || image.width > selected.width) {
+            return image;
+        }
+        return selected;
+    }, undefined);
+}
+function largestImageForFormat(images, format) {
+    return images.reduce((selected, image) => {
+        if (image.format !== format) {
+            return selected;
+        }
+        if (!selected || image.width > selected.width) {
+            return image;
+        }
+        return selected;
+    }, undefined);
+}
+function withOptionalSizes(source, sizes) {
+    return { ...source, ...optionalSizes(sizes) };
+}
+function optionalSizes(sizes) {
+    return sizes === undefined ? {} : { sizes };
+}
+function renderElement(name, attrs) {
+    const renderedAttrs = attrs
+        .filter((attr) => attr[1] !== undefined)
+        .map(([attrName, value]) => `${attrName}="${escapeAttributeValue(String(value))}"`)
+        .join(" ");
+    return `<${name}${renderedAttrs ? ` ${renderedAttrs}` : ""}>`;
+}
+function escapeAttributeValue(value) {
+    return value.replace(/[&<>"']/g, (character) => {
+        switch (character) {
+            case "&":
+                return "&amp;";
+            case "<":
+                return "&lt;";
+            case ">":
+                return "&gt;";
+            case '"':
+                return "&quot;";
+            case "'":
+                return "&#39;";
+            default:
+                return character;
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/migration.d.ts

@@ -0,0 +1,157 @@
+export type SvelteKitAuditOptions = {
+    routesDir: string;
+    paramsDir?: string;
+    migrationPlan?: boolean;
+};
+export type SvelteKitAuditReport = {
+    version: 1;
+    routesDir: string;
+    paramsDir?: string;
+    pages: SvelteKitPageAudit[];
+    endpoints: SvelteKitEndpointAudit[];
+    params: SvelteKitParamMatcherAudit[];
+    warnings: SvelteKitAuditWarning[];
+    migrationInventory: SvelteKitMigrationInventory;
+    migrationPlan?: SvelteKitMigrationPlan;
+    summary: {
+        pages: number;
+        endpoints: number;
+        dynamicRoutes: number;
+        endpointKinds: Partial<Record<SvelteKitEndpointKind, number>>;
+        warnings: number;
+    };
+};
+export type SvelteKitMigrationInventory = {
+    layouts: SvelteKitLayoutInventory[];
+    routeFiles: SvelteKitRouteFileInventory[];
+    componentHints: SvelteKitComponentHint[];
+    checklist: SvelteKitMigrationChecklistCategory[];
+};
+export type SvelteKitLayoutInventory = {
+    routePath: string;
+    file: string;
+    kind: "layout" | "layoutServer" | "layoutUniversal";
+    imports: string[];
+    components: string[];
+    layoutReset?: true;
+};
+export type SvelteKitRouteFileInventory = {
+    routePath: string;
+    file: string;
+    kind: SvelteKitRouteFileKind;
+    usesLoad: boolean;
+    usesActions: boolean;
+    usesRedirect: boolean;
+    usesError404: boolean;
+    exportsPrerender: boolean;
+    usesEntries: boolean;
+    layoutReset?: true;
+};
+export type SvelteKitRouteFileKind = "endpoint" | "layout" | "layoutServer" | "layoutUniversal" | "page" | "pageServer" | "pageUniversal";
+export type SvelteKitComponentHint = {
+    file: string;
+    imports: string[];
+    components: string[];
+};
+export type SvelteKitMigrationChecklistCategory = {
+    category: string;
+    items: string[];
+};
+export type SvelteKitMigrationPlan = {
+    routeFamilies: SvelteKitRouteFamilyPlan[];
+    artifactFamilies: SvelteKitArtifactFamilyPlan[];
+    paramMatchers: SvelteKitParamMatcherPlan[];
+    collisionTests: SvelteKitCollisionTestPlan[];
+};
+export type SvelteKitMigrationStubFile = {
+    path: "data.ts" | "routes.ts" | "artifacts.ts" | "param-matchers.ts" | "build.ts" | "collision-tests.md";
+    contents: string;
+};
+export type SvelteKitMigrationStubEmitOptions = {
+    overwrite?: boolean;
+};
+export type SvelteKitRouteFamilyPlan = {
+    name: string;
+    routePath: string;
+    pattern: string;
+    files: string[];
+    params: SvelteKitRouteParam[];
+    usesPageServer: boolean;
+    usesUniversalLoad: boolean;
+    usesEntries: boolean;
+    usesActions?: true;
+    layoutFiles?: string[];
+    paramMatchers: Record<string, string>;
+};
+export type SvelteKitArtifactFamilyPlan = {
+    name: string;
+    routePath: string;
+    pattern: string;
+    file: string;
+    kind: SvelteKitEndpointKind;
+    renderer: "artifactResponse" | "csvArtifact" | "jsonArtifact" | "textArtifact" | "xmlArtifact";
+    params: SvelteKitRouteParam[];
+    paramMatchers: Record<string, string>;
+    usesResponseMetadata: boolean;
+    usesEntries?: true;
+    methods?: string[];
+    nonStaticMethods?: string[];
+};
+export type SvelteKitParamMatcherPlan = {
+    name: string;
+    file: string;
+    usedBy: string[];
+};
+export type SvelteKitCollisionTestPlan = {
+    code: SvelteKitAuditWarning["code"];
+    path: string;
+    message: string;
+};
+export type SvelteKitPageAudit = {
+    routePath: string;
+    stoneagePattern: string;
+    files: string[];
+    params: SvelteKitRouteParam[];
+    hasPage: boolean;
+    hasPageServer: boolean;
+    hasPageUniversal: boolean;
+    usesUniversalLoad: boolean;
+    usesActions: boolean;
+    usesEntries: boolean;
+    exportsPrerender: boolean;
+    usesRedirect: boolean;
+    usesError404: boolean;
+};
+export type SvelteKitEndpointAudit = {
+    routePath: string;
+    stoneagePattern: string;
+    file: string;
+    params: SvelteKitRouteParam[];
+    kind: SvelteKitEndpointKind;
+    methods: string[];
+    usesJson: boolean;
+    usesResponse: boolean;
+    usesEntries: boolean;
+    exportsPrerender: boolean;
+    usesRedirect: boolean;
+    usesError404: boolean;
+};
+export type SvelteKitRouteParam = {
+    name: string;
+    matcher?: string;
+    rest?: boolean;
+    optional?: boolean;
+};
+export type SvelteKitParamMatcherAudit = {
+    name: string;
+    file: string;
+};
+export type SvelteKitAuditWarning = {
+    code: "param.matcher_missing" | "endpoint.non_static_method" | "route.duplicate_group_output" | "route.optional_param" | "route.page_actions" | "route.page_artifact_same_path" | "route.rest_param" | "route.static_dynamic_shadow" | "route.sibling_dynamic_without_matcher";
+    path: string;
+    message: string;
+};
+export type SvelteKitEndpointKind = "binary" | "csv" | "json" | "txt" | "unknown" | "xml";
+export declare function auditSvelteKitPublicSurface(options: SvelteKitAuditOptions): Promise<SvelteKitAuditReport>;
+export declare function createSvelteKitMigrationStubs(plan: SvelteKitMigrationPlan): SvelteKitMigrationStubFile[];
+export declare function emitSvelteKitMigrationStubs(plan: SvelteKitMigrationPlan, outDir: string, options?: SvelteKitMigrationStubEmitOptions): Promise<SvelteKitMigrationStubFile[]>;