ochre-sdk 1.0.78 → 1.1.0

package/dist/parsers/website/links.d.mts

@@ -0,0 +1,36 @@
+import { WebImage } from "../../types/website.mjs";
+import { ItemLink, ItemLinkCategory, ItemLinks, PropertyValueContent } from "../../types/index.mjs";
+import { WebsitePageSlugs } from "./slug.mjs";
+//#region src/parsers/website/links.d.ts
+/**
+ * The link categories a website can point at
+ */
+export type WebsiteLinkCategory = Extract<ItemLinkCategory, "resource" | "set" | "tree">;
+export declare function findWebsiteLink<U extends WebsiteLinkCategory, T extends ReadonlyArray<string>>(links: ItemLinks<T>, category: U, isMatch?: (link: ItemLink<U, T>) => boolean): ItemLink<U, T> | null;
+export declare function findWebsiteLinkByCategories<U extends WebsiteLinkCategory, T extends ReadonlyArray<string>>(links: ItemLinks<T>, categories: ReadonlyArray<U>): ItemLink<U, T> | null;
+export declare function getWebsiteLinks<U extends WebsiteLinkCategory, T extends ReadonlyArray<string>>(links: ItemLinks<T>, category: U): Array<ItemLink<U, T>>;
+/**
+ * Where a "link-to", "navigate-to" or "redirect-to" property points
+ *
+ * An external href is rewritten to an item route; anything else resolves
+ * through the page slug map, so a link to a page inside a segment gets that
+ * segment's full slug rather than the bare one OCHRE stores on the page.
+ * @param value - The raw property value holding the target
+ * @param pageSlugs - The website's resolved page slugs
+ * @returns The target, or null when the property carries none
+ * @internal
+ */
+export declare function parseWebsiteLinkTarget<T extends ReadonlyArray<string>>(value: PropertyValueContent<T> | null, pageSlugs: WebsitePageSlugs | undefined): string | null;
+/**
+ * The image a link stands for
+ *
+ * Built the same way wherever a website shows a linked image, so the six
+ * fields and the fallbacks for a link OCHRE has no dimensions for are stated
+ * once.
+ * @param link - The resource link pointing at the image
+ * @param quality - The quality the consumer should request
+ * @returns The image
+ * @internal
+ */
+export declare function webImageFromLink<T extends ReadonlyArray<string>>(link: ItemLinks<T>[number], quality: WebImage<T>["quality"]): WebImage<T>;
+//#endregion

package/dist/parsers/website/links.mjs

@@ -0,0 +1,58 @@
+import { transformPermanentIdentificationUrlToItemLink } from "../string.mjs";
+//#region src/parsers/website/links.ts
+function isWebsiteLink(link, category) {
+	return link.category === category;
+}
+function findWebsiteLink(links, category, isMatch) {
+	for (const link of links) if (isWebsiteLink(link, category) && (isMatch == null || isMatch(link))) return link;
+	return null;
+}
+function findWebsiteLinkByCategories(links, categories) {
+	for (const link of links) for (const category of categories) if (isWebsiteLink(link, category)) return link;
+	return null;
+}
+function getWebsiteLinks(links, category) {
+	const matchedLinks = [];
+	for (const link of links) if (isWebsiteLink(link, category)) matchedLinks.push(link);
+	return matchedLinks;
+}
+/**
+* Where a "link-to", "navigate-to" or "redirect-to" property points
+*
+* An external href is rewritten to an item route; anything else resolves
+* through the page slug map, so a link to a page inside a segment gets that
+* segment's full slug rather than the bare one OCHRE stores on the page.
+* @param value - The raw property value holding the target
+* @param pageSlugs - The website's resolved page slugs
+* @returns The target, or null when the property carries none
+* @internal
+*/
+function parseWebsiteLinkTarget(value, pageSlugs) {
+	if (value == null) return null;
+	if (value.href != null) return transformPermanentIdentificationUrlToItemLink(value.href);
+	return (value.uuid == null ? void 0 : pageSlugs?.get(value.uuid)) ?? value.slug;
+}
+/**
+* The image a link stands for
+*
+* Built the same way wherever a website shows a linked image, so the six
+* fields and the fallbacks for a link OCHRE has no dimensions for are stated
+* once.
+* @param link - The resource link pointing at the image
+* @param quality - The quality the consumer should request
+* @returns The image
+* @internal
+*/
+function webImageFromLink(link, quality) {
+	const image = "image" in link ? link.image : null;
+	return {
+		uuid: link.uuid,
+		label: link.identification.label,
+		description: link.description,
+		width: image?.width ?? 0,
+		height: image?.height ?? 0,
+		quality
+	};
+}
+//#endregion
+export { findWebsiteLink, findWebsiteLinkByCategories, getWebsiteLinks, parseWebsiteLinkTarget, webImageFromLink };

