ochre-sdk 1.0.13 → 1.0.14

package/dist/parsers/helpers.d.mts

@@ -0,0 +1,27 @@
+import { MultilingualString } from "./multilingual.mjs";
+import { License } from "../types/index.mjs";
+import { XMLContent, XMLString } from "../xml/types.mjs";
+
+//#region src/parsers/helpers.d.ts
+type ParserOptions<T extends ReadonlyArray<string>> = {
+  languages: T;
+};
+declare function getParserOptions<T extends ReadonlyArray<string>>(options: ParserOptions<T>): ParserOptions<T>;
+declare function cleanObject<T extends Record<string, unknown>>(obj: T): Partial<T>;
+declare function parseLicense(availability: {
+  license: XMLString & {
+    target?: string;
+  };
+} | undefined): License | null;
+declare function parseStringLike(value: XMLString | string | undefined): string | null;
+declare function isXMLContent(value: XMLContent | XMLString): value is XMLContent;
+declare function multilingualFromText<T extends ReadonlyArray<string>>(text: string | {
+  text: string;
+  richText: string;
+}, options: ParserOptions<T>): MultilingualString<T>;
+declare function parseContentLike<T extends ReadonlyArray<string>>(value: XMLContent | XMLString | string | undefined, options: ParserOptions<T>): MultilingualString<T> | null;
+declare function parseRequiredContentLike<T extends ReadonlyArray<string>>(value: XMLContent | XMLString, options: ParserOptions<T>): MultilingualString<T>;
+declare function parseContentLikeText<T extends ReadonlyArray<string>>(value: XMLContent | XMLString | undefined, options: ParserOptions<T>): string;
+declare function parseStringContent(value: XMLContent | XMLString | string | undefined, options?: ParserOptions<ReadonlyArray<string>>): string;
+//#endregion
+export { ParserOptions, cleanObject, getParserOptions, isXMLContent, multilingualFromText, parseContentLike, parseContentLikeText, parseLicense, parseRequiredContentLike, parseStringContent, parseStringLike };

package/dist/parsers/helpers.mjs

@@ -0,0 +1,53 @@
+import { DEFAULT_LANGUAGES } from "../constants.mjs";
+import { MultilingualString } from "./multilingual.mjs";
+import { parseXMLContent, parseXMLString } from "./string.mjs";
+//#region src/parsers/helpers.ts
+const FALLBACK_PARSER_OPTIONS = { languages: DEFAULT_LANGUAGES };
+function getParserOptions(options) {
+	return { languages: options.languages };
+}
+function cleanObject(obj) {
+	const cleaned = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) cleaned[key] = value;
+	return cleaned;
+}
+function parseLicense(availability) {
+	if (availability == null) return null;
+	return {
+		content: parseStringLike(availability.license) ?? "",
+		target: availability.license.target ?? null
+	};
+}
+function parseStringLike(value) {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	return parseXMLString(value).text;
+}
+function isXMLContent(value) {
+	return "content" in value;
+}
+function multilingualFromText(text, options) {
+	const content = {};
+	for (const language of options.languages) content[language] = text;
+	return MultilingualString.fromObject(content, options.languages);
+}
+function parseContentLike(value, options) {
+	if (value == null) return null;
+	if (typeof value === "string") return multilingualFromText(value, options);
+	if (!isXMLContent(value)) return multilingualFromText(parseXMLString(value), options);
+	return parseXMLContent(value, { languages: options.languages });
+}
+function parseRequiredContentLike(value, options) {
+	return parseContentLike(value, options) ?? MultilingualString.empty(options.languages);
+}
+function parseContentLikeText(value, options) {
+	return parseContentLike(value, options)?.getText().trim() ?? "";
+}
+function parseStringContent(value, options = FALLBACK_PARSER_OPTIONS) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (isXMLContent(value)) return parseXMLContent(value, { languages: options.languages }).getText();
+	return parseXMLString(value).text;
+}
+//#endregion
+export { cleanObject, getParserOptions, isXMLContent, multilingualFromText, parseContentLike, parseContentLikeText, parseLicense, parseRequiredContentLike, parseStringContent, parseStringLike };

package/dist/parsers/index.d.mts

