@t09tanaka/stoneage 0.1.0

package/dist/data.d.ts

@@ -0,0 +1,121 @@
+import type { ArtifactContent, ArtifactEntry, ArtifactFamily, Dependency, PageMetadata, RouteEntry, RouteParams } from "./core.js";
+export type PublicDataArtifact<Data> = {
+    key: string;
+    data: Data;
+    dependency: Dependency;
+    sourceDependencies: Dependency[];
+};
+export type PublicDataArtifactInput<Data> = {
+    key: string;
+    data: Data;
+    sourceDependencies?: Dependency[];
+};
+export type NormalizedDataSnapshot<Data> = PublicDataArtifact<Data> & {
+    path: string;
+    format: "json" | "csv";
+    bytes: number;
+    hash: string;
+    written: boolean;
+};
+export type NormalizedJsonDataOptions<Data> = PublicDataArtifactInput<Data> & {
+    path: string;
+    pretty?: boolean;
+    renderedContent?: string | (() => string);
+    contentFingerprint?: NormalizedDataContentFingerprint;
+    cacheManifestPath?: string;
+};
+export type NormalizedCsvDataOptions<Row> = {
+    key: string;
+    path: string;
+    rows: readonly Row[];
+    columns: readonly CsvColumn<Row>[];
+    header?: boolean;
+    sourceDependencies?: Dependency[];
+    contentFingerprint?: NormalizedDataContentFingerprint;
+    cacheManifestPath?: string;
+};
+export type NormalizedDataContentFingerprint = {
+    hash: string;
+    bytes?: number;
+};
+export type NormalizedDataCacheManifest = {
+    version: 1;
+    snapshots: Record<string, NormalizedDataCacheManifestSnapshot>;
+};
+export type NormalizedDataCacheManifestSnapshot = {
+    path: string;
+    format: NormalizedDataSnapshot<unknown>["format"];
+    hash: string;
+    bytes: number;
+};
+export type ViewModelRecord<ViewModel> = {
+    viewModel: ViewModel;
+    dependencies: Dependency[];
+};
+export type ViewModelInput<ViewModel> = {
+    viewModel: ViewModel;
+    dependencies?: Dependency[];
+};
+export type DeriveViewModelsOptions = {
+    artifactDependency?: "fallback" | "always" | "never";
+};
+export type RecordDependency<RecordItem> = {
+    key: string;
+    value: RecordItem;
+};
+export type DeriveRecordViewModelsOptions<RecordItem, ViewModel> = DeriveViewModelsOptions & {
+    key: (record: RecordItem, index: number) => string;
+    dependencies?: (record: RecordItem, index: number) => Dependency[];
+    viewModel: (record: RecordItem, index: number) => ViewModel;
+};
+export type RouteEntriesFromViewModelsOptions<ViewModel> = {
+    params: (viewModel: ViewModel) => RouteParams;
+    path?: (viewModel: ViewModel) => string | undefined;
+    dependencies?: (viewModel: ViewModel) => Dependency[];
+    metadata: (viewModel: ViewModel) => PageMetadata;
+    render: (viewModel: ViewModel) => string | Promise<string>;
+};
+export type ArtifactEntriesFromPublicDataOptions<Data> = {
+    params: (artifact: PublicDataArtifact<Data>) => RouteParams;
+    path?: (artifact: PublicDataArtifact<Data>) => string | undefined;
+    dependencies?: (artifact: PublicDataArtifact<Data>) => Dependency[];
+    render: (artifact: PublicDataArtifact<Data>) => ArtifactContent | Promise<ArtifactContent>;
+};
+export type JsonArtifactOptions = {
+    pretty?: boolean;
+};
+export type CsvCell = string | number | boolean | null | undefined;
+export type CsvColumn<Row> = {
+    header: string;
+    value: (row: Row, index: number) => CsvCell;
+};
+export type CsvArtifactOptions = {
+    header?: boolean;
+};
+export type PublicDataJsonManifestItem = {
+    key: string;
+    path: string;
+};
+export type PublicDataJsonManifest = {
+    version: 1;
+    artifacts: PublicDataJsonManifestItem[];
+};
+export type PublicDataJsonArtifactsOptions = {
+    name?: string;
+    path: (artifact: PublicDataArtifact<unknown>) => string;
+    manifestPath?: string | false;
+    manifestKey?: string;
+    pretty?: boolean;
+    dependencies?: (artifact: PublicDataArtifact<unknown>) => Dependency[];
+};
+export declare function definePublicDataArtifact<Data>(input: PublicDataArtifactInput<Data>): PublicDataArtifact<Data>;
+export declare function writeNormalizedJsonData<Data>(options: NormalizedJsonDataOptions<Data>): Promise<NormalizedDataSnapshot<Data>>;
+export declare function writeNormalizedCsvData<Row>(options: NormalizedCsvDataOptions<Row>): Promise<NormalizedDataSnapshot<readonly Row[]>>;
+export declare function recordDependency<RecordItem>(key: string, record: RecordItem): RecordDependency<RecordItem>;
+export declare function deriveViewModels<Data, ViewModel>(artifact: PublicDataArtifact<Data>, derive: (data: Data) => ViewModelInput<ViewModel>[], options?: DeriveViewModelsOptions): ViewModelRecord<ViewModel>[];
+export declare function deriveRecordViewModels<RecordItem, ViewModel>(artifact: PublicDataArtifact<readonly RecordItem[]>, options: DeriveRecordViewModelsOptions<RecordItem, ViewModel>): ViewModelRecord<ViewModel>[];
+export declare function routeEntriesFromViewModels<ViewModel>(records: ViewModelRecord<ViewModel>[], options: RouteEntriesFromViewModelsOptions<ViewModel>): RouteEntry[];
+export declare function artifactEntriesFromPublicData<Data>(artifacts: PublicDataArtifact<Data>[], options: ArtifactEntriesFromPublicDataOptions<Data>): ArtifactEntry[];
+export declare function definePublicDataJsonArtifacts(artifacts: readonly PublicDataArtifact<unknown>[], options: PublicDataJsonArtifactsOptions): ArtifactFamily;
+export declare function renderJsonArtifact(value: unknown, options?: JsonArtifactOptions): string;
+export declare function renderCsvArtifact<Row>(rows: readonly Row[], columns: readonly CsvColumn<Row>[], options?: CsvArtifactOptions): string;