package/dist/parsers/website/messages.d.mts

@@ -0,0 +1,24 @@
+import { WebElementComponent } from "../../types/website.mjs";
+import { XMLWebsiteResource } from "../../xml/types.mjs";
+//#region src/parsers/website/messages.d.ts
+/**
+ * Name a resource well enough to find it in OCHRE from an error message
+ *
+ * Every throw in the website parser goes through here, because a UUID on its
+ * own is not something anyone can look up quickly and a label on its own is
+ * not unique.
+ * @param resource - The resource the error is about
+ * @returns A comma-separated description of the resource
+ * @internal
+ */
+export declare function formatXMLWebsiteResourceMetadata(resource: XMLWebsiteResource): string;
+/**
+ * Describe a component parser failure
+ * @param message - What went wrong
+ * @param componentName - The component being parsed
+ * @param elementResource - The element the component belongs to
+ * @returns The error message
+ * @internal
+ */
+export declare function formatComponentError(message: string, componentName: WebElementComponent["component"] | undefined, elementResource: XMLWebsiteResource): string;
+//#endregion

package/dist/parsers/website/messages.mjs

@@ -0,0 +1,31 @@
+import { parseStringContent } from "../helpers.mjs";
+//#region src/parsers/website/messages.ts
+/**
+* Name a resource well enough to find it in OCHRE from an error message
+*
+* Every throw in the website parser goes through here, because a UUID on its
+* own is not something anyone can look up quickly and a label on its own is
+* not unique.
+* @param resource - The resource the error is about
+* @returns A comma-separated description of the resource
+* @internal
+*/
+function formatXMLWebsiteResourceMetadata(resource) {
+	const metadata = [`label “${parseStringContent(resource.identification.label)}”`, `uuid “${resource.uuid}”`];
+	if (resource.slug != null) metadata.push(`slug “${resource.slug}”`);
+	if (resource.identification.abbreviation != null) metadata.push(`abbreviation “${parseStringContent(resource.identification.abbreviation)}”`);
+	return metadata.join(", ");
+}
+/**
+* Describe a component parser failure
+* @param message - What went wrong
+* @param componentName - The component being parsed
+* @param elementResource - The element the component belongs to
+* @returns The error message
+* @internal
+*/
+function formatComponentError(message, componentName, elementResource) {
+	return `${message} for component “${componentName ?? "(unknown)"}” (${formatXMLWebsiteResourceMetadata(elementResource)})`;
+}
+//#endregion
+export { formatComponentError, formatXMLWebsiteResourceMetadata };

package/dist/parsers/website/options.d.mts

@@ -0,0 +1,6 @@
+import { WebOptions } from "../../types/website.mjs";
+import { XMLWebsiteOptions } from "../../xml/types.mjs";
+import { ParserOptions } from "../helpers.mjs";
+//#region src/parsers/website/options.d.ts
+export declare function parseWebsiteOptions<T extends ReadonlyArray<string>>(rawOptions: XMLWebsiteOptions | undefined, options: ParserOptions<T>): WebOptions<T>;
+//#endregion

package/dist/parsers/website/options.mjs

