camox 0.43.0 → 0.45.0

package/dist/core/lib/imagePlaceholder.js

@@ -0,0 +1,177 @@
+import { getImagePlaceholderTitle, isImagePlaceholder } from "./contentType.js";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/core/lib/imagePlaceholder.tsx
+const presentationProps = /* @__PURE__ */ new Set([
+	"id",
+	"className",
+	"style",
+	"width",
+	"height",
+	"title",
+	"role",
+	"tabIndex",
+	"hidden",
+	"dir",
+	"lang"
+]);
+const landscapeLayers = [
+	{
+		path: "M0 680 190 470 280 520 560 180 650 330 720 290 1020 610 1200 550V800H0Z",
+		shade: 5
+	},
+	{
+		path: "M0 500Q180 350 380 470T780 490Q1000 350 1200 460V800H0Z",
+		shade: 9
+	},
+	{
+		path: "M0 590Q200 690 440 550T850 570Q1040 650 1200 530V800H0Z",
+		shade: 14
+	},
+	{
+		path: "M0 650Q160 580 330 660T660 650Q850 590 1010 480L1200 390V800H0Z",
+		shade: 20
+	}
+];
+const placeholderFill = "var(--camox-placeholder, #f1f3f5)";
+const placeholderInk = "var(--camox-placeholder-ink, #64748b)";
+function PlaceholderLandscape() {
+	const $ = c(10);
+	const id = React.useId();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { color: placeholderFill };
+		$[0] = t0;
+	} else t0 = $[0];
+	let t1;
+	if ($[1] !== id) {
+		t1 = landscapeLayers.map((t2, index) => {
+			const { shade } = t2;
+			return /* @__PURE__ */ jsxs("linearGradient", {
+				id: `${id}-hill-${index}`,
+				x1: "0",
+				y1: "0",
+				x2: "0",
+				y2: "1",
+				children: [/* @__PURE__ */ jsx("stop", {
+					offset: "0",
+					stopColor: `color-mix(in oklab, currentColor ${100 - shade}%, #64748b)`
+				}), /* @__PURE__ */ jsx("stop", {
+					offset: "1",
+					stopColor: `color-mix(in oklab, currentColor ${104 - shade}%, #64748b)`
+				})]
+			}, index);
+		});
+		$[1] = id;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== t1) {
+		t2 = /* @__PURE__ */ jsx("defs", { children: t1 });
+		$[3] = t1;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== id) {
+		t3 = landscapeLayers.map((t4, index_0) => {
+			const { path } = t4;
+			return /* @__PURE__ */ jsx("path", {
+				d: path,
+				fill: `url(#${id}-hill-${index_0})`
+			}, index_0);
+		});
+		$[5] = id;
+		$[6] = t3;
+	} else t3 = $[6];
+	let t4;
+	if ($[7] !== t2 || $[8] !== t3) {
+		t4 = /* @__PURE__ */ jsxs("g", {
+			style: t0,
+			children: [t2, t3]
+		});
+		$[7] = t2;
+		$[8] = t3;
+		$[9] = t4;
+	} else t4 = $[9];
+	return t4;
+}
+/**
+* Run after the author's callback. Only direct images of explicitly synthesized
+* assets are replaced; picture elements, wrappers and custom components retain
+* their URL fallback. Refs and event handlers also keep the image intact rather
+* than silently dropping behavior or handing callers an incompatible SVG node.
+*/
+function renderImagePlaceholder(value, rendered) {
+	if (!isImagePlaceholder(value)) return rendered;
+	if (!React.isValidElement(rendered)) return rendered;
+	if (rendered.type !== "img") return rendered;
+	const props = rendered.props;
+	if (Object.entries(props).some(([name, value]) => value != null && (name === "ref" || /^on[A-Z]/.test(name) || name === "useMap" || name === "isMap"))) return rendered;
+	const svgProps = {};
+	for (const [name, value] of Object.entries(props)) if (presentationProps.has(name) || name.startsWith("aria-") || name.startsWith("data-")) svgProps[name] = value;
+	const hasLabel = Boolean(props["aria-label"] || props["aria-labelledby"] || props.alt);
+	const decorative = props["aria-hidden"] === true || props["aria-hidden"] === "true" || !hasLabel;
+	return /* @__PURE__ */ jsxs("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		width: 1200,
+		height: "auto",
+		viewBox: "0 0 1200 800",
+		preserveAspectRatio: "xMidYMid slice",
+		role: decorative ? void 0 : "img",
+		"aria-label": props["aria-labelledby"] ? void 0 : props.alt || void 0,
+		"aria-hidden": decorative ? true : void 0,
+		focusable: "false",
+		...svgProps,
+		children: [
+			/* @__PURE__ */ jsx("rect", {
+				width: "1200",
+				height: "800",
+				style: { fill: placeholderFill }
+			}),
+			/* @__PURE__ */ jsx(PlaceholderLandscape, {}),
+			/* @__PURE__ */ jsx("foreignObject", {
+				x: "60",
+				y: "300",
+				width: "1080",
+				height: "200",
+				children: /* @__PURE__ */ jsx("div", {
+					style: {
+						display: "flex",
+						alignItems: "center",
+						justifyContent: "center",
+						height: "100%",
+						fontFamily: "inherit",
+						fontSize: 48
+					},
+					children: /* @__PURE__ */ jsx("span", {
+						style: {
+							display: "block",
+							maxWidth: "100%",
+							color: placeholderFill,
+							background: "currentColor",
+							borderRadius: 16,
+							padding: "16px 28px"
+						},
+						children: /* @__PURE__ */ jsx("span", {
+							style: {
+								color: placeholderInk,
+								display: "block",
+								overflow: "hidden",
+								textOverflow: "ellipsis",
+								whiteSpace: "nowrap",
+								lineHeight: 1.25,
+								userSelect: "none"
+							},
+							children: getImagePlaceholderTitle(value)
+						})
+					})
+				})
+			})
+		]
+	}, rendered.key);
+}
+
+//#endregion
+export { renderImagePlaceholder };