package/dist/data.js

@@ -0,0 +1,358 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+const normalizedDataManifestUpdateQueues = new Map();
+export function definePublicDataArtifact(input) {
+    return {
+        key: input.key,
+        data: input.data,
+        dependency: {
+            key: input.key,
+            value: input.data,
+        },
+        sourceDependencies: [...(input.sourceDependencies ?? [])],
+    };
+}
+export async function writeNormalizedJsonData(options) {
+    const cached = await readCachedNormalizedDataSnapshot({
+        key: options.key,
+        path: options.path,
+        data: options.data,
+        format: "json",
+        contentFingerprint: options.contentFingerprint,
+        cacheManifestPath: options.cacheManifestPath,
+        sourceDependencies: options.sourceDependencies,
+    });
+    if (cached) {
+        return cached;
+    }
+    const content = typeof options.renderedContent === "function"
+        ? options.renderedContent()
+        : (options.renderedContent ?? renderJsonArtifact(options.data, { pretty: options.pretty }));
+    return writeNormalizedDataSnapshot({
+        key: options.key,
+        path: options.path,
+        data: options.data,
+        format: "json",
+        content,
+        contentFingerprint: options.contentFingerprint,
+        cacheManifestPath: options.cacheManifestPath,
+        sourceDependencies: options.sourceDependencies,
+    });
+}
+export async function writeNormalizedCsvData(options) {
+    const cached = await readCachedNormalizedDataSnapshot({
+        key: options.key,
+        path: options.path,
+        data: options.rows,
+        format: "csv",
+        contentFingerprint: options.contentFingerprint,
+        cacheManifestPath: options.cacheManifestPath,
+        sourceDependencies: options.sourceDependencies,
+    });
+    if (cached) {
+        return cached;
+    }
+    const content = renderCsvArtifact(options.rows, options.columns, {
+        header: options.header,
+    });
+    return writeNormalizedDataSnapshot({
+        key: options.key,
+        path: options.path,
+        data: options.rows,
+        format: "csv",
+        content,
+        contentFingerprint: options.contentFingerprint,
+        cacheManifestPath: options.cacheManifestPath,
+        sourceDependencies: options.sourceDependencies,
+    });
+}
+export function recordDependency(key, record) {
+    return { key, value: record };
+}
+export function deriveViewModels(artifact, derive, options = {}) {
+    const artifactDependency = options.artifactDependency ?? "fallback";
+    return derive(artifact.data).map((item) => ({
+        viewModel: item.viewModel,
+        dependencies: dependenciesForViewModel(artifact.dependency, item.dependencies ?? [], artifactDependency),
+    }));
+}
+export function deriveRecordViewModels(artifact, options) {
+    const artifactDependency = options.artifactDependency ?? "fallback";
+    return artifact.data.map((record, index) => {
+        const dependencies = [
+            recordDependency(options.key(record, index), record),
+            ...(options.dependencies?.(record, index) ?? []),
+        ];
+        return {
+            viewModel: options.viewModel(record, index),
+            dependencies: dependenciesForViewModel(artifact.dependency, dependencies, artifactDependency),
+        };
+    });
+}
+function dependenciesForViewModel(artifactDependency, dependencies, mode) {
+    if (mode === "always") {
+        return [artifactDependency, ...dependencies];
+    }
+    if (mode === "never" || dependencies.length > 0) {
+        return dependencies;
+    }
+    return [artifactDependency];
+}
+export function routeEntriesFromViewModels(records, options) {
+    return records.map((record) => ({
+        params: options.params(record.viewModel),
+        path: options.path?.(record.viewModel),
+        dependencies: [
+            ...record.dependencies,
+            ...(options.dependencies?.(record.viewModel) ?? []),
+        ],
+        metadata: options.metadata(record.viewModel),
+        render: () => options.render(record.viewModel),
+    }));
+}
+export function artifactEntriesFromPublicData(artifacts, options) {
+    return artifacts.map((artifact) => ({
+        params: options.params(artifact),
+        path: options.path?.(artifact),
+        dependencies: [
+            artifact.dependency,
+            ...artifact.sourceDependencies,
+            ...(options.dependencies?.(artifact) ?? []),
+        ],
+        render: () => options.render(artifact),
+    }));
+}
+export function definePublicDataJsonArtifacts(artifacts, options) {
+    const manifestPath = options.manifestPath === undefined ? "/site-data.json" : options.manifestPath;
+    return {
+        name: options.name ?? "publicData",
+        pattern: "/:name.json",
+        entries: () => {
+            const publicEntries = artifacts.map((artifact) => {
+                const path = options.path(artifact);
+                return {
+                    params: { name: fileStem(path) },
+                    path,
+                    dependencies: [
+                        artifact.dependency,
+                        ...artifact.sourceDependencies,
+                        ...(options.dependencies?.(artifact) ?? []),
+                    ],
+                    render: () => renderJsonArtifact(artifact.data, { pretty: options.pretty }),
+                };
+            });
+            if (manifestPath === false) {
+                return publicEntries;
+            }
+            const manifest = {
+                version: 1,
+                artifacts: publicEntries
+                    .map((entry, index) => ({
+                    key: artifacts[index]?.key ?? "",
+                    path: entry.path,
+                }))
+                    .sort((left, right) => left.key.localeCompare(right.key)),
+            };
+            return [
+                ...publicEntries,
+                {
+                    params: { name: fileStem(manifestPath) },
+                    path: manifestPath,
+                    dependencies: [
+                        {
+                            key: options.manifestKey ?? "public-data:manifest",
+                            value: manifest,
+                        },
+                    ],
+                    render: () => renderJsonArtifact(manifest, { pretty: options.pretty }),
+                },
+            ];
+        },
+    };
+}
+export function renderJsonArtifact(value, options = {}) {
+    return `${JSON.stringify(value, null, options.pretty ? 2 : undefined)}\n`;
+}
+export function renderCsvArtifact(rows, columns, options = {}) {
+    const includeHeader = options.header ?? true;
+    const lines = [
+        ...(includeHeader ? [columns.map((column) => escapeCsvCell(column.header)).join(",")] : []),
+        ...rows.map((row, index) => columns.map((column) => escapeCsvCell(column.value(row, index))).join(",")),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function escapeCsvCell(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    const text = String(value);
+    return /[",\r\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function fileStem(path) {
+    const filename = path.split("/").filter(Boolean).at(-1) ?? "data";
+    return filename.replace(/\.[^.]*$/, "") || "data";
+}
+async function writeNormalizedDataSnapshot(options) {
+    const useFingerprintCache = hasNormalizedDataFingerprintCache(options);
+    const hash = useFingerprintCache ? options.contentFingerprint.hash : hashContent(options.content);
+    const written = await writeTextIfChanged(options.path, options.content);
+    const bytes = Buffer.byteLength(options.content);
+    if (useFingerprintCache) {
+        await writeNormalizedDataCacheManifestSnapshot(options.cacheManifestPath, {
+            key: options.key,
+            path: options.path,
+            format: options.format,
+            hash,
+            bytes,
+        });
+    }
+    return {
+        key: options.key,
+        data: options.data,
+        dependency: {
+            key: options.key,
+            hash,
+        },
+        sourceDependencies: [...(options.sourceDependencies ?? [])],
+        path: options.path,
+        format: options.format,
+        bytes,
+        hash,
+        written,
+    };
+}
+function hasNormalizedDataFingerprintCache(options) {
+    return Boolean(options.contentFingerprint && options.cacheManifestPath);
+}
+async function readCachedNormalizedDataSnapshot(options) {
+    if (!options.contentFingerprint || !options.cacheManifestPath) {
+        return undefined;
+    }
+    const manifest = await readNormalizedDataCacheManifest(options.cacheManifestPath);
+    const snapshot = manifest.snapshots[options.key];
+    if (!snapshot ||
+        snapshot.path !== options.path ||
+        snapshot.format !== options.format ||
+        snapshot.hash !== options.contentFingerprint.hash ||
+        (options.contentFingerprint.bytes !== undefined &&
+            snapshot.bytes !== options.contentFingerprint.bytes)) {
+        return undefined;
+    }
+    const current = await readFileStats(options.path);
+    const bytes = options.contentFingerprint.bytes ?? snapshot.bytes;
+    if (!current || current.size !== bytes) {
+        return undefined;
+    }
+    return {
+        key: options.key,
+        data: options.data,
+        dependency: {
+            key: options.key,
+            hash: options.contentFingerprint.hash,
+        },
+        sourceDependencies: [...(options.sourceDependencies ?? [])],
+        path: options.path,
+        format: options.format,
+        bytes,
+        hash: options.contentFingerprint.hash,
+        written: false,
+    };
+}
+async function writeNormalizedDataCacheManifestSnapshot(manifestPath, snapshot) {
+    const previous = normalizedDataManifestUpdateQueues.get(manifestPath) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(() => writeNormalizedDataCacheManifestSnapshotWithoutQueue(manifestPath, snapshot));
+    const queued = next.finally(() => {
+        if (normalizedDataManifestUpdateQueues.get(manifestPath) === queued) {
+            normalizedDataManifestUpdateQueues.delete(manifestPath);
+        }
+    });
+    normalizedDataManifestUpdateQueues.set(manifestPath, queued);
+    await next;
+}
+async function writeNormalizedDataCacheManifestSnapshotWithoutQueue(manifestPath, snapshot) {
+    const manifest = await readNormalizedDataCacheManifest(manifestPath);
+    manifest.snapshots[snapshot.key] = {
+        path: snapshot.path,
+        format: snapshot.format,
+        hash: snapshot.hash,
+        bytes: snapshot.bytes,
+    };
+    await mkdir(dirname(manifestPath), { recursive: true });
+    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+async function readNormalizedDataCacheManifest(manifestPath) {
+    try {
+        const parsed = JSON.parse(await readFile(manifestPath, "utf8"));
+        return {
+            version: 1,
+            snapshots: isObjectRecord(parsed.snapshots) ? normalizeCacheSnapshots(parsed.snapshots) : {},
+        };
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return { version: 1, snapshots: {} };
+        }
+        throw error;
+    }
+}
+function normalizeCacheSnapshots(snapshots) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(snapshots)) {
+        if (!isObjectRecord(value)) {
+            continue;
+        }
+        const snapshot = value;
+        if (typeof snapshot.path === "string" &&
+            isNormalizedDataFormat(snapshot.format) &&
+            typeof snapshot.hash === "string" &&
+            typeof snapshot.bytes === "number") {
+            normalized[key] = {
+                path: snapshot.path,
+                format: snapshot.format,
+                hash: snapshot.hash,
+                bytes: snapshot.bytes,
+            };
+        }
+    }
+    return normalized;
+}
+function isNormalizedDataFormat(value) {
+    return value === "json" || value === "csv";
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readFileStats(path) {
+    try {
+        return await stat(path);
+    }
+    catch (error) {
+        if (isMissingPath(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function writeTextIfChanged(path, content) {
+    try {
+        const current = await readFile(path, "utf8");
+        if (current === content) {
+            return false;
+        }
+    }
+    catch (error) {
+        if (!isMissingPath(error)) {
+            throw error;
+        }
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content);
+    return true;
+}
+function hashContent(content) {
+    return createHash("sha256").update(content).digest().subarray(0, 16).toString("base64url");
+}
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/deploy.d.ts

@@ -0,0 +1,34 @@
+export type DeployProvider = "netlify" | "github-pages";
+export type DeployArtifactsOptions = {
+    outDir: string;
+    provider: DeployProvider;
+    /**
+     * Custom domain for GitHub Pages. Only the host is written to CNAME
+     * (protocol and path are stripped). Ignored by other providers.
+     */
+    cname?: string;
+};
+export type DeployArtifactsResult = {
+    provider: DeployProvider;
+    files: string[];
+    redirects: number;
+    headers: number;
+};
+type RedirectsManifest = {
+    redirects: Array<{
+        from: string;
+        to: string;
+        status: number;
+    }>;
+};
+type HeadersManifest = {
+    headers: Array<{
+        path: string;
+        headers: Record<string, string>;
+    }>;
+};
+export declare function writeDeployArtifacts(options: DeployArtifactsOptions): Promise<DeployArtifactsResult>;
+export declare function normalizeCname(cname: string | undefined): string | undefined;
+export declare function renderNetlifyRedirects(redirects: RedirectsManifest["redirects"]): string;
+export declare function renderNetlifyHeaders(headers: HeadersManifest["headers"]): string;
+export {};