camox 0.43.0 → 0.45.0

package/dist/features/preview/components/useFieldWriter.js

@@ -0,0 +1,200 @@
+import { useProjectUuid } from "../../../lib/auth.js";
+import { useCamoxApp } from "../../provider/components/CamoxAppContext.js";
+import { referenceList } from "../../../lib/normalized-data.js";
+import { reads, useStudioCache } from "../../../lib/studio-reads.js";
+import { lexicalStateToPlainText } from "../../../core/lib/lexicalState.js";
+import { referenceListIds } from "../../../core/lib/reference.js";
+import { blockMutations, collectionMutations, repeatableItemMutations } from "../../../lib/queries.js";
+import { invalidateCollectionRecordViews } from "../../../lib/collection-cache.js";
+import { serializeAssetField } from "../../content/collection-form.js";
+import { contentFieldSchema } from "./contentFieldSchema.js";
+import { referenceWritesFor } from "../../../core/editing/referenceWrites.js";
+import { c } from "react/compiler-runtime";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "@camox/ui/toaster";
+
+//#region src/features/preview/components/useFieldWriter.ts
+const fieldTypeOf = (schema, fieldName) => contentFieldSchema(schema, fieldName)?.fieldType;
+function listOwnerIn(bundle, owner) {
+	if (owner.kind === "block") return bundle.block;
+	return bundle.repeatableItems.find((item) => item.id === owner.itemId);
+}
+/** A block bundle whose reference list stores `ids`, hydrated from `records` in that order. */
+function withReferenceList(bundle, owner, fieldName, ids, records) {
+	const withList = (current) => ({
+		...current,
+		content: {
+			...current.content,
+			[fieldName]: ids
+		},
+		references: {
+			...current.references,
+			[fieldName]: ids.flatMap((id) => records.find((record) => record.id === id) ?? [])
+		}
+	});
+	if (owner.kind === "block") return {
+		...bundle,
+		block: withList(bundle.block)
+	};
+	return {
+		...bundle,
+		repeatableItems: bundle.repeatableItems.map((item) => item.id === owner.itemId ? withList(item) : item)
+	};
+}
+/**
+* Shows a reference list change in the sidebar and preview before the server confirms it:
+* the block's draft stores the new ids, and its hydrated records follow the same order.
+* Newly linked records are fetched (or read from the record cache) and inserted as soon as
+* they resolve, so the preview shows them without waiting for the block refetch.
+* Returns an undo.
+*/
+function applyReferenceListOptimistically(studioCache, blockId, owner, fieldName, ids, linkRecord) {
+	const edit = studioCache.edit();
+	const bundle = reads.blockBundle(blockId);
+	const previous = edit.get(bundle);
+	const previousOwner = previous && listOwnerIn(previous, owner);
+	if (!previous || !previousOwner) return () => {};
+	const hydrated = referenceList(previousOwner.references, fieldName);
+	edit.set(bundle, withReferenceList(previous, owner, fieldName, ids, hydrated));
+	const missing = ids.filter((id) => !hydrated.some((record) => record.id === id));
+	if (missing.length > 0) Promise.all(missing.map(linkRecord)).then((linked) => edit.set(bundle, (current) => {
+		const currentOwner = current && listOwnerIn(current, owner);
+		if (!current || !currentOwner) return current;
+		if (referenceListIds(currentOwner.content[fieldName]).join() !== ids.join()) return current;
+		return withReferenceList(current, owner, fieldName, ids, [...referenceList(currentOwner.references, fieldName), ...linked]);
+	})).catch(() => {});
+	return () => edit.rollback();
+}
+/**
+* Returns the single field-change handler shared by every sidebar field editor
+* (field list, asset and link views). Reference and reference list changes return a promise
+* so callers like the create-record modal can wait for the link.
+* Record edits go through the per-record queue shared with inline preview
+* edits, as full content with the expected version; their assets are sent as
+* collection asset snapshots rather than block file markers.
+*/
+function useFieldWriter(target, schema) {
+	const $ = c(13);
+	const queryClient = useQueryClient();
+	const projectUuid = useProjectUuid();
+	const camoxApp = useCamoxApp();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = blockMutations.updateContent();
+		$[0] = t0;
+	} else t0 = $[0];
+	const updateBlockContent = useMutation(t0);
+	let t1;
+	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = repeatableItemMutations.updateContent();
+		$[1] = t1;
+	} else t1 = $[1];
+	const updateItemContent = useMutation(t1);
+	let t2;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = collectionMutations.edit();
+		$[2] = t2;
+	} else t2 = $[2];
+	const editRecord = useMutation(t2);
+	const studioCache = useStudioCache();
+	let t3;
+	if ($[3] !== camoxApp || $[4] !== editRecord || $[5] !== projectUuid || $[6] !== queryClient || $[7] !== schema || $[8] !== studioCache || $[9] !== target || $[10] !== updateBlockContent || $[11] !== updateItemContent) {
+		t3 = (fieldName, value) => {
+			if (target?.kind === "record") {
+				const fieldType = fieldTypeOf(schema, fieldName);
+				const awaited = fieldType === "Reference" || fieldType === "ReferenceList";
+				const { record } = target;
+				const saving = referenceWritesFor(queryClient).save(record, fieldName, serializeAssetField(fieldType, value), async (input) => {
+					const saved = await editRecord.mutateAsync({
+						...input,
+						projectUuid
+					});
+					studioCache.set(reads.record({
+						projectUuid,
+						collectionId: record.collectionId,
+						id: record.id
+					}), saved);
+					invalidateCollectionRecordViews(studioCache, projectUuid, record.collectionId);
+					return saved;
+				}).then(_temp);
+				if (awaited) return saving;
+				saving.catch(_temp2);
+				return;
+			}
+			const content = { [fieldName]: value };
+			const mutation = target?.kind === "item" ? updateItemContent : updateBlockContent;
+			const id = target?.kind === "item" ? target.itemId : target?.blockId;
+			const field = contentFieldSchema(schema, fieldName);
+			if (field?.fieldType === "ReferenceList" && target) {
+				const { collectionId: t4 } = field;
+				const collectionId = t4 === void 0 ? "" : t4;
+				const linkRecord = async (recordId) => {
+					const record_0 = await studioCache.ensure(reads.record({
+						projectUuid,
+						collectionId,
+						id: recordId
+					}));
+					const labelField = camoxApp.getCollectionById(collectionId)?._internal.label;
+					const label = labelField ? record_0.content[labelField] : void 0;
+					return {
+						id: record_0.id,
+						collectionId,
+						content: record_0.content,
+						label: typeof label === "string" ? lexicalStateToPlainText(label) : ""
+					};
+				};
+				return (async () => {
+					const restore = applyReferenceListOptimistically(studioCache, target.blockId, target.kind === "item" ? {
+						kind: "item",
+						itemId: target.itemId
+					} : { kind: "block" }, fieldName, referenceListIds(value), linkRecord);
+					try {
+						if (target.kind === "item") await updateItemContent.mutateAsync({
+							id: target.itemId,
+							content
+						});
+						else await updateBlockContent.mutateAsync({
+							id: target.blockId,
+							content
+						});
+					} catch (t5) {
+						const cause_0 = t5;
+						restore();
+						throw cause_0;
+					}
+					studioCache.invalidate(reads.blockBundle(target.blockId));
+				})();
+			}
+			if (field?.fieldType === "Reference") return (async () => {
+				if (id == null) throw new Error("Nothing to change this reference on.");
+				await mutation.mutateAsync({
+					id,
+					content
+				});
+			})();
+			if (id == null) return;
+			mutation.mutate({
+				id,
+				content
+			});
+		};
+		$[3] = camoxApp;
+		$[4] = editRecord;
+		$[5] = projectUuid;
+		$[6] = queryClient;
+		$[7] = schema;
+		$[8] = studioCache;
+		$[9] = target;
+		$[10] = updateBlockContent;
+		$[11] = updateItemContent;
+		$[12] = t3;
+	} else t3 = $[12];
+	return t3;
+}
+function _temp2(cause) {
+	toast.error(cause instanceof Error ? cause.message : "Could not save item");
+}
+function _temp() {}
+
+//#endregion
+export { useFieldWriter };