@@ -0,0 +1,114 @@
+import { parseContentLike } from "../helpers.mjs";
+import { parseIdentification, parseNotes } from "../index.mjs";
+//#region src/parsers/website/options.ts
+function parseContextTreeLevel(contextItemToParse, options) {
+	let type = "";
+	const levels = [];
+	const levelsToParse = contextItemToParse.levels?.level ?? [];
+	for (const level of levelsToParse) {
+		const [rawVariableUuid = "", rawValueUuid] = level.payload.split(",", 2);
+		const valueUuid = rawValueUuid == null || rawValueUuid.trim() === "null" ? null : rawValueUuid.trim();
+		type = level.dataType ?? type;
+		levels.push({
+			variableUuid: rawVariableUuid.trim(),
+			valueUuid
+		});
+	}
+	return {
+		context: levels,
+		type,
+		identification: parseIdentification(contextItemToParse.identification, options),
+		description: parseContentLike(contextItemToParse.description, options)
+	};
+}
+function parseFilterContextDisplay(filterOption) {
+	switch (filterOption) {
+		case "inline-displayed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-closed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-open": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		case "sidebar-displayed-closed": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "sidebar-displayed-open": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		default: return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
+	}
+}
+function parseContexts(contextLevels, options) {
+	const contextTreeLevels = [];
+	for (const contextLevel of contextLevels) for (const contextItemToParse of contextLevel.context) contextTreeLevels.push(parseContextTreeLevel(contextItemToParse, options));
+	return contextTreeLevels;
+}
+function parseFilterContexts(filterContextLevels, options) {
+	const filterContextTreeLevels = [];
+	for (const filterContextLevel of filterContextLevels) for (const contextItemToParse of filterContextLevel.context) filterContextTreeLevels.push({
+		...parseContextTreeLevel(contextItemToParse, options),
+		filterType: contextItemToParse.filterType ?? "property",
+		filterVariant: contextItemToParse.filterVariant ?? null,
+		...parseFilterContextDisplay(contextItemToParse.filterOption)
+	});
+	return filterContextTreeLevels;
+}
+function parseAllOptionContexts(options, parserOptions) {
+	function handleContexts(contexts) {
+		return parseContexts(contexts ?? [], parserOptions);
+	}
+	function handleFilterContexts(contexts) {
+		return parseFilterContexts(contexts ?? [], parserOptions);
+	}
+	return {
+		flatten: handleContexts(options.flattenContexts),
+		suppress: handleContexts(options.suppressContexts),
+		filter: handleFilterContexts(options.filterContexts),
+		sort: handleContexts(options.sortContexts),
+		detail: handleContexts(options.detailContexts),
+		download: handleContexts(options.downloadContexts),
+		label: handleContexts(options.labelContexts),
+		prominent: handleContexts(options.prominentContexts)
+	};
+}
+function parseWebsiteScopes(scopes, options) {
+	if (scopes == null) return null;
+	return Array.from(scopes.scope, (scope) => ({
+		uuid: scope.uuid.payload,
+		type: scope.uuid.type,
+		identification: parseIdentification(scope.identification, options)
+	}));
+}
+function parseWebsiteOptions(rawOptions, options) {
+	const parsedOptions = {
+		scopes: parseWebsiteScopes(rawOptions?.scopes, options),
+		contextTree: rawOptions == null ? null : parseAllOptionContexts(rawOptions, options),
+		labels: { title: null }
+	};
+	const notes = parseNotes(rawOptions?.notes, options);
+	for (const note of notes) {
+		if (note.title?.getText() !== "Title label") continue;
+		parsedOptions.labels.title = note.content;
+		break;
+	}
+	return parsedOptions;
+}
+//#endregion
+export { parseWebsiteOptions };

package/dist/parsers/website/properties.d.mts

@@ -0,0 +1,12 @@
+import { WebSidebar, Website } from "../../types/website.mjs";
+import { XMLWebsiteProperties, XMLWebsiteTree } from "../../xml/types.mjs";
+import { ParserOptions } from "../helpers.mjs";
+//#region src/parsers/website/properties.d.ts
+/**
+ * Parses raw website properties into a standardized Website properties structure
+ *
+ * @param properties - Array of raw website properties in OCHRE format
+ * @returns Parsed WebsiteProperties object
+ */
+export declare function parseWebsiteProperties<T extends ReadonlyArray<string>>(properties: XMLWebsiteProperties["property"], websiteTree: XMLWebsiteTree, sidebar: WebSidebar<T> | null, options: ParserOptions<T>, parent: Website<T>["properties"] | null): Website<T>["properties"];
+//#endregion

package/dist/parsers/website/properties.mjs