@@ -0,0 +1,65 @@
+import { Webpage } from "../types/website.mjs";
+import { Bibliography, ContainedItemCategoryFromOption, ContainedItemCategoryOption, Gallery, Identification, Item, ItemCategory, ItemLinks, Metadata, Note, Person, Property, Resource, SetItem, SetItemCategory, SimplifiedProperty } from "../types/index.mjs";
+import { XMLBibliography, XMLData, XMLDataItem, XMLGalleryData, XMLIdentification, XMLItemLinks, XMLLink, XMLMetadata, XMLNote, XMLPerson, XMLProperty, XMLResource, XMLSetItems, XMLSimplifiedProperty } from "../xml/types.mjs";
+import { ParserOptions, getParserOptions, parseStringLike } from "./helpers.mjs";
+
+//#region src/parsers/index.d.ts
+type RawOchre = XMLData["result"]["ochre"];
+type ResourceViewParser<T extends ReadonlyArray<string>> = (view: XMLResource["view"], context: Pick<Resource<T, "topLevel">, "belongsTo" | "metadata">) => Webpage<T> | null;
+type SetItemCategoryFromCategories<T extends ReadonlyArray<SetItemCategory> | undefined> = T extends ReadonlyArray<infer U> ? Extract<U, SetItemCategory> : SetItemCategory;
+declare function parseIdentification<T extends ReadonlyArray<string>>(rawIdentification: XMLIdentification, options: ParserOptions<T>): Identification<T>;
+declare function parseNotes<T extends ReadonlyArray<string>>(rawNotes: {
+  note: Array<XMLNote>;
+} | undefined, options: ParserOptions<T>): Array<Note<T>>;
+declare function parseProperties<T extends ReadonlyArray<string>>(rawProperties: {
+  property: Array<XMLProperty>;
+} | undefined, options: ParserOptions<T>): Array<Property<T>>;
+declare function parseSimplifiedProperties<T extends ReadonlyArray<string>>(rawProperties: {
+  property: Array<XMLSimplifiedProperty>;
+} | undefined, options: ParserOptions<T>): Array<SimplifiedProperty<T>>;
+declare function parseLinks<T extends ReadonlyArray<string>>(rawLinks: XMLLink | XMLDataItem | undefined, options: ParserOptions<T>): ItemLinks<T>;
+declare function parseBibliographyList<T extends ReadonlyArray<string>>(rawBibliographies: {
+  bibliography: Array<XMLBibliography>;
+} | undefined, options: ParserOptions<T>): Array<Bibliography<T, "embedded">>;
+declare function parsePersonList<T extends ReadonlyArray<string>>(rawPersons: Array<XMLPerson> | undefined, options: ParserOptions<T>): Array<Person<T, "embedded">>;
+declare function parseMetadataLanguages(rawOchre: {
+  metadata: XMLMetadata;
+  languages?: string;
+}): Array<string>;
+declare function resolveLanguages<T extends ReadonlyArray<string>>(requestedLanguages: T, metadataLanguages: Array<string>): T;
+declare function resolveDefaultLanguage<T extends ReadonlyArray<string>>(rawOchre: {
+  metadata: XMLMetadata;
+}, languages: T): T[number];
+declare function parseMetadata<T extends ReadonlyArray<string>>(rawOchre: {
+  uuidBelongsTo: string;
+  metadata: XMLMetadata;
+}, options: ParserOptions<T>, defaultLanguage: T[number]): Metadata<T>;
+declare function parseLinkedItems<const TContainedItemCategory extends ContainedItemCategoryOption<ItemCategory> | undefined = undefined, T extends ReadonlyArray<string> = ReadonlyArray<string>>(rawItems: XMLItemLinks | undefined, options: {
+  containedItemCategory?: TContainedItemCategory;
+  languages: T;
+}): Array<Item<ItemCategory, ContainedItemCategoryFromOption<ItemCategory, TContainedItemCategory>, T, "embedded">>;
+declare function parseSetItems<const TContainedItemCategories extends ReadonlyArray<SetItemCategory> | undefined = undefined, T extends ReadonlyArray<string> = ReadonlyArray<string>>(rawItems: XMLSetItems | undefined, options: {
+  containedItemCategories?: TContainedItemCategories;
+  languages: T;
+}): Array<SetItem<SetItemCategoryFromCategories<TContainedItemCategories>, T>>;
+declare function parseGallery<T extends ReadonlyArray<string>>(rawData: XMLGalleryData, options: ParserOptions<T>): Gallery<T>;
+declare function parseItem<const TContainedItemCategory extends ContainedItemCategoryOption<ItemCategory> | undefined = undefined, T extends ReadonlyArray<string> = ReadonlyArray<string>>(rawData: XMLData, options: {
+  category?: undefined;
+  containedItemCategory?: TContainedItemCategory;
+  languages: T;
+  parseResourceView?: ResourceViewParser<T>;
+}): Item<ItemCategory, ContainedItemCategoryFromOption<ItemCategory, TContainedItemCategory>, T>;
+declare function parseItem<const TCategory extends ItemCategory, const TContainedItemCategory extends ContainedItemCategoryOption<TCategory> | undefined = undefined, T extends ReadonlyArray<string> = ReadonlyArray<string>>(rawData: XMLData, options: {
+  category: TCategory;
+  containedItemCategory?: TContainedItemCategory;
+  languages: T;
+  parseResourceView?: ResourceViewParser<T>;
+}): Item<TCategory, ContainedItemCategoryFromOption<TCategory, TContainedItemCategory>, T>;
+declare function parseItem(rawData: XMLData, options: {
+  category?: ItemCategory;
+  containedItemCategory?: ContainedItemCategoryOption<ItemCategory>;
+  languages: ReadonlyArray<string>;
+  parseResourceView?: ResourceViewParser<ReadonlyArray<string>>;
+}): Item<ItemCategory, SetItemCategory, ReadonlyArray<string>>;
+//#endregion
+export { type ParserOptions, RawOchre, getParserOptions, parseBibliographyList, parseGallery, parseIdentification, parseItem, parseLinkedItems, parseLinks, parseMetadata, parseMetadataLanguages, parseNotes, parsePersonList, parseProperties, parseSetItems, parseSimplifiedProperties, parseStringLike, resolveDefaultLanguage, resolveLanguages };