package/dist/features/preview/components/useRecordView.js

@@ -0,0 +1,383 @@
+import { useCamoxApp } from "../../provider/components/CamoxAppContext.js";
+import { placedRecords, referenceList } from "../../../lib/normalized-data.js";
+import { referenceListIds } from "../../../core/lib/reference.js";
+import { isBlockPlacement, previewStore, recordPlacement } from "../previewStore.js";
+import { contentFieldSchema } from "./contentFieldSchema.js";
+import { formatFieldName } from "./ItemFieldsEditor.js";
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { isQueryBacked } from "@camox/api-contract";
+
+//#region src/features/preview/components/useRecordView.ts
+/**
+* Whether a reference field still links the record: the id a reference stores, any id a
+* reference list contains, or any record a query-backed list resolved to (it stores nothing).
+*/
+function linksRecord(field, owner, fieldName, recordId) {
+	if (isQueryBacked(field)) return referenceList(owner.references, fieldName).some((record) => record.id === recordId);
+	const stored = owner.content?.[fieldName];
+	if (field?.fieldType === "ReferenceList") return referenceListIds(stored).includes(recordId);
+	return stored === recordId;
+}
+function isLayoutPlacer(placer) {
+	return placer != null && "record" in placer;
+}
+/**
+* Resolves a record or record-field selection into the record it shows, while the placer's
+* reference field still links that record, or the reference list still contains it. A layout
+* places the record its record page loaded, through no reference field. A record
+* linked by a placed record (`nested`) resolves through that record's own links. A stale
+* selection (a field no longer links its record) shows, and then selects, that reference field's
+* view instead.
+*/
+function useRecordView(t0) {
+	const $ = c(77);
+	const { owner, selection, placer } = t0;
+	const camoxApp = useCamoxApp();
+	const recordSelection = selection?.type === "record" || selection?.type === "record-field" ? selection : null;
+	const nested = recordSelection?.nested;
+	const blockSelection = recordSelection && isBlockPlacement(recordSelection) ? recordSelection : null;
+	const layoutSelection = recordSelection && !isBlockPlacement(recordSelection) ? recordSelection : null;
+	const blockPlacer = placer && !isLayoutPlacer(placer) ? placer : null;
+	const layoutPlacer = isLayoutPlacer(placer) ? placer : null;
+	const referenceFieldName = blockSelection?.fieldName;
+	let nestedCollection;
+	let nestedField;
+	let nestedRecord;
+	let nestedStale;
+	let outerCollection;
+	let outerRecord;
+	let outerStale;
+	let referenceField;
+	let referenceFieldType;
+	let t1;
+	if ($[0] !== blockPlacer || $[1] !== blockSelection || $[2] !== camoxApp || $[3] !== layoutPlacer || $[4] !== layoutSelection || $[5] !== nested || $[6] !== referenceFieldName) {
+		referenceField = referenceFieldName ? contentFieldSchema(blockPlacer?.contentSchema, referenceFieldName) : void 0;
+		const outerCollectionId = layoutSelection ? layoutPlacer?.collectionId : referenceField?.collectionId;
+		outerCollection = outerCollectionId ? camoxApp.getCollectionById(outerCollectionId) : void 0;
+		outerStale = blockSelection ? blockPlacer != null && !linksRecord(referenceField, blockPlacer, blockSelection.fieldName, blockSelection.recordId) : layoutSelection != null && layoutPlacer != null && layoutPlacer.record.id !== layoutSelection.recordId;
+		let t2;
+		if ($[17] !== blockPlacer?.references || $[18] !== blockSelection || $[19] !== layoutPlacer?.record || $[20] !== layoutSelection || $[21] !== outerStale) {
+			t2 = () => {
+				if (outerStale) return;
+				if (blockSelection) return placedRecords(blockPlacer?.references, blockSelection.fieldName).find((record) => record.id === blockSelection.recordId);
+				if (layoutSelection) return layoutPlacer?.record;
+			};
+			$[17] = blockPlacer?.references;
+			$[18] = blockSelection;
+			$[19] = layoutPlacer?.record;
+			$[20] = layoutSelection;
+			$[21] = outerStale;
+			$[22] = t2;
+		} else t2 = $[22];
+		outerRecord = t2();
+		nestedField = nested ? contentFieldSchema(outerCollection?._internal.contentSchema, nested.fieldName) : void 0;
+		nestedCollection = nestedField?.collectionId ? camoxApp.getCollectionById(nestedField.collectionId) : void 0;
+		nestedStale = nested != null && outerRecord != null && !linksRecord(nestedField, outerRecord, nested.fieldName, nested.recordId);
+		nestedRecord = nested && outerRecord && !nestedStale ? placedRecords(outerRecord.references, nested.fieldName).find((record_0) => record_0.id === nested.recordId) : void 0;
+		const fieldTypeOf = _temp;
+		referenceFieldType = fieldTypeOf(referenceField);
+		t1 = fieldTypeOf(nestedField);
+		$[0] = blockPlacer;
+		$[1] = blockSelection;
+		$[2] = camoxApp;
+		$[3] = layoutPlacer;
+		$[4] = layoutSelection;
+		$[5] = nested;
+		$[6] = referenceFieldName;
+		$[7] = nestedCollection;
+		$[8] = nestedField;
+		$[9] = nestedRecord;
+		$[10] = nestedStale;
+		$[11] = outerCollection;
+		$[12] = outerRecord;
+		$[13] = outerStale;
+		$[14] = referenceField;
+		$[15] = referenceFieldType;
+		$[16] = t1;
+	} else {
+		nestedCollection = $[7];
+		nestedField = $[8];
+		nestedRecord = $[9];
+		nestedStale = $[10];
+		outerCollection = $[11];
+		outerRecord = $[12];
+		outerStale = $[13];
+		referenceField = $[14];
+		referenceFieldType = $[15];
+		t1 = $[16];
+	}
+	const nestedFieldType = t1;
+	const recordBlockId = blockSelection?.blockId;
+	const recordItemId = blockSelection?.itemId;
+	const recordLayoutId = layoutSelection?.layoutId;
+	let t2;
+	bb0: {
+		if (recordBlockId == null || !referenceFieldName) {
+			t2 = null;
+			break bb0;
+		}
+		let t3;
+		if ($[23] !== referenceFieldName || $[24] !== referenceFieldType) {
+			t3 = {
+				fieldName: referenceFieldName,
+				fieldType: referenceFieldType
+			};
+			$[23] = referenceFieldName;
+			$[24] = referenceFieldType;
+			$[25] = t3;
+		} else t3 = $[25];
+		const field_0 = t3;
+		if (recordItemId == null) {
+			let t4;
+			if ($[26] !== field_0 || $[27] !== recordBlockId) {
+				t4 = {
+					type: "block-field",
+					blockId: recordBlockId,
+					...field_0
+				};
+				$[26] = field_0;
+				$[27] = recordBlockId;
+				$[28] = t4;
+			} else t4 = $[28];
+			t2 = t4;
+			break bb0;
+		}
+		let t4;
+		if ($[29] !== field_0 || $[30] !== recordBlockId || $[31] !== recordItemId) {
+			t4 = {
+				type: "item-field",
+				blockId: recordBlockId,
+				itemId: recordItemId,
+				...field_0
+			};
+			$[29] = field_0;
+			$[30] = recordBlockId;
+			$[31] = recordItemId;
+			$[32] = t4;
+		} else t4 = $[32];
+		t2 = t4;
+	}
+	const referenceFieldSelection = t2;
+	let t3;
+	if ($[33] !== recordSelection) {
+		t3 = recordSelection ? _temp2(recordPlacement(recordSelection)) : null;
+		$[33] = recordSelection;
+		$[34] = t3;
+	} else t3 = $[34];
+	const outerPlacement = t3;
+	const recordId = recordSelection?.recordId;
+	const nestedFieldName = nested?.fieldName;
+	let t4;
+	bb1: {
+		if (!recordId || !nestedFieldName) {
+			t4 = null;
+			break bb1;
+		}
+		let t5;
+		if ($[35] !== nestedFieldName || $[36] !== nestedFieldType) {
+			t5 = {
+				recordFieldName: nestedFieldName,
+				recordFieldType: nestedFieldType
+			};
+			$[35] = nestedFieldName;
+			$[36] = nestedFieldType;
+			$[37] = t5;
+		} else t5 = $[37];
+		const field_1 = t5;
+		if (recordLayoutId != null) {
+			let t6;
+			if ($[38] !== field_1 || $[39] !== recordId || $[40] !== recordLayoutId) {
+				t6 = {
+					type: "record-field",
+					layoutId: recordLayoutId,
+					recordId,
+					...field_1
+				};
+				$[38] = field_1;
+				$[39] = recordId;
+				$[40] = recordLayoutId;
+				$[41] = t6;
+			} else t6 = $[41];
+			t4 = t6;
+			break bb1;
+		}
+		if (recordBlockId == null || !referenceFieldName) {
+			t4 = null;
+			break bb1;
+		}
+		let t6;
+		if ($[42] !== recordItemId) {
+			t6 = recordItemId == null ? {} : { itemId: recordItemId };
+			$[42] = recordItemId;
+			$[43] = t6;
+		} else t6 = $[43];
+		let t7;
+		if ($[44] !== field_1 || $[45] !== recordBlockId || $[46] !== recordId || $[47] !== referenceFieldName || $[48] !== t6) {
+			t7 = {
+				type: "record-field",
+				blockId: recordBlockId,
+				...t6,
+				fieldName: referenceFieldName,
+				recordId,
+				...field_1
+			};
+			$[44] = field_1;
+			$[45] = recordBlockId;
+			$[46] = recordId;
+			$[47] = referenceFieldName;
+			$[48] = t6;
+			$[49] = t7;
+		} else t7 = $[49];
+		t4 = t7;
+	}
+	const nestedFieldSelection = t4;
+	const isStale = outerStale || nestedStale;
+	const fallbackSelection = outerStale ? referenceFieldSelection : nestedFieldSelection;
+	let t5;
+	let t6;
+	if ($[50] !== fallbackSelection || $[51] !== isStale || $[52] !== owner) {
+		t5 = () => {
+			if (!isStale || !fallbackSelection) return;
+			previewStore.send({
+				type: "selectTarget",
+				...owner,
+				selection: fallbackSelection
+			});
+		};
+		t6 = [
+			isStale,
+			fallbackSelection,
+			owner
+		];
+		$[50] = fallbackSelection;
+		$[51] = isStale;
+		$[52] = owner;
+		$[53] = t5;
+		$[54] = t6;
+	} else {
+		t5 = $[53];
+		t6 = $[54];
+	}
+	React.useEffect(t5, t6);
+	const placedRecord = nested ? nestedRecord : outerRecord;
+	const collection = nested ? nestedCollection : outerCollection;
+	const shown = recordSelection && !isStale && placedRecord && collection;
+	let t7;
+	if ($[55] !== collection || $[56] !== nested || $[57] !== nestedFieldType || $[58] !== placedRecord || $[59] !== recordSelection || $[60] !== referenceFieldType || $[61] !== shown) {
+		t7 = shown ? {
+			selection: recordSelection,
+			record: placedRecord,
+			collection,
+			inList: (nested ? nestedFieldType : referenceFieldType) === "ReferenceList",
+			linksRecords: !nested
+		} : null;
+		$[55] = collection;
+		$[56] = nested;
+		$[57] = nestedFieldType;
+		$[58] = placedRecord;
+		$[59] = recordSelection;
+		$[60] = referenceFieldType;
+		$[61] = shown;
+		$[62] = t7;
+	} else t7 = $[62];
+	const recordView = t7;
+	let t8;
+	if ($[63] !== nested || $[64] !== nestedField?.title || $[65] !== nestedFieldSelection || $[66] !== outerPlacement || $[67] !== outerRecord || $[68] !== owner || $[69] !== recordView || $[70] !== referenceField?.title || $[71] !== referenceFieldSelection) {
+		t8 = (fieldHasOwnView) => {
+			if (!recordView || !outerRecord || !outerPlacement) return [];
+			const outerTarget = {
+				type: "record",
+				...outerPlacement
+			};
+			const crumbs = [...isBlockPlacement(outerPlacement) ? [{
+				key: "reference-field",
+				label: referenceField?.title ?? formatFieldName(outerPlacement.fieldName),
+				isCurrent: false,
+				hoverTarget: referenceFieldSelection,
+				onClick: () => previewStore.send({
+					type: "selectTarget",
+					...owner,
+					selection: referenceFieldSelection
+				})
+			}] : [], {
+				key: "record",
+				label: outerRecord.label,
+				isCurrent: !nested && !fieldHasOwnView,
+				hoverTarget: outerTarget,
+				onClick: nested || fieldHasOwnView ? () => previewStore.send({
+					type: "selectRecord",
+					...owner,
+					...outerPlacement
+				}) : void 0
+			}];
+			if (!nested) return crumbs;
+			const nestedTarget = {
+				type: "record",
+				...outerPlacement,
+				nested
+			};
+			return [
+				...crumbs,
+				{
+					key: "nested-reference-field",
+					label: nestedField?.title ?? formatFieldName(nested.fieldName),
+					isCurrent: false,
+					hoverTarget: nestedFieldSelection,
+					onClick: () => previewStore.send({
+						type: "selectTarget",
+						...owner,
+						selection: nestedFieldSelection
+					})
+				},
+				{
+					key: "nested-record",
+					label: recordView.record.label,
+					isCurrent: !fieldHasOwnView,
+					hoverTarget: nestedTarget,
+					onClick: fieldHasOwnView ? () => previewStore.send({
+						type: "selectRecord",
+						...owner,
+						...outerPlacement,
+						nested
+					}) : void 0
+				}
+			];
+		};
+		$[63] = nested;
+		$[64] = nestedField?.title;
+		$[65] = nestedFieldSelection;
+		$[66] = outerPlacement;
+		$[67] = outerRecord;
+		$[68] = owner;
+		$[69] = recordView;
+		$[70] = referenceField?.title;
+		$[71] = referenceFieldSelection;
+		$[72] = t8;
+	} else t8 = $[72];
+	const recordCrumbs = t8;
+	const t9 = isStale ? fallbackSelection : selection;
+	let t10;
+	if ($[73] !== recordCrumbs || $[74] !== recordView || $[75] !== t9) {
+		t10 = {
+			recordView,
+			viewSelection: t9,
+			recordCrumbs
+		};
+		$[73] = recordCrumbs;
+		$[74] = recordView;
+		$[75] = t9;
+		$[76] = t10;
+	} else t10 = $[76];
+	return t10;
+}
+function _temp2(t0) {
+	const { nested: _nested, ...outer } = t0;
+	return outer;
+}
+function _temp(field) {
+	return field?.fieldType === "ReferenceList" ? "ReferenceList" : "Reference";
+}
+
+//#endregion
+export { useRecordView };