@@ -0,0 +1,158 @@
+import { parseSimplifiedProperties } from "../index.mjs";
+import { parseWebsiteOptions } from "./options.mjs";
+import { websitePresentationReader } from "./reader.mjs";
+import { parseStylesheets } from "./styles.mjs";
+//#region src/parsers/website/properties.ts
+/**
+* Parses raw website properties into a standardized Website properties structure
+*
+* @param properties - Array of raw website properties in OCHRE format
+* @returns Parsed WebsiteProperties object
+*/
+function parseWebsiteProperties(properties, websiteTree, sidebar, options, parent) {
+	const mainProperties = parseSimplifiedProperties({ property: properties }, options);
+	const websiteReader = websitePresentationReader(mainProperties).nested("presentation");
+	const returnProperties = {
+		type: parent?.type ?? "traditional",
+		status: parent?.status ?? "development",
+		versionLabel: parent?.versionLabel ?? "release",
+		privacy: parent?.privacy ?? "public",
+		contact: parent?.contact ?? null,
+		loadingVariant: "spinner",
+		theme: {
+			isThemeToggleDisplayed: true,
+			defaultTheme: "system"
+		},
+		icon: {
+			logoUuid: null,
+			faviconUuid: null,
+			appleTouchIconUuid: null
+		},
+		navbar: {
+			isDisplayed: true,
+			variant: "default",
+			alignment: "start",
+			isProjectDisplayed: true,
+			searchBarBoundElementUuid: null,
+			items: parent?.navbar.items ?? null
+		},
+		footer: {
+			isDisplayed: true,
+			logoUuid: null,
+			items: parent?.footer.items ?? null
+		},
+		sidebar: sidebar ?? parent?.sidebar ?? null,
+		itemPage: {
+			isMainContentDisplayed: parent?.itemPage.isMainContentDisplayed ?? true,
+			description: {
+				isDisplayed: parent?.itemPage.description.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.description.isHeaderDisplayed ?? true
+			},
+			document: {
+				isDisplayed: parent?.itemPage.document.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.document.isHeaderDisplayed ?? true
+			},
+			notes: {
+				isDisplayed: parent?.itemPage.notes.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.notes.isHeaderDisplayed ?? true,
+				variant: parent?.itemPage.notes.variant ?? "discrete"
+			},
+			events: {
+				isDisplayed: parent?.itemPage.events.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.events.isHeaderDisplayed ?? true,
+				variant: parent?.itemPage.events.variant ?? "tabular"
+			},
+			periods: {
+				isDisplayed: parent?.itemPage.periods.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.periods.isHeaderDisplayed ?? true
+			},
+			isPropertiesDisplayed: parent?.itemPage.isPropertiesDisplayed ?? true,
+			bibliography: {
+				isDisplayed: parent?.itemPage.bibliography.isDisplayed ?? true,
+				isHeaderDisplayed: parent?.itemPage.bibliography.isHeaderDisplayed ?? true
+			},
+			isPropertyValuesGrouped: parent?.itemPage.isPropertyValuesGrouped ?? true,
+			isPublicationDateTimeDisplayed: parent?.itemPage.isPublicationDateTimeDisplayed ?? true,
+			isPersistentIdentifierDisplayed: parent?.itemPage.isPersistentIdentifierDisplayed ?? true,
+			iiifViewer: parent?.itemPage.iiifViewer ?? "universal-viewer"
+		},
+		options: {
+			contextTree: parent?.options.contextTree ?? null,
+			scopes: parent?.options.scopes ?? null,
+			labels: { title: parent?.options.labels.title ?? null },
+			stylesheets: { properties: parent?.options.stylesheets.properties ?? [] }
+		}
+	};
+	const contactProperty = websiteReader.property("contact");
+	if (contactProperty !== null) {
+		const contactContent = contactProperty.values[0]?.content.toString().split(";") ?? [];
+		if (contactContent.length === 2) returnProperties.contact = {
+			name: contactContent[0],
+			email: contactContent[1] ?? null
+		};
+		else throw new Error(`Contact property must use “name;email”, got “${contactProperty.values[0]?.content}” (website uuid “${websiteTree.uuid}”)`, { cause: websiteTree });
+	}
+	websiteReader.readAll(returnProperties, {
+		type: "webUI",
+		status: "status",
+		versionLabel: "version-label",
+		privacy: "privacy",
+		loadingVariant: "loading-variant"
+	});
+	websiteReader.readAll(returnProperties.theme, {
+		isThemeToggleDisplayed: "supports-theme-toggle",
+		defaultTheme: "default-theme"
+	});
+	websiteReader.readAllUuids(returnProperties.icon, {
+		logoUuid: "navbar-logo",
+		faviconUuid: "favicon-ico",
+		appleTouchIconUuid: "favicon-img"
+	});
+	websiteReader.readAll(returnProperties.navbar, {
+		isDisplayed: "navbar-displayed",
+		variant: "navbar-variant",
+		alignment: "navbar-alignment",
+		isProjectDisplayed: "navbar-project-displayed"
+	});
+	websiteReader.readAllUuids(returnProperties.navbar, { searchBarBoundElementUuid: "bound-element-navbar-search-bar" });
+	websiteReader.readAll(returnProperties.footer, { isDisplayed: "footer-displayed" });
+	websiteReader.readAllUuids(returnProperties.footer, { logoUuid: "footer-logo" });
+	const itemPageReader = websiteReader.nestedByValue("page-type", "item-page");
+	if (itemPageReader.size > 0) {
+		for (const [key, slug] of [
+			["description", "description"],
+			["document", "document"],
+			["notes", "notes"],
+			["events", "events"],
+			["periods", "periods"],
+			["bibliography", "bibliography"]
+		]) {
+			const section = returnProperties.itemPage[key];
+			itemPageReader.readAll(section, {
+				isDisplayed: `item-page-${slug}-displayed`,
+				isHeaderDisplayed: `item-page-${slug}-header-displayed`
+			});
+		}
+		itemPageReader.readAll(returnProperties.itemPage.notes, { variant: "item-page-notes-display-variant" });
+		itemPageReader.readAll(returnProperties.itemPage.events, { variant: "item-page-events-display-variant" });
+		itemPageReader.readAll(returnProperties.itemPage, {
+			isPropertyValuesGrouped: "item-page-property-values-grouped",
+			isPublicationDateTimeDisplayed: "item-page-publication-date-time-displayed",
+			isPersistentIdentifierDisplayed: "item-page-persistent-identifier-displayed",
+			iiifViewer: "item-page-iiif-viewer"
+		});
+	}
+	if (websiteTree.options != null) {
+		const parsedOptions = parseWebsiteOptions(websiteTree.options, options);
+		returnProperties.options.scopes = (parsedOptions.scopes != null && parsedOptions.scopes.length > 0 ? parsedOptions : returnProperties.options).scopes;
+		returnProperties.options.contextTree = parsedOptions.contextTree ?? returnProperties.options.contextTree;
+		returnProperties.options.labels = { title: parsedOptions.labels.title ?? returnProperties.options.labels.title };
+	}
+	if ("styleOptions" in websiteTree && websiteTree.styleOptions != null) {
+		const stylesheetProperties = parseStylesheets(websiteTree.styleOptions.style);
+		if (stylesheetProperties.length > 0) returnProperties.options.stylesheets.properties = stylesheetProperties;
+	}
+	return returnProperties;
+}
+//#endregion
+export { parseWebsiteProperties };

