@bscotch/gamemaker-releases 0.4.0 → 0.4.2

package/dist/feeds.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feeds.types.d.ts","sourceRoot":"","sources":["../src/feeds.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC9C,eAAO,MAAM,QAAQ,gDAAiD,CAAC;AACvE,eAAO,MAAM,aAAa,kDAAmB,CAAC;AAG9C,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AACxD,eAAO,MAAM,aAAa,6BAA8B,CAAC;AAGzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBxB,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU3C,CAAC;AAUH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIxC,CAAC;AAEL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAMtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAClE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;GAAiC,CAAC"}
+{"version":3,"file":"feeds.types.d.ts","sourceRoot":"","sources":["../src/feeds.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC9C,eAAO,MAAM,QAAQ,gDAAiD,CAAC;AACvE,eAAO,MAAM,aAAa,kDAAmB,CAAC;AAG9C,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AACxD,eAAO,MAAM,aAAa,6BAA8B,CAAC;AAGzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBxB,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU3C,CAAC;AAUH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIxC,CAAC;AAEL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAMtB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAClE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;GAAiC,CAAC"}

package/dist/feeds.types.js

@@ -1,69 +1,69 @@
-import { z } from 'zod';
-import { htmlString } from './utils.js';
-export const channels = ['lts', 'stable', 'beta', 'unstable'];
-export const channelSchema = z.enum(channels);
-Object.freeze(channels);
-export const artifactTypes = ['ide', 'runtime'];
-Object.freeze(artifactTypes);
-export const rssFeedSchema = z.object({
-    rss: z.object({
-        channel: z.object({
-            title: htmlString(),
-            description: htmlString(),
-            link: z.string(),
-            item: z.preprocess((arg) => {
-                if (!Array.isArray(arg)) {
-                    return [arg];
-                }
-                return arg;
-            }, z.array(z.object({
-                title: z.string().regex(/^Version \d+\.\d+\.\d+\.\d+$/),
-                pubDate: z.string(),
-                link: z.string().optional(),
-                comments: z.string(),
-                description: htmlString().optional(),
-            }))),
-        }),
-    }),
-});
-export const gameMakerArtifactSchema = z.object({
-    type: z.enum(artifactTypes),
-    version: z.string().regex(/^\d+\.\d+\.\d+\.\d+$/),
-    channel: channelSchema,
-    summary: z.string().optional(),
-    feedUrl: z.string(),
-    publishedAt: z.string(),
-    link: z.string().optional(),
-    notesUrl: z.string(),
-});
-export const gameMakerArtifactWithNotesSchema = gameMakerArtifactSchema.extend({
-    notes: z.object({
-        since: z.string().nullable(),
-        groups: z.array(z.object({
-            title: htmlString(),
-            changes: z.array(htmlString()),
-        })),
-    }),
-});
-const gameMakerReleaseBaseSchema = z.object({
-    channel: channelSchema,
-    publishedAt: z.string().describe('Date of release for the IDE in this pair'),
-    summary: htmlString().describe('Summary of the release, from the RSS feed for the IDE'),
-});
-export const gameMakerReleaseWithNotesSchema = gameMakerReleaseBaseSchema.extend({
-    ide: gameMakerArtifactWithNotesSchema.omit({ summary: true }),
-    runtime: gameMakerArtifactWithNotesSchema.omit({ summary: true }),
-});
-export const gameMakerReleaseSchema = gameMakerReleaseBaseSchema.extend({
-    ide: gameMakerArtifactSchema.omit({ summary: true }),
-    runtime: gameMakerArtifactSchema.omit({ summary: true }),
-});
-export const rawReleaseNoteSchema = z
-    .object({
-    type: z.enum(artifactTypes).optional(),
-    version: z.string(),
-    release_notes: z.array(z.string()),
-})
-    .strict();
-export const rawReleaseNotesCacheSchema = z.record(rawReleaseNoteSchema);
+import { z } from 'zod';
+import { htmlString } from './utils.js';
+export const channels = ['lts', 'stable', 'beta', 'unstable'];
+export const channelSchema = z.enum(channels);
+Object.freeze(channels);
+export const artifactTypes = ['ide', 'runtime'];
+Object.freeze(artifactTypes);
+export const rssFeedSchema = z.object({
+    rss: z.object({
+        channel: z.object({
+            title: htmlString(),
+            description: htmlString(),
+            link: z.string(),
+            item: z.preprocess((arg) => {
+                if (!Array.isArray(arg)) {
+                    return [arg];
+                }
+                return arg;
+            }, z.array(z.object({
+                title: z.string().regex(/^Version \d+\.\d+\.\d+\.\d+$/),
+                pubDate: z.string(),
+                link: z.string().optional(),
+                comments: z.string(),
+                description: htmlString().optional(),
+            }))),
+        }),
+    }),
+});
+export const gameMakerArtifactSchema = z.object({
+    type: z.enum(artifactTypes),
+    version: z.string().regex(/^\d+\.\d+\.\d+\.\d+$/),
+    channel: channelSchema,
+    summary: z.string().optional(),
+    feedUrl: z.string(),
+    publishedAt: z.string(),
+    link: z.string().optional(),
+    notesUrl: z.string(),
+});
+export const gameMakerArtifactWithNotesSchema = gameMakerArtifactSchema.extend({
+    notes: z.object({
+        since: z.string().nullable(),
+        groups: z.array(z.object({
+            title: htmlString(),
+            changes: z.array(htmlString()),
+        })),
+    }),
+});
+const gameMakerReleaseBaseSchema = z.object({
+    channel: channelSchema,
+    publishedAt: z.string().describe('Date of release for the IDE in this pair'),
+    summary: htmlString().describe('Summary of the release, from the RSS feed for the IDE'),
+});
+export const gameMakerReleaseWithNotesSchema = gameMakerReleaseBaseSchema.extend({
+    ide: gameMakerArtifactWithNotesSchema.omit({ summary: true }),
+    runtime: gameMakerArtifactWithNotesSchema.omit({ summary: true }),
+});
+export const gameMakerReleaseSchema = gameMakerReleaseBaseSchema.extend({
+    ide: gameMakerArtifactSchema.omit({ summary: true }),
+    runtime: gameMakerArtifactSchema.omit({ summary: true }),
+});
+export const rawReleaseNoteSchema = z
+    .object({
+    type: z.enum(artifactTypes).optional(),
+    version: z.string(),
+    release_notes: z.array(z.string()),
+})
+    .strict();
+export const rawReleaseNotesCacheSchema = z.record(rawReleaseNoteSchema);
 //# sourceMappingURL=feeds.types.js.map

package/dist/fetch.d.ts

@@ -1,6 +1,6 @@
-export type Validator<T> = {
-    parse: (data: any) => T;
-};
-export declare function fetchXml<T = unknown>(url: string, validator?: Validator<T>): Promise<T>;
-export declare function fetchJson<T = unknown>(url: string, validator?: Validator<T>): Promise<T>;
+export type Validator<T> = {
+    parse: (data: any) => T;
+};
+export declare function fetchXml<T = unknown>(url: string, validator?: Validator<T>): Promise<T>;
+export declare function fetchJson<T = unknown>(url: string, validator?: Validator<T>): Promise<T>;
 //# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.js

@@ -1,37 +1,37 @@
-import fetch from 'node-fetch';
-import { XMLParser } from 'fast-xml-parser';
-import { isError } from './utils.js';
-export async function fetchXml(url, validator) {
-    const res = await fetchUrl(url);
-    try {
-        const data = await res.text();
-        const asJson = new XMLParser().parse(data);
-        return validator ? validator.parse(asJson) : asJson;
-    }
-    catch (err) {
-        throw new Error(`Error parsing XML from ${url}: ${isError(err) ? err.message : 'UNKNOWN'}`);
-    }
-}
-export async function fetchJson(url, validator) {
-    const res = await fetchUrl(url);
-    try {
-        const parsed = await res.json();
-        return validator ? validator.parse(parsed) : parsed;
-    }
-    catch (err) {
-        throw new Error(`Error parsing JSON from ${url}: ${isError(err) ? err.message : 'UNKNOWN'}`);
-    }
-}
-async function fetchUrl(url) {
-    try {
-        const res = await fetch(url);
-        if (res.status >= 300) {
-            throw new Error(`Error fetching "${url}": ${res.status} ${res.statusText}`);
-        }
-        return res;
-    }
-    catch (err) {
-        throw new Error(`Error fetching "${url}": ${isError(err) ? err.message : 'UNKNOWN'}`);
-    }
-}
+import fetch from 'node-fetch';
+import { XMLParser } from 'fast-xml-parser';
+import { isError } from './utils.js';
+export async function fetchXml(url, validator) {
+    const res = await fetchUrl(url);
+    try {
+        const data = await res.text();
+        const asJson = new XMLParser().parse(data);
+        return validator ? validator.parse(asJson) : asJson;
+    }
+    catch (err) {
+        throw new Error(`Error parsing XML from ${url}: ${isError(err) ? err.message : 'UNKNOWN'}`);
+    }
+}
+export async function fetchJson(url, validator) {
+    const res = await fetchUrl(url);
+    try {
+        const parsed = await res.json();
+        return validator ? validator.parse(parsed) : parsed;
+    }
+    catch (err) {
+        throw new Error(`Error parsing JSON from ${url}: ${isError(err) ? err.message : 'UNKNOWN'}`);
+    }
+}
+async function fetchUrl(url) {
+    try {
+        const res = await fetch(url);
+        if (res.status >= 300) {
+            throw new Error(`Error fetching "${url}": ${res.status} ${res.statusText}`);
+        }
+        return res;
+    }
+    catch (err) {
+        throw new Error(`Error fetching "${url}": ${isError(err) ? err.message : 'UNKNOWN'}`);
+    }
+}
 //# sourceMappingURL=fetch.js.map

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export * from './browser.js';
-export { listReleases, listReleasesWithNotes } from './feeds.js';
+export * from './browser.js';
+export { computeReleasesSummary, computeReleasesSummaryWithNotes, } from './feeds.js';
+export { fetchReleasesSummaryWithNotes } from './releases.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,3 +1,4 @@
-export * from './browser.js';
-export { listReleases, listReleasesWithNotes } from './feeds.js';
+export * from './browser.js';
+export { computeReleasesSummary, computeReleasesSummaryWithNotes, } from './feeds.js';
+export { fetchReleasesSummaryWithNotes } from './releases.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC"}

package/dist/notes.d.ts

@@ -1,34 +1,34 @@
-import { Pathy } from '@bscotch/pathy';
-import { ArtifactType, GameMakerRelease } from './feeds.types.js';
-export declare function listReleaseNotes(releases: GameMakerRelease[], cache?: Pathy | string): Promise<Record<string, {
-    version: string;
-    url: string;
-    title: string | null;
-    type: "ide" | "runtime";
-    changes: {
-        since: string | null;
-        groups: {
-            title: string;
-            changes: string[];
-        }[];
-    };
-}>>;
-export declare function cleanNote(note: {
-    type?: ArtifactType;
-    version: string;
-    url: string;
-    release_notes: string[];
-}): {
-    version: string;
-    url: string;
-    title: string | null;
-    type: "ide" | "runtime";
-    changes: {
-        since: string | null;
-        groups: {
-            title: string;
-            changes: string[];
-        }[];
-    };
-};
+import { Pathy } from '@bscotch/pathy';
+import { ArtifactType, GameMakerRelease } from './feeds.types.js';
+export declare function listReleaseNotes(releases: GameMakerRelease[], cache?: Pathy | string): Promise<Record<string, {
+    version: string;
+    url: string;
+    title: string | null;
+    type: "ide" | "runtime";
+    changes: {
+        since: string | null;
+        groups: {
+            title: string;
+            changes: string[];
+        }[];
+    };
+}>>;
+export declare function cleanNote(note: {
+    type?: ArtifactType;
+    version: string;
+    url: string;
+    release_notes: string[];
+}): {
+    version: string;
+    url: string;
+    title: string | null;
+    type: "ide" | "runtime";
+    changes: {
+        since: string | null;
+        groups: {
+            title: string;
+            changes: string[];
+        }[];
+    };
+};
 //# sourceMappingURL=notes.d.ts.map

package/dist/notes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../src/notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EACL,YAAY,EACZ,gBAAgB,EAIjB,MAAM,kBAAkB,CAAC;AAI1B,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,gBAAgB,EAAE,EAC5B,KAAK,GAAE,KAAK,GAAG,MAA8B;;;;;;;;;;;;IA8B9C;AAqDD,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAC9B,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;;;;;;;;;;;;EAiBA"}
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../src/notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EACN,YAAY,EACZ,gBAAgB,EAIhB,MAAM,kBAAkB,CAAC;AAI1B,wBAAsB,gBAAgB,CACrC,QAAQ,EAAE,gBAAgB,EAAE,EAC5B,KAAK,GAAE,KAAK,GAAG,MAA8B;;;;;;;;;;;;IAgC7C;AAqDD,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAC/B,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;EAiBA"}

package/dist/notes.js

@@ -1,141 +1,143 @@
-import { Pathy } from '@bscotch/pathy';
-import { assert } from '@bscotch/utility/browser';
-import { defaultNotesCachePath } from './constants.js';
-import { rawReleaseNotesCacheSchema, rawReleaseNoteSchema, } from './feeds.types.js';
-import { fetchJson } from './fetch.js';
-import { countNonUnique, findMax } from './utils.js';
-export async function listReleaseNotes(releases, cache = defaultNotesCachePath) {
-    const cachePath = Pathy.asInstance(cache).withValidator(rawReleaseNotesCacheSchema);
-    assert(cachePath.hasExtension('json'), `Cache path must have a .json extension`);
-    const cacheData = await cachePath.read({ fallback: {} });
-    for (const release of releases) {
-        for (const type of ['ide', 'runtime']) {
-            const url = release[type].notesUrl;
-            if (cacheData[url]) {
-                if (!cacheData[url].type) {
-                    cacheData[url].type = type;
-                    await cachePath.write(cacheData);
-                }
-                continue;
-            }
-            console.info('Notes cache miss:', url);
-            const note = await fetchJson(url, rawReleaseNoteSchema);
-            cacheData[url] = {
-                type,
-                ...rawReleaseNoteSchema.parse(note),
-            };
-            await cachePath.write(cacheData);
-        }
-    }
-    return cleanNotes(cacheData);
-}
-function cleanNotes(cachedNotes) {
-    const rawNotes = Object.entries(cachedNotes).map(([url, note]) => ({
-        ...note,
-        url,
-    }));
-    // As of writing, all versions from downloaded notes are unique.
-    // We'll assume that moving forward, but also throw if that assumption is broken.
-    const versions = rawNotes.map((note) => `${note.version} (${note.type})`);
-    assert(countNonUnique(versions) === 0, `Duplicate versions found in release notes`);
-    // Convert each note into a well-defined structured document.
-    const cleanedNotes = rawNotes.map(cleanNote);
-    // Try to normalize "since" versions, since they're often only the *last* digits
-    for (const note of cleanedNotes) {
-        if (!note.changes.since?.match(/^\d+$/)) {
-            continue;
-        }
-        const possibleMatches = versions.filter((v) => v.endsWith(`.${note.changes.since}`));
-        if (possibleMatches.length === 1) {
-            note.changes.since = possibleMatches[0];
-            continue;
-        }
-        if (!possibleMatches.length) {
-            // Then just replace the current version with those digits
-            note.changes.since = note.version.replace(/\d+$/, note.changes.since);
-            continue;
-        }
-        // Score matches by digits in common
-        const versionParts = note.version.split('.');
-        note.changes.since = findMax(possibleMatches, (possibleMatch) => {
-            const matchParts = possibleMatch.split('.');
-            let score = 0;
-            for (let j = 0; j < matchParts.length; j++) {
-                score += matchParts[j] === versionParts[j] ? 1 : 0;
-            }
-            return score;
-        });
-    }
-    // Re-organize into a map for indexing by notes-URL, so that these can be merged
-    // into the release feed data.
-    const notesByUrl = cleanedNotes.reduce((acc, note) => {
-        acc[note.url] = note;
-        return acc;
-    }, {});
-    return notesByUrl;
-}
-export function cleanNote(note) {
-    assert(note.type, 'Note type must be set');
-    const { body, title } = parseHeader(note.release_notes.join(''));
-    const groups = parseBody(body);
-    const sinceVersion = relativeToVersion(title);
-    // Normalize the HTML
-    return {
-        version: note.version,
-        url: note.url,
-        title,
-        type: note.type,
-        changes: {
-            since: sinceVersion,
-            groups,
-        },
-    };
-}
-function relativeToVersion(title) {
-    if (!title) {
-        return null;
-    }
-    const sinceMatch = title.match(/([0-9.]+)/i);
-    return sinceMatch?.[1] || null;
-}
-function parseBody(html) {
-    // Split on h3 elements, and then pull out the lists within each
-    const parts = html.split(/<h3>\s*(.+?)\s*<\/h3>\s*<ul>\s*(.+?)\s*<\/ul>/gs);
-    const changes = [];
-    for (let groupIdx = 0; groupIdx < parts.length - 2; groupIdx += 3) {
-        const [title, list] = [parts[groupIdx + 1], parts[groupIdx + 2]];
-        changes.push({ title, changes: parseList(list) });
-    }
-    return changes;
-}
-function parseList(htmlList) {
-    const parts = htmlList.split(/<li>\s*(.+?)\s*<\/li>/gs);
-    const changes = [];
-    for (let groupIdx = 0; groupIdx < parts.length - 1; groupIdx += 2) {
-        const change = parts[groupIdx + 1];
-        changes.push(change);
-    }
-    return changes;
-}
-function parseHeader(html) {
-    // Remove changelogs from other versions (if there are additional h2 headings, remove
-    // those and all below them)
-    html = html.trim();
-    // If there is an h2 with the word "since" in it (otherwise the first h2), treat that
-    // one as the one describing this version and remove everything above and all headers
-    // below it.
-    const h2s = html.match(/<h2>\s*(.+?)\s*<\/h2>/gs);
-    if (!h2s?.length) {
-        return { title: null, body: html };
-    }
-    const thisVersionH2 = h2s.find((h2) => h2.match(/\bsince\b/i)) || h2s[0];
-    let [, after] = html.split(thisVersionH2);
-    const firstH2Index = after.indexOf('<h2>');
-    if (firstH2Index > 0) {
-        after = after.slice(0, firstH2Index);
-    }
-    assert(!after.includes('<h2>'), `Somehow still has an h2 after parsing`);
-    const [, title] = thisVersionH2.match(/^<h2>\s*(?<title>.+?)\s*<\/h2>/ms);
-    return { title, body: after };
-}
+import { Pathy } from '@bscotch/pathy';
+import { assert } from '@bscotch/utility/browser';
+import { defaultNotesCachePath } from './constants.js';
+import { rawReleaseNotesCacheSchema, rawReleaseNoteSchema, } from './feeds.types.js';
+import { fetchJson } from './fetch.js';
+import { countNonUnique, findMax } from './utils.js';
+export async function listReleaseNotes(releases, cache = defaultNotesCachePath) {
+    const cachePath = Pathy.asInstance(cache).withValidator(rawReleaseNotesCacheSchema);
+    assert(cachePath.hasExtension('json'), `Cache path must have a .json extension`);
+    const cacheData = await cachePath.read({ fallback: {} });
+    for (const release of releases) {
+        for (const type of ['ide', 'runtime']) {
+            let url = release[type].notesUrl;
+            // URL can be malformed
+            url = url.replace(/^(.+\.cloudfront\.net)(release.*)$/, '$1/$2');
+            if (cacheData[url]) {
+                if (!cacheData[url].type) {
+                    cacheData[url].type = type;
+                    await cachePath.write(cacheData);
+                }
+                continue;
+            }
+            console.info('Notes cache miss:', url);
+            const note = await fetchJson(url, rawReleaseNoteSchema);
+            cacheData[url] = {
+                type,
+                ...rawReleaseNoteSchema.parse(note),
+            };
+            await cachePath.write(cacheData);
+        }
+    }
+    return cleanNotes(cacheData);
+}
+function cleanNotes(cachedNotes) {
+    const rawNotes = Object.entries(cachedNotes).map(([url, note]) => ({
+        ...note,
+        url,
+    }));
+    // As of writing, all versions from downloaded notes are unique.
+    // We'll assume that moving forward, but also throw if that assumption is broken.
+    const versions = rawNotes.map((note) => `${note.version} (${note.type})`);
+    assert(countNonUnique(versions) === 0, `Duplicate versions found in release notes`);
+    // Convert each note into a well-defined structured document.
+    const cleanedNotes = rawNotes.map(cleanNote);
+    // Try to normalize "since" versions, since they're often only the *last* digits
+    for (const note of cleanedNotes) {
+        if (!note.changes.since?.match(/^\d+$/)) {
+            continue;
+        }
+        const possibleMatches = versions.filter((v) => v.endsWith(`.${note.changes.since}`));
+        if (possibleMatches.length === 1) {
+            note.changes.since = possibleMatches[0];
+            continue;
+        }
+        if (!possibleMatches.length) {
+            // Then just replace the current version with those digits
+            note.changes.since = note.version.replace(/\d+$/, note.changes.since);
+            continue;
+        }
+        // Score matches by digits in common
+        const versionParts = note.version.split('.');
+        note.changes.since = findMax(possibleMatches, (possibleMatch) => {
+            const matchParts = possibleMatch.split('.');
+            let score = 0;
+            for (let j = 0; j < matchParts.length; j++) {
+                score += matchParts[j] === versionParts[j] ? 1 : 0;
+            }
+            return score;
+        });
+    }
+    // Re-organize into a map for indexing by notes-URL, so that these can be merged
+    // into the release feed data.
+    const notesByUrl = cleanedNotes.reduce((acc, note) => {
+        acc[note.url] = note;
+        return acc;
+    }, {});
+    return notesByUrl;
+}
+export function cleanNote(note) {
+    assert(note.type, 'Note type must be set');
+    const { body, title } = parseHeader(note.release_notes.join(''));
+    const groups = parseBody(body);
+    const sinceVersion = relativeToVersion(title);
+    // Normalize the HTML
+    return {
+        version: note.version,
+        url: note.url,
+        title,
+        type: note.type,
+        changes: {
+            since: sinceVersion,
+            groups,
+        },
+    };
+}
+function relativeToVersion(title) {
+    if (!title) {
+        return null;
+    }
+    const sinceMatch = title.match(/([0-9.]+)/i);
+    return sinceMatch?.[1] || null;
+}
+function parseBody(html) {
+    // Split on h3 elements, and then pull out the lists within each
+    const parts = html.split(/<h3>\s*(.+?)\s*<\/h3>\s*<ul>\s*(.+?)\s*<\/ul>/gs);
+    const changes = [];
+    for (let groupIdx = 0; groupIdx < parts.length - 2; groupIdx += 3) {
+        const [title, list] = [parts[groupIdx + 1], parts[groupIdx + 2]];
+        changes.push({ title, changes: parseList(list) });
+    }
+    return changes;
+}
+function parseList(htmlList) {
+    const parts = htmlList.split(/<li>\s*(.+?)\s*<\/li>/gs);
+    const changes = [];
+    for (let groupIdx = 0; groupIdx < parts.length - 1; groupIdx += 2) {
+        const change = parts[groupIdx + 1];
+        changes.push(change);
+    }
+    return changes;
+}
+function parseHeader(html) {
+    // Remove changelogs from other versions (if there are additional h2 headings, remove
+    // those and all below them)
+    html = html.trim();
+    // If there is an h2 with the word "since" in it (otherwise the first h2), treat that
+    // one as the one describing this version and remove everything above and all headers
+    // below it.
+    const h2s = html.match(/<h2>\s*(.+?)\s*<\/h2>/gs);
+    if (!h2s?.length) {
+        return { title: null, body: html };
+    }
+    const thisVersionH2 = h2s.find((h2) => h2.match(/\bsince\b/i)) || h2s[0];
+    let [, after] = html.split(thisVersionH2);
+    const firstH2Index = after.indexOf('<h2>');
+    if (firstH2Index > 0) {
+        after = after.slice(0, firstH2Index);
+    }
+    assert(!after.includes('<h2>'), `Somehow still has an h2 after parsing`);
+    const [, title] = thisVersionH2.match(/^<h2>\s*(?<title>.+?)\s*<\/h2>/ms);
+    return { title, body: after };
+}
 //# sourceMappingURL=notes.js.map