package/dist/core/lib/imageTransform.js

@@ -9,7 +9,7 @@ const DEFAULT_SRCSET_WIDTHS = [
 ];
 const DEFAULT_SRC_WIDTH = 1280;
 const DEFAULT_SIZES = "100vw";
-const MIN_OPTIMIZE_SIZE = 50 * 1024;
+const MIN_OPTIMIZE_SIZE = 51200;
 function isNonProxiedHostname(hostname) {
 	if (hostname === "localhost") return true;
 	if (hostname === "127.0.0.1") return true;

package/dist/core/lib/lexicalReact.d.ts

@@ -1 +1,3 @@
-import { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData } from "./textStyles.js";
+import { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData } from "./textStyles.js";
+import "react";
+export type { InlineStyle, InlineTextStyles, TextLinkStyleData, TextStyleData };

package/dist/core/lib/lexicalState.js

@@ -50,9 +50,9 @@ function extractMarkdownFromNode(node) {
 function serializeInlineChildren(nodes) {
 	const marks = [
 		{
-			flag: FORMAT_FLAGS.underline,
-			open: "<u>",
-			close: "</u>"
+			flag: FORMAT_FLAGS.strikethrough,
+			open: "<s>",
+			close: "</s>"
 		},
 		{
 			flag: FORMAT_FLAGS.bold,
@@ -90,7 +90,7 @@ function serializeInlineChildren(nodes) {
 		let text = (node.text ?? "").replace(/[\\*_[\]<>]/g, "\\$&");
 		if (node.format & FORMAT_FLAGS.italic) text = `<em>${text}</em>`;
 		if (node.format & FORMAT_FLAGS.bold) text = `<strong>${text}</strong>`;
-		if (node.format & FORMAT_FLAGS.underline) text = `<u>${text}</u>`;
+		if (node.format & FORMAT_FLAGS.strikethrough) text = `<s>${text}</s>`;
 		return text;
 	}).join("");
 }
@@ -204,7 +204,7 @@ function parseTokens(tokens, format) {
 			else nodes.push(...children);
 			continue;
 		}
-		const tag = token.type === "html" ? /^<(highlight|u|strong|em)>$/.exec(token.raw)?.[1] : void 0;
+		const tag = token.type === "html" ? /^<(highlight|s|strong|em)>$/.exec(token.raw)?.[1] : void 0;
 		if (tag) {
 			let depth = 1;
 			let end = i + 1;
@@ -216,7 +216,7 @@ function parseTokens(tokens, format) {
 			}
 			if (!depth) {
 				const tagFlags = {
-					u: FORMAT_FLAGS.underline,
+					s: FORMAT_FLAGS.strikethrough,
 					strong: FORMAT_FLAGS.bold,
 					em: FORMAT_FLAGS.italic
 				};
@@ -240,4 +240,4 @@ function parseTokens(tokens, format) {
 }
 
 //#endregion
-export { isLexicalState, lexicalStateToMarkdown, lexicalStateToPlainText, markdownToLexicalState };
+export { isLexicalState, lexicalStateToMarkdown, lexicalStateToPlainText, markdownToLexicalState, parseInlineMarkdown };

package/dist/core/lib/modifierFormats.js

@@ -3,7 +3,7 @@
 const FORMAT_FLAGS = {
 	bold: 1,
 	italic: 2,
-	underline: 8,
+	strikethrough: 4,
 	highlight: 1 << 20
 };
 

package/dist/core/lib/previewPaused.js

@@ -0,0 +1,9 @@
+//#region src/core/lib/previewPaused.ts
+/**
+* Set on the root of a preview document while Camox pauses it, such as a
+* Canvas frame nobody is looking at.
+*/
+const PREVIEW_PAUSED_ATTRIBUTE = "data-camox-paused";
+
+//#endregion
+export { PREVIEW_PAUSED_ATTRIBUTE };

package/dist/core/lib/recordScope.js

@@ -0,0 +1,316 @@
+import { useProjectUuid } from "../../lib/auth.js";
+import { useLocation } from "../../features/navigation/navigation.js";
+import { resolveAssetValue, useNormalizedData } from "../../lib/normalized-data.js";
+import { useLinkPages } from "../../lib/link-pages.js";
+import { renderImagePlaceholder } from "./imagePlaceholder.js";
+import { buildImageSrcSet, getDefaultImageSizes, getDefaultImageWidth, transformImageUrl } from "./imageTransform.js";
+import { markdownToReactNodes } from "./lexicalReact.js";
+import { fieldPlainText } from "../recordItem.js";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/core/lib/recordScope.tsx
+const RecordContext = React.createContext(null);
+function useFieldValue(name) {
+	const record = React.use(RecordContext);
+	if (!record) throw new Error("Record fields must be used within layout.Item");
+	return record.content[name];
+}
+const Field = (t0) => {
+	const $ = c(8);
+	const { name, textStyle, linkStyle, children } = t0;
+	const value = useFieldValue(name);
+	const pages = useLinkPages(useProjectUuid());
+	let t1;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = { select: _temp };
+		$[0] = t1;
+	} else t1 = $[0];
+	const pathname = useLocation(t1);
+	let t2;
+	if ($[1] !== children || $[2] !== linkStyle || $[3] !== pages || $[4] !== pathname || $[5] !== textStyle || $[6] !== value) {
+		t2 = children({ children: markdownToReactNodes(value, {
+			pages,
+			fallbackHref: pathname,
+			textStyle,
+			linkStyle
+		}) }, { text: fieldPlainText(value) });
+		$[1] = children;
+		$[2] = linkStyle;
+		$[3] = pages;
+		$[4] = pathname;
+		$[5] = textStyle;
+		$[6] = value;
+		$[7] = t2;
+	} else t2 = $[7];
+	return t2;
+};
+function renderImage(value, children) {
+	return renderImagePlaceholder(value, children({
+		src: transformImageUrl(value.url, {
+			width: getDefaultImageWidth(),
+			mimeType: value.mimeType,
+			size: value.size
+		}),
+		srcSet: buildImageSrcSet(value.url, value.mimeType, value.size),
+		sizes: getDefaultImageSizes(),
+		alt: value.alt
+	}, value));
+}
+function renderFile(value, children) {
+	return children({
+		href: value.url,
+		download: value.filename
+	}, value);
+}
+/** An asset field's value; unset assets render nothing rather than a fabricated default. */
+function useAsset(name) {
+	const $ = c(3);
+	const { filesMap } = useNormalizedData();
+	const value = useFieldValue(name);
+	let t0;
+	if ($[0] !== filesMap || $[1] !== value) {
+		t0 = value == null ? null : resolveAssetValue(value, filesMap);
+		$[0] = filesMap;
+		$[1] = value;
+		$[2] = t0;
+	} else t0 = $[2];
+	return t0;
+}
+const Image = (t0) => {
+	const $ = c(3);
+	const { name, children } = t0;
+	const value = useAsset(name);
+	let t1;
+	if ($[0] !== children || $[1] !== value) {
+		t1 = value ? renderImage(value, children) : null;
+		$[0] = children;
+		$[1] = value;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+const File = (t0) => {
+	const $ = c(3);
+	const { name, children } = t0;
+	const value = useAsset(name);
+	let t1;
+	if ($[0] !== children || $[1] !== value) {
+		t1 = value ? renderFile(value, children) : null;
+		$[0] = children;
+		$[1] = value;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+const Embed = (t0) => {
+	const $ = c(3);
+	const { name, children } = t0;
+	const value = useFieldValue(name);
+	const url = typeof value === "string" ? value : "";
+	let t1;
+	if ($[0] !== children || $[1] !== url) {
+		t1 = children({ src: url }, { url });
+		$[0] = children;
+		$[1] = url;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+function useAssetList(name) {
+	const $ = c(6);
+	const { filesMap } = useNormalizedData();
+	const value = useFieldValue(name);
+	if (!Array.isArray(value)) {
+		let t0;
+		if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+			t0 = [];
+			$[0] = t0;
+		} else t0 = $[0];
+		return t0;
+	}
+	let t0;
+	if ($[1] !== filesMap || $[2] !== value) {
+		let t1;
+		if ($[4] !== filesMap) {
+			t1 = (asset) => resolveAssetValue(asset, filesMap);
+			$[4] = filesMap;
+			$[5] = t1;
+		} else t1 = $[5];
+		t0 = value.map(t1).filter(Boolean);
+		$[1] = filesMap;
+		$[2] = value;
+		$[3] = t0;
+	} else t0 = $[3];
+	return t0;
+}
+const ImageList = (t0) => {
+	const $ = c(5);
+	const { name, children } = t0;
+	const t1 = useAssetList(name);
+	let t2;
+	if ($[0] !== children || $[1] !== t1) {
+		let t3;
+		if ($[3] !== children) {
+			t3 = (value, index) => /* @__PURE__ */ jsx(React.Fragment, { children: renderImage(value, children) }, index);
+			$[3] = children;
+			$[4] = t3;
+		} else t3 = $[4];
+		t2 = t1.map(t3);
+		$[0] = children;
+		$[1] = t1;
+		$[2] = t2;
+	} else t2 = $[2];
+	return t2;
+};
+const FileList = (t0) => {
+	const $ = c(5);
+	const { name, children } = t0;
+	const t1 = useAssetList(name);
+	let t2;
+	if ($[0] !== children || $[1] !== t1) {
+		let t3;
+		if ($[3] !== children) {
+			t3 = (value, index) => /* @__PURE__ */ jsx(React.Fragment, { children: renderFile(value, children) }, index);
+			$[3] = children;
+			$[4] = t3;
+		} else t3 = $[4];
+		t2 = t1.map(t3);
+		$[0] = children;
+		$[1] = t1;
+		$[2] = t2;
+	} else t2 = $[2];
+	return t2;
+};
+const LinksContext = React.createContext(void 0);
+function useLinked(name) {
+	const record = React.use(RecordContext);
+	const links = React.use(LinksContext);
+	return {
+		schema: record?.properties[name],
+		linked: links?.[name]
+	};
+}
+const Reference = (t0) => {
+	const $ = c(4);
+	const { name, children } = t0;
+	const { schema, linked } = useLinked(name);
+	if (!linked || Array.isArray(linked) || linked.collectionId !== schema?.collectionId) return null;
+	let t1;
+	if ($[0] !== children || $[1] !== linked || $[2] !== schema.referenceSchema.properties) {
+		t1 = /* @__PURE__ */ jsx(RecordScope, {
+			record: linked,
+			properties: schema.referenceSchema.properties,
+			hop: 2,
+			children
+		});
+		$[0] = children;
+		$[1] = linked;
+		$[2] = schema.referenceSchema.properties;
+		$[3] = t1;
+	} else t1 = $[3];
+	return t1;
+};
+const ReferenceList = (t0) => {
+	const $ = c(9);
+	const { name, children } = t0;
+	const { schema, linked } = useLinked(name);
+	if (!Array.isArray(linked)) return null;
+	let t1;
+	if ($[0] !== children || $[1] !== linked || $[2] !== schema) {
+		let t2;
+		if ($[4] !== schema?.collectionId) {
+			t2 = (record) => record.collectionId === schema?.collectionId;
+			$[4] = schema?.collectionId;
+			$[5] = t2;
+		} else t2 = $[5];
+		let t3;
+		if ($[6] !== children || $[7] !== schema) {
+			t3 = (record_0) => /* @__PURE__ */ jsx(RecordScope, {
+				record: record_0,
+				properties: schema.referenceSchema.properties,
+				hop: 2,
+				children
+			}, record_0.id);
+			$[6] = children;
+			$[7] = schema;
+			$[8] = t3;
+		} else t3 = $[8];
+		t1 = linked.filter(t2).map(t3);
+		$[0] = children;
+		$[1] = linked;
+		$[2] = schema;
+		$[3] = t1;
+	} else t1 = $[3];
+	return t1;
+};
+/**
+* Renders `record` with its typed scope. The first hop also renders the records it links
+* (the second hop), which link nothing further.
+*/
+function RecordScope(t0) {
+	const $ = c(14);
+	const { record, properties, hop, children } = t0;
+	let t1;
+	if ($[0] !== properties || $[1] !== record.content) {
+		t1 = {
+			content: record.content,
+			properties
+		};
+		$[0] = properties;
+		$[1] = record.content;
+		$[2] = t1;
+	} else t1 = $[2];
+	const value = t1;
+	const t2 = hop === 1 ? record.references : void 0;
+	let t3;
+	if ($[3] !== children || $[4] !== hop || $[5] !== record.id || $[6] !== record.label) {
+		t3 = children({
+			id: record.id,
+			label: record.label,
+			Field,
+			Image,
+			File,
+			Embed,
+			ImageList,
+			FileList,
+			...hop === 1 ? {
+				Reference,
+				ReferenceList
+			} : {}
+		});
+		$[3] = children;
+		$[4] = hop;
+		$[5] = record.id;
+		$[6] = record.label;
+		$[7] = t3;
+	} else t3 = $[7];
+	let t4;
+	if ($[8] !== t2 || $[9] !== t3) {
+		t4 = /* @__PURE__ */ jsx(LinksContext.Provider, {
+			value: t2,
+			children: t3
+		});
+		$[8] = t2;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	let t5;
+	if ($[11] !== t4 || $[12] !== value) {
+		t5 = /* @__PURE__ */ jsx(RecordContext.Provider, {
+			value,
+			children: t4
+		});
+		$[11] = t4;
+		$[12] = value;
+		$[13] = t5;
+	} else t5 = $[13];
+	return t5;
+}
+function _temp(location) {
+	return location.pathname;
+}
+
+//#endregion
+export { RecordScope };

package/dist/core/lib/reference.d.ts

@@ -0,0 +1,81 @@
+import { InlineTextStyles } from "./textStyles.js";
+import "./lexicalReact.js";
+import { EmbedURL, FileValue, ImageValue, ReferenceListSchema, ReferenceSchema } from "./contentType.js";
+import * as React from "react";
+import { Static, TSchema } from "@sinclair/typebox";
+//#region src/core/lib/reference.d.ts
+type Keys<T extends Record<string, TSchema>, V> = { [K in keyof T & string]: Static<T[K]> extends V ? K : never; }[keyof T & string];
+type TextKeys<T extends Record<string, TSchema>> = { [K in keyof T & string]: T[K] extends {
+  fieldType: "String";
+} ? K : never; }[keyof T & string];
+type Primitive<K, P, D> = (props: {
+  name: K;
+  children: (props: P, data: D) => React.ReactNode;
+}) => React.ReactNode;
+/**
+ * The typed scope of a placed record. A record placed by a block or item (the first hop) also
+ * renders the records it links; those (the second hop) link nothing further.
+ */
+export type ReferenceScope<T extends Record<string, TSchema>, Nested extends boolean = true> = RecordFields<T> & (Nested extends true ? LinkedRecords<T> : unknown);
+type LinkedRecords<T extends Record<string, TSchema>> = {
+  Reference: <K extends ReferenceKeys<T>>(props: {
+    name: K;
+    children: (scope: ReferenceScope<ReferenceContent<T[K]>, false>) => React.ReactNode;
+  }) => React.ReactNode;
+  ReferenceList: <K extends ReferenceListKeys<T>>(props: {
+    name: K;
+    children: (scope: ReferenceScope<ReferenceContent<T[K]>, false>) => React.ReactNode;
+  }) => React.ReactNode;
+};
+type RecordFields<T extends Record<string, TSchema>> = {
+  id: string;
+  label: string;
+  Field: (props: InlineTextStyles & {
+    name: TextKeys<T>;
+    children: (props: React.HTMLAttributes<HTMLElement> & {
+      ref?: React.Ref<any>;
+    }, data: {
+      text: string;
+    }) => React.ReactNode;
+  }) => React.ReactNode;
+  Image: Primitive<Keys<T, ImageValue>, {
+    src: string;
+    alt: string;
+    srcSet?: string;
+    sizes?: string;
+  }, ImageValue>;
+  File: Primitive<Keys<T, FileValue>, {
+    href: string;
+    download: string;
+  }, FileValue>;
+  Embed: Primitive<Keys<T, EmbedURL>, {
+    src: string;
+  }, {
+    url: string;
+  }>;
+  ImageList: Primitive<Keys<T, ImageValue[]>, {
+    src: string;
+    alt: string;
+    srcSet?: string;
+    sizes?: string;
+  }, ImageValue>;
+  FileList: Primitive<Keys<T, FileValue[]>, {
+    href: string;
+    download: string;
+  }, FileValue>;
+};
+export type ReferenceKeys<T extends Record<string, TSchema>> = { [K in keyof T & string]: T[K] extends ReferenceSchema<any> ? K : never; }[keyof T & string];
+export type ReferenceListKeys<T extends Record<string, TSchema>> = { [K in keyof T & string]: T[K] extends ReferenceListSchema<any> ? K : never; }[keyof T & string];
+export type ReferenceContent<T extends TSchema> = T extends ReferenceSchema<infer C> ? C : T extends ReferenceListSchema<infer C> ? C : never;
+export type ReferenceRecord = {
+  id: string;
+  collectionId: string;
+  label: string;
+  content: Record<string, unknown>;
+  /** When its content last changed, for a record page's record. */
+  updatedAt?: number;
+  /** The records this record links, when it was placed at the first hop. */
+  references?: Record<string, ReferenceRecord | ReferenceRecord[] | null>;
+};
+//#endregion
+export {};

package/dist/core/lib/reference.js

@@ -0,0 +1,29 @@
+//#region src/core/lib/reference.ts
+/**
+* A record page's record: as its loader returned it, or as a later save through any placement
+* stored it, whichever changed last.
+*/
+function latestContent(loaded, saved) {
+	if (!saved || loaded.updatedAt == null || saved.updatedAt <= loaded.updatedAt) return loaded;
+	return {
+		content: saved.content,
+		updatedAt: saved.updatedAt
+	};
+}
+function resolveReference(value, collectionId, records) {
+	if (typeof value !== "string") return null;
+	const record = records.get(value);
+	return record?.collectionId === collectionId ? record : null;
+}
+/** The record ids a reference list value links, in stored order; anything else links none. */
+function referenceListIds(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((id) => typeof id === "string" && id !== "");
+}
+/** The records a reference list links, in stored order; unresolved ids are skipped. */
+function resolveReferenceList(value, collectionId, records) {
+	return referenceListIds(value).map((id) => resolveReference(id, collectionId, records)).filter((record) => record !== null);
+}
+
+//#endregion
+export { latestContent, referenceListIds, resolveReference, resolveReferenceList };