package/dist/parsers/website/reader.d.mts

@@ -3,24 +3,74 @@ import { LanguageCodes, PropertyValueContent, SimplifiedProperty } from "../../t
 import { ParserOptions } from "../helpers.mjs";
 //#region src/parsers/website/reader.d.ts
 type WebsitePropertyContent<T extends LanguageCodes> = PropertyValueContent<T>["content"];
+/**
+ * The fields of an object that hold a UUID, which are the only ones
+ * {@link WebsitePresentationReader.readAllUuids} can write
+ */
+type UuidKeys<O> = { [K in keyof O]-?: O[K] extends string | null ? K : never; }[keyof O];
+/**
+ * Reads a website's presentation properties
+ *
+ * OCHRE stores everything a website declares about itself as labeled property
+ * values nested under a "presentation" property, so every read is "find the
+ * property with this label, then take its first value". This owns that walk
+ * and the coercions that go with it, and hands back readers for nested levels
+ * so the caller never touches the raw property array.
+ */
 export declare class WebsitePresentationReader<T extends LanguageCodes> {
   private readonly sourceProperties;
   constructor(sourceProperties: ReadonlyArray<SimplifiedProperty<T>>);
+  private propertyByValue;
+  /**
+   * Overwrite one field from a labeled OCHRE property
+   *
+   * Private because {@link readAll} covers every caller: a single-field read
+   * is a one-entry label map, and going through the map keeps the field's type
+   * coming from the target rather than from a type argument.
+   */
+  private readOne;
   property(label: string): SimplifiedProperty<T> | null;
   requiredProperty(label: string, message: string): SimplifiedProperty<T>;
-  propertyByValue(label: string, value: WebsitePropertyContent<T>): SimplifiedProperty<T> | null;
   valueNode(label: string): PropertyValueContent<T> | null;
-  values(label: string): Array<PropertyValueContent<T>>;
   value<U = WebsitePropertyContent<T>>(label: string): U | null;
   valueOr<U>(label: string, fallback: U): U;
+  /**
+   * Read a property whose field is a string but whose OCHRE value may not be
+   *
+   * OCHRE types a dimension like "width" from what was entered, so the same
+   * property arrives as `"50%"` on one resource and `50` on another. Anything
+   * that is neither is treated as unset rather than stringified, so a stray
+   * boolean does not become the literal text "true".
+   * @param label - The OCHRE property label to read
+   * @returns The string, or null when the property is unset or not string-like
+   */
   stringValue(label: string): string | null;
-  numberValue(label: string): number | null;
   uuid(label: string): string | null;
   multilingualValue(label: string, options: ParserOptions<T>): MultilingualString<T> | null;
+  /**
+   * Overwrite several fields from the OCHRE properties naming them
+   *
+   * The defaults object carries the shape and the fallback values, and the
+   * label map carries the OCHRE names, so a component states each property
+   * twice rather than five times: once as a default and once as a label. The
+   * field's type comes from the defaults object, so no type argument is needed.
+   * @param target - The object holding the fields, pre-filled with defaults
+   * @param labels - The OCHRE property label for each field to overwrite
+   */
+  readAll<O extends object>(target: O, labels: Partial<Record<keyof O, string>>): void;
+  /**
+   * Overwrite several UUID fields from the UUIDs labeled OCHRE properties
+   * point at
+   *
+   * The same shape as {@link readAll}, for the fields that take the value's
+   * target rather than its content.
+   * @param target - The object holding the fields, pre-filled with defaults
+   * @param labels - The OCHRE property label for each field to overwrite
+   */
+  readAllUuids<O extends object>(target: O, labels: Partial<Record<UuidKeys<O>, string>>): void;
   nested(label: string): WebsitePresentationReader<T>;
   nestedByValue(label: string, value: WebsitePropertyContent<T>): WebsitePresentationReader<T>;
   get size(): number;
-  get properties(): ReadonlyArray<SimplifiedProperty<T>>;
 }
 export declare function websitePresentationReader<T extends LanguageCodes>(properties: ReadonlyArray<SimplifiedProperty<T>>): WebsitePresentationReader<T>;
 //#endregion

