@zivue/zuuid 0.1.0 → 0.2.0

package/dist/providers/openlibrary/book.js

@@ -0,0 +1,535 @@
+import { createZuuidData } from "../../entity.js";
+import { providerZuuid } from "../../identity.js";
+import { attachSourceMetadata, createSourceRecord } from "../../source.js";
+import { OPEN_LIBRARY_COVER_BASE_URL, OPEN_LIBRARY_PROVIDER } from "./constants.js";
+export const OPEN_LIBRARY_BOOK_CATEGORY = "book";
+export async function fetchOpenLibraryBookSourceRecord(provider, input) {
+    const id = normalizeOpenLibraryBookId(input.id);
+    const work = await provider.getJson(`/works/${id}.json`, {});
+    if (!work) {
+        return undefined;
+    }
+    const search = await fetchOpenLibraryBookSearchDoc(provider, id, work);
+    const editions = await provider.getJson(`/works/${id}/editions.json`, {
+        limit: String(input.editionLimit ?? 50)
+    });
+    const ratings = await provider.getJson(`/works/${id}/ratings.json`, {});
+    const authors = await fetchOpenLibraryAuthors(provider, work);
+    const payload = {
+        work,
+        ...(search ? { search } : {}),
+        ...(editions ? { editions: { entries: editions.entries ?? [], size: editions.size } } : {}),
+        ...(authors.length ? { authors } : {}),
+        ...(ratings ? { ratings } : {})
+    };
+    return createSourceRecord({
+        source: { provider: OPEN_LIBRARY_PROVIDER, category: OPEN_LIBRARY_BOOK_CATEGORY, externalId: id },
+        payload: payload
+    });
+}
+export async function searchOpenLibraryBookSourceRecords(provider, input) {
+    const payload = await fetchOpenLibraryBookSearchResults(provider, input);
+    return {
+        results: await sourceRecordsFromSearchResults(payload.docs),
+        pagination: paginationFromOpenLibrarySearchResponse(payload, input)
+    };
+}
+export async function searchOpenLibraryBooks(provider, input, options = {}) {
+    const payload = await fetchOpenLibraryBookSearchResults(provider, input);
+    const results = [];
+    for (const item of payload.docs ?? []) {
+        const id = openLibraryWorkIdFromKey(item.key);
+        const title = stringField(item.title);
+        if (!id || !title) {
+            continue;
+        }
+        const zuuid = await providerZuuid({ provider: OPEN_LIBRARY_PROVIDER, category: OPEN_LIBRARY_BOOK_CATEGORY, externalId: id });
+        const rating = typeof item.ratings_average === "number" ? item.ratings_average : null;
+        results.push({
+            id: zuuid,
+            zuuid,
+            category: OPEN_LIBRARY_BOOK_CATEGORY,
+            title,
+            date: item.first_publish_year === undefined ? stringField(item.first_publish_date) ?? null : String(item.first_publish_year),
+            cover: coverUrl(item.cover_i, options.coverBaseUrl ?? OPEN_LIBRARY_COVER_BASE_URL),
+            rating,
+            weight: typeof item.edition_count === "number" ? item.edition_count : rating,
+            relationType: null,
+            attribute: item.author_name?.filter(Boolean).join(", ") || null,
+            order: null,
+            source: { source: OPEN_LIBRARY_PROVIDER, category: OPEN_LIBRARY_BOOK_CATEGORY, value: id }
+        });
+    }
+    return {
+        results,
+        pagination: paginationFromOpenLibrarySearchResponse(payload, input)
+    };
+}
+export async function transformOpenLibraryBook(source, options = {}) {
+    if (source.source.provider !== OPEN_LIBRARY_PROVIDER || source.source.category !== OPEN_LIBRARY_BOOK_CATEGORY) {
+        throw new Error(`unsupported Open Library source: ${source.source.provider}:${source.source.category}`);
+    }
+    const payload = openLibraryBookPayload(source.payload);
+    const work = payload.work;
+    const id = normalizeOpenLibraryBookId(source.source.externalId || work.key || "");
+    const title = stringField(work.title);
+    if (!title) {
+        throw new Error("missing required Open Library book field: title");
+    }
+    const zuuid = await providerZuuid({ provider: OPEN_LIBRARY_PROVIDER, category: OPEN_LIBRARY_BOOK_CATEGORY, externalId: id });
+    const data = createZuuidData({ zuuid, category: OPEN_LIBRARY_BOOK_CATEGORY, primaryTitle: title });
+    const preferredEdition = preferredOpenLibraryEdition(payload);
+    const rating = numberField(payload.ratings?.summary?.average ?? payload.ratings?.summary?.sortable ?? payload.search?.ratings_average);
+    if (rating !== undefined) {
+        data.rating = rating;
+        data.details.push({ key: "rating_average", value: rating, source: OPEN_LIBRARY_PROVIDER });
+    }
+    const ratingCount = numberField(payload.ratings?.summary?.count);
+    if (ratingCount !== undefined) {
+        data.details.push({ key: "rating_count", value: ratingCount, source: OPEN_LIBRARY_PROVIDER });
+    }
+    const firstPublishYear = numberField(payload.search?.first_publish_year);
+    const firstPublishDate = stringField(work.first_publish_date) ?? stringField(payload.search?.first_publish_date);
+    if (firstPublishYear !== undefined) {
+        data.primaryDate = String(firstPublishYear);
+        data.details.push({ key: "first_publish_year", value: firstPublishYear, source: OPEN_LIBRARY_PROVIDER });
+        if (firstPublishDate && firstPublishDate !== String(firstPublishYear)) {
+            data.details.push({ key: "work_first_publish_date", value: firstPublishDate, source: OPEN_LIBRARY_PROVIDER });
+        }
+    }
+    else if (firstPublishDate) {
+        data.primaryDate = firstPublishDate;
+        data.details.push({ key: "first_publish_date", value: firstPublishDate, source: OPEN_LIBRARY_PROVIDER });
+    }
+    const description = descriptionValue(work.description);
+    if (description) {
+        data.descriptions.push({ value: description, source: OPEN_LIBRARY_PROVIDER });
+    }
+    for (const edition of payload.editions?.entries ?? []) {
+        const editionDescription = descriptionValue(edition.description);
+        if (editionDescription && !data.descriptions.some((item) => item.value === editionDescription)) {
+            data.descriptions.push({ value: editionDescription, source: OPEN_LIBRARY_PROVIDER });
+        }
+    }
+    const primaryCover = work.covers?.find((cover) => typeof cover === "number") ??
+        preferredEdition?.covers?.find((cover) => typeof cover === "number") ??
+        payload.search?.cover_i;
+    const primaryCoverUrl = coverUrl(primaryCover, options.coverBaseUrl ?? OPEN_LIBRARY_COVER_BASE_URL);
+    if (primaryCoverUrl) {
+        data.cover = primaryCoverUrl;
+        data.media.push({
+            url: primaryCoverUrl,
+            mediaType: "image",
+            mediaCategory: "cover",
+            isPrimary: true,
+            source: OPEN_LIBRARY_PROVIDER
+        });
+    }
+    addArrayDetail(data, "subjects", work.subjects);
+    addArrayDetail(data, "subject_places", work.subject_places);
+    addArrayDetail(data, "subject_people", work.subject_people);
+    addArrayDetail(data, "subject_times", work.subject_times);
+    addStructuredDetail(data, "links", work.links);
+    addStructuredDetail(data, "excerpts", work.excerpts);
+    addStructuredDetail(data, "series", work.series);
+    addStructuredDetail(data, "cover_edition", work.cover_edition);
+    addOpenLibraryBookAggregateDetails(data, payload, preferredEdition);
+    if (typeof payload.editions?.size === "number") {
+        data.details.push({ key: "edition_count", value: payload.editions.size, source: OPEN_LIBRARY_PROVIDER });
+    }
+    else if (typeof payload.search?.edition_count === "number") {
+        data.details.push({ key: "edition_count", value: payload.search.edition_count, source: OPEN_LIBRARY_PROVIDER });
+    }
+    for (const subject of work.subjects ?? []) {
+        addTag(data, subject);
+    }
+    await addAuthorRelations(data, payload);
+    return attachSourceMetadata(data, source);
+}
+async function fetchOpenLibraryBookSearchDoc(provider, id, work) {
+    const byId = await fetchOpenLibraryBookSearchDocByQuery(provider, id, id, 5);
+    if (byId) {
+        return byId;
+    }
+    const title = stringField(work.title);
+    return title ? fetchOpenLibraryBookSearchDocByQuery(provider, id, title, 20) : undefined;
+}
+async function fetchOpenLibraryBookSearchDocByQuery(provider, id, query, limit) {
+    const payload = await provider.getJson("/search.json", {
+        q: query,
+        limit: String(limit),
+        fields: openLibraryBookSearchFields().join(",")
+    });
+    return payload?.docs?.find((doc) => openLibraryWorkIdFromKey(doc.key) === id);
+}
+async function fetchOpenLibraryAuthors(provider, work) {
+    const authors = [];
+    for (const ref of work.authors ?? []) {
+        const id = openLibraryAuthorIdFromKey(ref.author?.key);
+        if (!id) {
+            continue;
+        }
+        const author = await provider.getJson(`/authors/${id}.json`, {});
+        if (author) {
+            authors.push(author);
+        }
+    }
+    return authors;
+}
+async function fetchOpenLibraryBookSearchResults(provider, input) {
+    const query = searchQuery(input.query);
+    const fields = input.fields ?? openLibraryBookSearchFields();
+    const payload = await provider.getJson("/search.json", {
+        q: query,
+        page: String(input.page ?? 1),
+        limit: String(input.limit ?? 20),
+        fields: fields.join(","),
+        ...(input.language ? { language: input.language } : {})
+    });
+    return payload ?? {};
+}
+function openLibraryBookSearchFields() {
+    return [
+        "key",
+        "title",
+        "author_name",
+        "author_key",
+        "first_publish_year",
+        "first_publish_date",
+        "cover_i",
+        "ratings_average",
+        "edition_count",
+        "language",
+        "isbn",
+        "ia",
+        "subject",
+        "ddc",
+        "lcc",
+        "lccn"
+    ];
+}
+async function sourceRecordsFromSearchResults(results) {
+    const records = [];
+    for (const result of results ?? []) {
+        const id = openLibraryWorkIdFromKey(result.key);
+        if (!id) {
+            continue;
+        }
+        records.push(await createSourceRecord({
+            source: { provider: OPEN_LIBRARY_PROVIDER, category: OPEN_LIBRARY_BOOK_CATEGORY, externalId: id },
+            payload: result
+        }));
+    }
+    return records;
+}
+async function addAuthorRelations(data, payload) {
+    for (const [index, ref] of (payload.work.authors ?? []).entries()) {
+        const id = openLibraryAuthorIdFromKey(ref.author?.key);
+        if (!id) {
+            continue;
+        }
+        const author = payload.authors?.find((item) => openLibraryAuthorIdFromKey(item.key) === id);
+        const zuuid = await providerZuuid({ provider: OPEN_LIBRARY_PROVIDER, category: "author", externalId: id });
+        data.relations.push({
+            id: zuuid,
+            zuuid,
+            category: "author",
+            title: stringField(author?.name) ?? id,
+            date: stringField(author?.birth_date) ?? null,
+            cover: coverUrl(author?.photos?.find((photo) => typeof photo === "number"), OPEN_LIBRARY_COVER_BASE_URL),
+            rating: null,
+            weight: null,
+            relationType: "authored_by",
+            direction: "outgoing",
+            attribute: null,
+            order: index,
+            source: OPEN_LIBRARY_PROVIDER,
+            externalId: id
+        });
+    }
+}
+function addOpenLibraryBookAggregateDetails(data, payload, preferredEdition) {
+    const editions = payload.editions?.entries ?? [];
+    if (!editions.length && !payload.search) {
+        return;
+    }
+    addArrayDetail(data, "languages", uniqueStrings([...(payload.search?.language ?? []), ...editions.flatMap((edition) => languageKeys(edition.languages))]));
+    addArrayDetail(data, "isbn_10", uniqueStrings(editions.flatMap((edition) => edition.isbn_10 ?? [])));
+    addArrayDetail(data, "isbn_13", uniqueStrings(editions.flatMap((edition) => edition.isbn_13 ?? [])));
+    addArrayDetail(data, "isbn", uniqueStrings([...(payload.search?.isbn ?? []), ...editions.flatMap((edition) => [...(edition.isbn_10 ?? []), ...(edition.isbn_13 ?? [])])]));
+    addArrayDetail(data, "ia", payload.search?.ia);
+    addArrayDetail(data, "publishers", uniqueStrings(editions.flatMap((edition) => edition.publishers ?? [])));
+    addArrayDetail(data, "source_records", uniqueStrings(editions.flatMap((edition) => edition.source_records ?? [])));
+    addArrayDetail(data, "local_id", uniqueStrings(editions.flatMap((edition) => edition.local_id ?? [])));
+    addArrayDetail(data, "dewey_decimal_class", uniqueStrings([...(payload.search?.ddc ?? []), ...classificationSubjects(payload.work.subjects, "dewey")]));
+    addArrayDetail(data, "lc_classifications", uniqueStrings([...(payload.search?.lcc ?? []), ...classificationSubjects(payload.work.subjects, "lc")]));
+    addArrayDetail(data, "lccn", payload.search?.lccn);
+    addArrayDetail(data, "translated_from", uniqueStrings(editions.flatMap((edition) => languageKeys(edition.translated_from))));
+    addArrayDetail(data, "translation_of", uniqueStrings(editions.map((edition) => stringField(edition.translation_of)).filter((item) => Boolean(item))));
+    const contributors = uniqueObjects(editions.flatMap((edition) => (edition.contributors ?? [])
+        .map((contributor) => ({
+        role: stringField(contributor.role),
+        name: stringField(contributor.name)
+    }))
+        .filter((contributor) => contributor.name)));
+    addStructuredDetail(data, "contributors", contributors);
+    const classifications = combineEditionRecords(editions, "classifications");
+    addStructuredDetail(data, "classifications", classifications);
+    const identifiers = combineEditionRecords(editions, "identifiers");
+    addStructuredDetail(data, "identifiers", identifiers);
+    if (preferredEdition) {
+        const preferred = editionSummary(preferredEdition);
+        addStructuredDetail(data, "preferred_edition", preferred);
+        addDetail(data, "publish_date", preferredEdition.publish_date);
+        addDetail(data, "edition_name", preferredEdition.edition_name);
+        addDetail(data, "full_title", preferredEdition.full_title);
+        addDetail(data, "subtitle", preferredEdition.subtitle);
+        if (typeof preferredEdition.number_of_pages === "number") {
+            data.details.push({ key: "number_of_pages", value: preferredEdition.number_of_pages, source: OPEN_LIBRARY_PROVIDER });
+        }
+        addDetail(data, "physical_format", preferredEdition.physical_format);
+    }
+    const summaries = editions.map((edition) => editionSummary(edition)).filter((edition) => Object.keys(edition).length > 0);
+    addStructuredDetail(data, "editions", summaries);
+}
+function preferredOpenLibraryEdition(payload) {
+    const editions = payload.editions?.entries ?? [];
+    if (!editions.length) {
+        return undefined;
+    }
+    const coverEditionId = openLibraryEditionIdFromKey(payload.work.cover_edition?.key);
+    const coverEdition = editions.find((edition) => openLibraryEditionIdFromKey(edition.key) === coverEditionId);
+    if (coverEdition) {
+        return coverEdition;
+    }
+    return [...editions].sort((a, b) => editionScore(b, payload) - editionScore(a, payload))[0];
+}
+function editionScore(edition, payload) {
+    let score = 0;
+    const title = stringField(edition.title)?.toLowerCase();
+    const workTitle = stringField(payload.work.title)?.toLowerCase();
+    const languages = languageKeys(edition.languages);
+    if (title && workTitle && title === workTitle) {
+        score += 20;
+    }
+    if (languages.includes("eng")) {
+        score += 15;
+    }
+    if (edition.isbn_13?.length) {
+        score += 8;
+    }
+    if (edition.isbn_10?.length) {
+        score += 6;
+    }
+    if (edition.covers?.length) {
+        score += 5;
+    }
+    if (edition.publish_date) {
+        score += 4;
+    }
+    if (edition.publishers?.length) {
+        score += 3;
+    }
+    if (typeof edition.number_of_pages === "number") {
+        score += 2;
+    }
+    return score;
+}
+function editionSummary(edition) {
+    const summary = {};
+    addSummaryString(summary, "id", openLibraryEditionIdFromKey(edition.key));
+    addSummaryString(summary, "title", edition.title);
+    addSummaryString(summary, "subtitle", edition.subtitle);
+    addSummaryString(summary, "fullTitle", edition.full_title);
+    addSummaryString(summary, "editionName", edition.edition_name);
+    addSummaryString(summary, "publishDate", edition.publish_date);
+    addSummaryString(summary, "physicalFormat", edition.physical_format);
+    addSummaryNumber(summary, "numberOfPages", edition.number_of_pages);
+    addSummaryArray(summary, "publishers", edition.publishers);
+    addSummaryArray(summary, "isbn10", edition.isbn_10);
+    addSummaryArray(summary, "isbn13", edition.isbn_13);
+    addSummaryArray(summary, "languages", languageKeys(edition.languages));
+    addSummaryArray(summary, "translatedFrom", languageKeys(edition.translated_from));
+    addSummaryString(summary, "translationOf", edition.translation_of);
+    addSummaryArray(summary, "covers", edition.covers);
+    addSummaryArray(summary, "sourceRecords", edition.source_records);
+    addSummaryArray(summary, "localId", edition.local_id);
+    if (edition.contributors?.length) {
+        summary.contributors = edition.contributors;
+    }
+    if (edition.identifiers && Object.keys(edition.identifiers).length) {
+        summary.identifiers = edition.identifiers;
+    }
+    if (edition.classifications && Object.keys(edition.classifications).length) {
+        summary.classifications = edition.classifications;
+    }
+    return summary;
+}
+function addSummaryString(summary, key, value) {
+    const clean = stringField(value);
+    if (clean) {
+        summary[key] = clean;
+    }
+}
+function addSummaryNumber(summary, key, value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        summary[key] = value;
+    }
+}
+function addSummaryArray(summary, key, value) {
+    if (value?.length) {
+        summary[key] = value;
+    }
+}
+function languageKeys(value) {
+    return uniqueStrings((value ?? [])
+        .map((item) => stringField(item.key)?.replace(/^\/languages\//, ""))
+        .filter((item) => Boolean(item)));
+}
+function combineEditionRecords(editions, key) {
+    const combined = {};
+    for (const edition of editions) {
+        const record = edition[key];
+        if (!record) {
+            continue;
+        }
+        for (const [recordKey, value] of Object.entries(record)) {
+            if (value === undefined || value === null || (Array.isArray(value) && value.length === 0)) {
+                continue;
+            }
+            const values = Array.isArray(value) ? value : [value];
+            for (const item of values) {
+                combined[recordKey] = combined[recordKey] ?? [];
+                if (!combined[recordKey].some((existing) => JSON.stringify(existing) === JSON.stringify(item))) {
+                    combined[recordKey].push(item);
+                }
+            }
+        }
+    }
+    return Object.keys(combined).length ? combined : undefined;
+}
+function classificationSubjects(subjects, type) {
+    const values = [];
+    for (const subject of subjects ?? []) {
+        const clean = stringField(subject);
+        if (!clean) {
+            continue;
+        }
+        if (type === "dewey" && /^\d{3}(?:\/|\.)/.test(clean)) {
+            values.push(clean);
+        }
+        if (type === "lc" && /^[A-Za-z]{1,3}\d{1,5}(?:\.\w+)?(?:\s+\w+)*$/.test(clean) && !/^\d/.test(clean)) {
+            values.push(clean);
+        }
+    }
+    return uniqueStrings(values);
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values ?? []) {
+        const clean = stringField(value);
+        if (clean && !seen.has(clean)) {
+            seen.add(clean);
+            result.push(clean);
+        }
+    }
+    return result;
+}
+function uniqueObjects(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const key = JSON.stringify(value);
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function addTag(data, value) {
+    const tag = stringField(value)?.toLowerCase();
+    if (tag && !data.tags.includes(tag)) {
+        data.tags.push(tag);
+    }
+}
+function addArrayDetail(data, key, value) {
+    const clean = value?.map((item) => stringField(item)).filter((item) => Boolean(item));
+    if (clean?.length) {
+        data.details.push({ key, value: clean, source: OPEN_LIBRARY_PROVIDER });
+    }
+}
+function addDetail(data, key, value) {
+    const clean = stringField(value);
+    if (clean) {
+        data.details.push({ key, value: clean, source: OPEN_LIBRARY_PROVIDER });
+    }
+}
+function addStructuredDetail(data, key, value) {
+    if (value === undefined || value === null || (Array.isArray(value) && value.length === 0)) {
+        return;
+    }
+    data.details.push({ key, value, source: OPEN_LIBRARY_PROVIDER });
+}
+function paginationFromOpenLibrarySearchResponse(payload, input) {
+    const totalResults = payload.numFound ?? payload.num_found ?? 0;
+    const limit = input.limit ?? 20;
+    return {
+        page: input.page ?? 1,
+        totalPages: limit > 0 ? Math.ceil(totalResults / limit) : 0,
+        totalResults
+    };
+}
+function normalizeOpenLibraryBookId(value) {
+    const normalized = stringField(value)?.replace(/^\/works\//, "").replace(/\.json$/, "");
+    if (!normalized) {
+        throw new Error("Open Library book id must not be empty");
+    }
+    if (!/^OL\d+W$/i.test(normalized)) {
+        throw new Error(`Open Library book id must be a work id like OL82563W: ${value}`);
+    }
+    return normalized.toUpperCase();
+}
+function openLibraryWorkIdFromKey(value) {
+    const normalized = stringField(value)?.replace(/^\/works\//, "");
+    return normalized && /^OL\d+W$/i.test(normalized) ? normalized.toUpperCase() : undefined;
+}
+function openLibraryEditionIdFromKey(value) {
+    const normalized = stringField(value)?.replace(/^\/books\//, "");
+    return normalized && /^OL\d+M$/i.test(normalized) ? normalized.toUpperCase() : undefined;
+}
+function openLibraryAuthorIdFromKey(value) {
+    const normalized = stringField(value)?.replace(/^\/authors\//, "");
+    return normalized && /^OL\d+A$/i.test(normalized) ? normalized.toUpperCase() : undefined;
+}
+function coverUrl(coverId, baseUrl) {
+    if (typeof coverId !== "number" || !baseUrl) {
+        return null;
+    }
+    return `${baseUrl.replace(/\/$/, "")}/${coverId}-L.jpg`;
+}
+function descriptionValue(value) {
+    return typeof value === "string" ? stringField(value) : stringField(value?.value);
+}
+function openLibraryBookPayload(payload) {
+    const value = payload;
+    if ("work" in value && value.work) {
+        return value;
+    }
+    return { work: value };
+}
+function searchQuery(value) {
+    const query = stringField(value);
+    if (!query) {
+        throw new Error("Open Library search query must not be empty");
+    }
+    return query;
+}
+function stringField(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/dist/providers/openlibrary/client.d.ts

@@ -0,0 +1,22 @@
+import type { SearchResponse, ZuuidData, ZuuidSearchResult } from "../../entity.js";
+import type { SourceRecord } from "../../source.js";
+import { type FetchOpenLibraryAuthorInput } from "./author.js";
+import { type FetchOpenLibraryBookInput } from "./book.js";
+import type { OpenLibraryProviderOptions, OpenLibrarySearchInput, OpenLibraryTransformOptions } from "./types.js";
+export declare class OpenLibraryProvider {
+    readonly apiBase: string;
+    readonly coverBaseUrl: string | null;
+    private readonly fetchImpl;
+    constructor(options?: OpenLibraryProviderOptions);
+    getJson<T>(path: string, params: Record<string, string>): Promise<T | undefined>;
+    fetchBookSourceRecord(input: FetchOpenLibraryBookInput): Promise<SourceRecord | undefined>;
+    fetchBook(input: FetchOpenLibraryBookInput): Promise<ZuuidData | undefined>;
+    fetchAuthorSourceRecord(input: FetchOpenLibraryAuthorInput): Promise<SourceRecord | undefined>;
+    fetchAuthor(input: FetchOpenLibraryAuthorInput): Promise<ZuuidData | undefined>;
+    searchBookSourceRecords(input: OpenLibrarySearchInput): Promise<SearchResponse<SourceRecord>>;
+    searchBooks(input: OpenLibrarySearchInput): Promise<SearchResponse<ZuuidSearchResult>>;
+    searchAuthorSourceRecords(input: OpenLibrarySearchInput): Promise<SearchResponse<SourceRecord>>;
+    searchAuthors(input: OpenLibrarySearchInput): Promise<SearchResponse<ZuuidSearchResult>>;
+    transformOptions(): OpenLibraryTransformOptions;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/providers/openlibrary/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/providers/openlibrary/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAKL,KAAK,2BAA2B,EACjC,MAAM,aAAa,CAAC;AACrB,OAAO,EAKL,KAAK,yBAAyB,EAC/B,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAwB,0BAA0B,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAExI,qBAAa,mBAAmB;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;gBAErC,OAAO,GAAE,0BAA+B;IAM9C,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAqBhF,qBAAqB,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAI1F,SAAS,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAK3E,uBAAuB,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAI9F,WAAW,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAK/E,uBAAuB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAI7F,WAAW,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;IAItF,yBAAyB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAI/F,aAAa,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;IAI9F,gBAAgB,IAAI,2BAA2B;CAKhD"}

package/dist/providers/openlibrary/client.js

@@ -0,0 +1,61 @@
+import { fetchOpenLibraryAuthorSourceRecord, searchOpenLibraryAuthors, searchOpenLibraryAuthorSourceRecords, transformOpenLibraryAuthor } from "./author.js";
+import { fetchOpenLibraryBookSourceRecord, searchOpenLibraryBooks, searchOpenLibraryBookSourceRecords, transformOpenLibraryBook } from "./book.js";
+import { OPEN_LIBRARY_API_BASE, OPEN_LIBRARY_COVER_BASE_URL } from "./constants.js";
+export class OpenLibraryProvider {
+    apiBase;
+    coverBaseUrl;
+    fetchImpl;
+    constructor(options = {}) {
+        this.apiBase = options.apiBase ?? OPEN_LIBRARY_API_BASE;
+        this.coverBaseUrl = options.coverBaseUrl === undefined ? OPEN_LIBRARY_COVER_BASE_URL : options.coverBaseUrl;
+        this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    }
+    async getJson(path, params) {
+        const url = new URL(`${this.apiBase.replace(/\/$/, "")}/${path.replace(/^\//, "")}`);
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, value);
+        }
+        const headers = new Headers();
+        headers.set("accept", "application/json");
+        const response = await this.fetchImpl(url, { headers });
+        if (response.status === 404) {
+            return undefined;
+        }
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Open Library API returned ${response.status}: ${body}`);
+        }
+        return response.json();
+    }
+    async fetchBookSourceRecord(input) {
+        return fetchOpenLibraryBookSourceRecord(this, input);
+    }
+    async fetchBook(input) {
+        const source = await this.fetchBookSourceRecord(input);
+        return source ? transformOpenLibraryBook(source, this.transformOptions()) : undefined;
+    }
+    async fetchAuthorSourceRecord(input) {
+        return fetchOpenLibraryAuthorSourceRecord(this, input);
+    }
+    async fetchAuthor(input) {
+        const source = await this.fetchAuthorSourceRecord(input);
+        return source ? transformOpenLibraryAuthor(source, this.transformOptions()) : undefined;
+    }
+    async searchBookSourceRecords(input) {
+        return searchOpenLibraryBookSourceRecords(this, input);
+    }
+    async searchBooks(input) {
+        return searchOpenLibraryBooks(this, input, this.transformOptions());
+    }
+    async searchAuthorSourceRecords(input) {
+        return searchOpenLibraryAuthorSourceRecords(this, input);
+    }
+    async searchAuthors(input) {
+        return searchOpenLibraryAuthors(this, input);
+    }
+    transformOptions() {
+        return {
+            coverBaseUrl: this.coverBaseUrl
+        };
+    }
+}

package/dist/providers/openlibrary/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const OPEN_LIBRARY_PROVIDER = "openlibrary";
+export declare const OPEN_LIBRARY_API_BASE = "https://openlibrary.org";
+export declare const OPEN_LIBRARY_COVER_BASE_URL = "https://covers.openlibrary.org/b/id";
+//# sourceMappingURL=constants.d.ts.map

package/dist/providers/openlibrary/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/providers/openlibrary/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AACnD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAC/D,eAAO,MAAM,2BAA2B,wCAAwC,CAAC"}

package/dist/providers/openlibrary/constants.js

@@ -0,0 +1,3 @@
+export const OPEN_LIBRARY_PROVIDER = "openlibrary";
+export const OPEN_LIBRARY_API_BASE = "https://openlibrary.org";
+export const OPEN_LIBRARY_COVER_BASE_URL = "https://covers.openlibrary.org/b/id";

package/dist/providers/openlibrary/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./author.js";
+export * from "./book.js";
+export * from "./client.js";
+export * from "./constants.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/openlibrary/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/openlibrary/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dist/providers/openlibrary/index.js

@@ -0,0 +1,5 @@
+export * from "./author.js";
+export * from "./book.js";
+export * from "./client.js";
+export * from "./constants.js";
+export * from "./types.js";

package/dist/providers/openlibrary/types.d.ts

@@ -0,0 +1,23 @@
+export type OpenLibraryFetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type OpenLibraryProviderOptions = {
+    apiBase?: string;
+    coverBaseUrl?: string | null;
+    fetch?: OpenLibraryFetchLike;
+};
+export type OpenLibraryTransformOptions = {
+    coverBaseUrl?: string | null;
+};
+export type OpenLibrarySearchInput = {
+    query: string;
+    page?: number;
+    limit?: number;
+    language?: string;
+    fields?: string[];
+};
+export type OpenLibrarySearchResponse<T> = {
+    start?: number;
+    numFound?: number;
+    num_found?: number;
+    docs?: T[];
+};
+//# sourceMappingURL=types.d.ts.map