package/dist/parsers/website/reader.mjs

@@ -1,27 +1,46 @@
-import { getPropertyByVariableLabel, getPropertyByVariableLabelAndValueContent, getPropertyValueByVariableLabel } from "../../getters.mjs";
+import { getProperty, getPropertyValue } from "../../getters.mjs";
 import { multilingualFromText } from "../helpers.mjs";
 //#region src/parsers/website/reader.ts
+/**
+* Reads a website's presentation properties
+*
+* OCHRE stores everything a website declares about itself as labeled property
+* values nested under a "presentation" property, so every read is "find the
+* property with this label, then take its first value". This owns that walk
+* and the coercions that go with it, and hands back readers for nested levels
+* so the caller never touches the raw property array.
+*/
 var WebsitePresentationReader = class WebsitePresentationReader {
 	sourceProperties;
 	constructor(sourceProperties) {
 		this.sourceProperties = sourceProperties;
 	}
+	propertyByValue(label, value) {
+		return getProperty(this.sourceProperties, {
+			label,
+			valueContent: value
+		});
+	}
+	/**
+	* Overwrite one field from a labeled OCHRE property
+	*
+	* Private because {@link readAll} covers every caller: a single-field read
+	* is a one-entry label map, and going through the map keeps the field's type
+	* coming from the target rather than from a type argument.
+	*/
+	readOne(target, key, label) {
+		target[key] = this.valueOr(label, target[key]);
+	}
 	property(label) {
-		return getPropertyByVariableLabel(this.sourceProperties, label);
+		return getProperty(this.sourceProperties, { label });
 	}
 	requiredProperty(label, message) {
 		const property = this.property(label);
 		if (property === null) throw new Error(message, { cause: this.sourceProperties });
 		return property;
 	}
-	propertyByValue(label, value) {
-		return getPropertyByVariableLabelAndValueContent(this.sourceProperties, label, value);
-	}
 	valueNode(label) {
-		return getPropertyValueByVariableLabel(this.sourceProperties, label);
-	}
-	values(label) {
-		return this.property(label)?.values ?? [];
+		return getPropertyValue(this.sourceProperties, { label });
 	}
 	value(label) {
 		return this.valueNode(label)?.content ?? null;
@@ -29,16 +48,20 @@ var WebsitePresentationReader = class WebsitePresentationReader {
 	valueOr(label, fallback) {
 		return this.value(label) ?? fallback;
 	}
+	/**
+	* Read a property whose field is a string but whose OCHRE value may not be
+	*
+	* OCHRE types a dimension like "width" from what was entered, so the same
+	* property arrives as `"50%"` on one resource and `50` on another. Anything
+	* that is neither is treated as unset rather than stringified, so a stray
+	* boolean does not become the literal text "true".
+	* @param label - The OCHRE property label to read
+	* @returns The string, or null when the property is unset or not string-like
+	*/
 	stringValue(label) {
 		const value = this.value(label);
-		return value == null ? null : value.toString();
-	}
-	numberValue(label) {
-		const value = this.value(label);
-		if (typeof value === "number") return value;
-		if (typeof value !== "string" || value.trim() === "") return null;
-		const parsedValue = Number(value);
-		return Number.isNaN(parsedValue) ? null : parsedValue;
+		if (typeof value === "string") return value;
+		return typeof value === "number" ? value.toString() : null;
 	}
 	uuid(label) {
 		return this.valueNode(label)?.uuid ?? null;
@@ -49,6 +72,31 @@ var WebsitePresentationReader = class WebsitePresentationReader {
 		if (value.label != null) return value.label;
 		return typeof value.content === "string" ? multilingualFromText(value.content, options) : null;
 	}
+	/**
+	* Overwrite several fields from the OCHRE properties naming them
+	*
+	* The defaults object carries the shape and the fallback values, and the
+	* label map carries the OCHRE names, so a component states each property
+	* twice rather than five times: once as a default and once as a label. The
+	* field's type comes from the defaults object, so no type argument is needed.
+	* @param target - The object holding the fields, pre-filled with defaults
+	* @param labels - The OCHRE property label for each field to overwrite
+	*/
+	readAll(target, labels) {
+		for (const [key, label] of Object.entries(labels)) if (label != null) this.readOne(target, key, label);
+	}
+	/**
+	* Overwrite several UUID fields from the UUIDs labeled OCHRE properties
+	* point at
+	*
+	* The same shape as {@link readAll}, for the fields that take the value's
+	* target rather than its content.
+	* @param target - The object holding the fields, pre-filled with defaults
+	* @param labels - The OCHRE property label for each field to overwrite
+	*/
+	readAllUuids(target, labels) {
+		for (const [key, label] of Object.entries(labels)) if (label != null) target[key] = this.uuid(label) ?? target[key];
+	}
 	nested(label) {
 		return new WebsitePresentationReader(this.property(label)?.properties ?? []);
 	}
@@ -58,9 +106,6 @@ var WebsitePresentationReader = class WebsitePresentationReader {
 	get size() {
 		return this.sourceProperties.length;
 	}
-	get properties() {
-		return this.sourceProperties;
-	}
 };
 function websitePresentationReader(properties) {
 	return new WebsitePresentationReader(properties);