@mulmoclaude/collection-plugin 0.7.5 → 0.7.6

package/dist/vue.js

@@ -1717,7 +1717,10 @@ var CollectionKanbanView_default = /* @__PURE__ */ defineComponent({
 		const emit = __emit;
 		const { t } = useCollectionI18n();
 		/** The Uncategorized column uses the empty string as its sentinel value. */
-		const groupSpec = computed(() => props.schema.fields[props.groupField]);
+		const groupSpec = computed(() => {
+			const spec = props.schema.fields[props.groupField];
+			return spec?.type === "enum" ? spec : void 0;
+		});
 		/** Declared enum values become columns in order, with a trailing
 		*  Uncategorized column for empty/unknown values (also a drop target that
 		*  clears the field). The Uncategorized column is omitted when the group
@@ -1764,7 +1767,10 @@ var CollectionKanbanView_default = /* @__PURE__ */ defineComponent({
 			const value = String(raw);
 			return (groupSpec.value?.values ?? []).includes(value) ? value : UNCATEGORIZED;
 		}
-		const visibleItems = computed(() => groupSpec.value ? props.items.filter((item) => fieldVisible(groupSpec.value, item)) : []);
+		const visibleItems = computed(() => {
+			const spec = groupSpec.value;
+			return spec ? props.items.filter((item) => fieldVisible(spec, item)) : [];
+		});
 		const itemsByColumnMap = computed(() => {
 			const map = /* @__PURE__ */ new Map();
 			for (const column of columns.value) map.set(column.value, []);
@@ -2291,7 +2297,8 @@ var CollectionRecordPanel_default = /* @__PURE__ */ defineComponent({
 		/** Required flag for an embed's per-record picker — read off the storage
 		*  field it writes (`idField`), since the embed itself stores nothing. */
 		function embedPickerRequired(field) {
-			const target = field.idField ? props.collection.schema.fields[field.idField] : void 0;
+			const idField = field.type === "embed" ? field.idField : void 0;
+			const target = idField ? props.collection.schema.fields[idField] : void 0;
 			return target ? isFieldRequiredInUi(target) : false;
 		}
 		/** Tailwind fill/text/border classes tinting an enum `<select>` by its current
@@ -3043,8 +3050,11 @@ function formatCell(value, type) {
 }
 /** Resolve the ISO 4217 code for a money field: a per-record
 *  `currencyField` (when present and non-blank) wins over the field's
-*  literal `currency`. */
+*  literal `currency`. Only `money` / `derived` variants carry currency
+*  keys; any other field resolves to undefined (the formatter's USD
+*  fallback), as before. */
 function resolveCurrency(field, record) {
+	if (field.type !== "money" && field.type !== "derived") return void 0;
 	if (field.currencyField && record) {
 		const code = record[field.currencyField];
 		if (typeof code === "string" && code.trim().length > 0) return code;
@@ -3149,8 +3159,60 @@ function buildEmbedOptions(schema, items) {
 	}).filter((opt) => opt.slug.length > 0).sort((left, right) => left.display.localeCompare(right.display));
 }
 //#endregion
-//#region src/vue/useCollectionRendering.ts
-function useCollectionRendering(collection, locale) {
+//#region src/vue/useLinkedCollectionCaches.ts
+/** The de-duplicated ref + embed target slugs a schema links to. `allTargets`
+*  is the union (each target fetched once even when both ref'd and embedded). */
+function linkedTargets(schema) {
+	const refTargets = new Set(uniqueRefTargets(schema));
+	const embedTargets = new Set(uniqueEmbedTargets(schema));
+	return {
+		refTargets,
+		embedTargets,
+		allTargets: [.../* @__PURE__ */ new Set([...refTargets, ...embedTargets])]
+	};
+}
+/** Fan-out fetch that hydrates the linked-collection caches. Best-effort: a
+*  target whose fetch *rejects* (vs. resolving `{ ok: false }`) is coerced to a
+*  skip and must not abort the others. Returns null when a quicker subsequent
+*  load has already moved on (stale-write guard) so the caller drops the write.
+*  Pure + injectable (`fetchDetail`, `currentSlug`) so both paths are testable. */
+async function fetchLinkedCaches(targets, fetchDetail, currentSlug, expectedSlug) {
+	const { refTargets, embedTargets, allTargets } = targets;
+	const results = await Promise.all(allTargets.map(async (target) => {
+		try {
+			return {
+				target,
+				result: await fetchDetail(target)
+			};
+		} catch {
+			return {
+				target,
+				result: { ok: false }
+			};
+		}
+	}));
+	if (currentSlug() !== expectedSlug) return null;
+	const refCache = {};
+	const refRecordCache = {};
+	const embedCache = {};
+	for (const { target, result } of results) {
+		if (!result.ok) continue;
+		if (refTargets.has(target)) {
+			refCache[target] = buildRefDisplayMap(result.data);
+			refRecordCache[target] = buildRefRecordMap(result.data);
+		}
+		if (embedTargets.has(target)) embedCache[target] = {
+			schema: result.data.collection.schema,
+			items: result.data.items
+		};
+	}
+	return {
+		refCache,
+		refRecordCache,
+		embedCache
+	};
+}
+function useLinkedCollectionCaches(collection) {
 	const refCache = ref({});
 	const refRecordCache = ref({});
 	const embedCache = ref({});
@@ -3160,161 +3222,139 @@ function useCollectionRendering(collection, locale) {
 		embedCache.value = {};
 	}
 	async function loadLinkedCollections(schema, expectedSlug) {
-		const refTargets = new Set(uniqueRefTargets(schema));
-		const embedTargets = new Set(uniqueEmbedTargets(schema));
-		const allTargets = [.../* @__PURE__ */ new Set([...refTargets, ...embedTargets])];
-		if (allTargets.length === 0) return;
+		const targets = linkedTargets(schema);
+		if (targets.allTargets.length === 0) return;
 		const binding = collectionUi();
-		const results = await Promise.all(allTargets.map(async (target) => {
-			try {
-				return {
-					target,
-					result: await binding.fetchCollectionDetail(target)
-				};
-			} catch {
-				return {
-					target,
-					result: { ok: false }
-				};
-			}
-		}));
-		if (collection.value?.slug !== expectedSlug) return;
-		const nextRef = {};
-		const nextRefRecords = {};
-		const nextEmbed = {};
-		for (const { target, result } of results) {
-			if (!result.ok) continue;
-			if (refTargets.has(target)) {
-				nextRef[target] = buildRefDisplayMap(result.data);
-				nextRefRecords[target] = buildRefRecordMap(result.data);
-			}
-			if (embedTargets.has(target)) nextEmbed[target] = {
-				schema: result.data.collection.schema,
-				items: result.data.items
-			};
-		}
-		refCache.value = nextRef;
-		refRecordCache.value = nextRefRecords;
-		embedCache.value = nextEmbed;
-	}
-	function refDisplay(targetSlug, itemSlug) {
-		const map = refCache.value[targetSlug];
-		return map && map[itemSlug] || itemSlug;
-	}
-	function refOptions(targetSlug) {
-		const map = refCache.value[targetSlug];
-		return map ? sortedRefOptions(map) : [];
-	}
-	/** Dropdown options for an `embed` field's per-record picker (`idField`):
-	*  every record in the target collection, labelled by its name/title (or
-	*  primary key). Built from `embedCache` so it works for embed targets
-	*  that aren't also `ref` targets (the profile collection, say). */
-	function embedOptions(targetSlug) {
-		const data = embedCache.value[targetSlug];
-		return data ? buildEmbedOptions(data.schema, data.items) : [];
-	}
-	function resolveEmbed(field, record) {
-		if (field.type !== "embed" || !field.to) return {
-			schema: null,
-			item: null
-		};
-		const targetId = embedTargetId(field, record);
-		const data = targetId ? embedCache.value[field.to] : void 0;
-		if (!data) return {
-			schema: null,
-			item: null
-		};
-		const item = data.items.find((entry) => String(entry[data.schema.primaryKey] ?? "") === targetId) ?? null;
-		return {
-			schema: data.schema,
-			item
-		};
-	}
-	function embedValue(field, value, record) {
-		if (field.type === "money") return formatMoney(value, resolveCurrency(field, record), locale.value);
-		return detailText(value);
-	}
-	/** Build the read-only embed view-models for one record. A function of
-	*  the open record (not a bare computed) because a per-record `idField`
-	*  embed resolves a different target per row. */
-	function embedViewsFor(record) {
-		const out = {};
-		if (!collection.value) return out;
-		for (const [key, field] of Object.entries(collection.value.schema.fields)) {
-			if (field.type !== "embed") continue;
-			const { schema, item } = resolveEmbed(field, record);
-			const rows = [];
-			if (schema && item) for (const [subKey, subField] of Object.entries(schema.fields)) {
-				const value = item[subKey];
-				if (value === void 0 || value === null || value === "") continue;
-				rows.push({
-					key: subKey,
-					label: subField.label,
-					type: subField.type,
-					value,
-					display: embedValue(subField, value, item)
-				});
-			}
-			out[key] = {
-				found: Boolean(item),
-				rows,
-				targetSlug: field.to ?? "",
-				recordId: embedTargetId(field, record)
-			};
-		}
-		return out;
-	}
-	function currencySymbol(currency) {
-		return currencySymbolForLocale(currency, locale.value);
-	}
-	function artifactUrl(value) {
-		return collectionUi().fileAssetUrl(value);
-	}
-	function fileRoutePath(value) {
-		return collectionUi().fileRoutePath(value);
-	}
-	function formatSubCell(subField, value, record) {
-		if (subField.type === "money") return formatMoney(value, resolveCurrency(subField, record), locale.value);
-		if (subField.type === "ref" && subField.to && typeof value === "string" && value.length > 0) return refDisplay(subField.to, value);
-		return formatCell(value, subField.type);
-	}
-	const stepFor = stepForFieldType;
-	function evaluateDerivedAgainstItem(field, fieldKey, item) {
-		if (!field.formula || !collection.value) return null;
-		const result = deriveAll(collection.value.schema, item, refRecordCache.value)[fieldKey];
-		return typeof result === "number" && Number.isFinite(result) ? result : null;
-	}
-	function derivedDisplay(field, computedValue, record) {
-		if (computedValue === null || computedValue === void 0) return "—";
-		if (field.display === "money") return formatMoney(computedValue, resolveCurrency(field, record), locale.value);
-		return formatCell(computedValue, field.display ?? "number");
+		const snapshot = await fetchLinkedCaches(targets, (slug) => binding.fetchCollectionDetail(slug), () => collection.value?.slug, expectedSlug);
+		if (!snapshot) return;
+		refCache.value = snapshot.refCache;
+		refRecordCache.value = snapshot.refRecordCache;
+		embedCache.value = snapshot.embedCache;
 	}
 	return {
 		refCache,
 		refRecordCache,
 		embedCache,
 		resetLinkedCaches,
-		loadLinkedCollections,
-		refDisplay,
-		refOptions,
-		embedOptions,
-		embedViewsFor,
-		resolveCurrency,
-		currencySymbol,
-		formatMoney,
-		formatCell,
-		detailText,
-		isExternalUrl,
-		artifactUrl,
-		fileRoutePath,
-		tableRows,
-		hasTableRows,
-		formatSubCell,
-		inputTypeFor,
-		stepFor,
-		deriveAll,
-		evaluateDerivedAgainstItem,
-		derivedDisplay
+		loadLinkedCollections
+	};
+}
+//#endregion
+//#region src/vue/useCollectionRendering.renderers.ts
+function lookupRefDisplay(refCache, targetSlug, itemSlug) {
+	const map = refCache[targetSlug];
+	return map && map[itemSlug] || itemSlug;
+}
+function refOptionsFor(refCache, targetSlug) {
+	const map = refCache[targetSlug];
+	return map ? sortedRefOptions(map) : [];
+}
+/** Dropdown options for an `embed` field's per-record picker (`idField`):
+*  every record in the target collection, labelled by its name/title (or
+*  primary key). Built from `embedCache` so it works for embed targets
+*  that aren't also `ref` targets (the profile collection, say). */
+function embedOptionsFor(embedCache, targetSlug) {
+	const data = embedCache[targetSlug];
+	return data ? buildEmbedOptions(data.schema, data.items) : [];
+}
+function resolveEmbed(field, record, embedCache) {
+	if (field.type !== "embed" || !field.to) return {
+		schema: null,
+		item: null
+	};
+	const targetId = embedTargetId(field, record);
+	const data = targetId ? embedCache[field.to] : void 0;
+	if (!data) return {
+		schema: null,
+		item: null
+	};
+	const item = data.items.find((entry) => String(entry[data.schema.primaryKey] ?? "") === targetId) ?? null;
+	return {
+		schema: data.schema,
+		item
+	};
+}
+function formatEmbedValue(field, value, record, locale) {
+	if (field.type === "money") return formatMoney(value, resolveCurrency(field, record), locale);
+	return detailText(value);
+}
+/** Build the read-only embed view-models for one record. A function of the
+*  open record (not a bare computed) because a per-record `idField` embed
+*  resolves a different target per row. `schema` is the OPEN collection's
+*  schema (null when no collection is loaded → no views). */
+function buildEmbedViews(schema, embedCache, record, locale) {
+	const out = {};
+	if (!schema) return out;
+	for (const [key, field] of Object.entries(schema.fields)) {
+		if (field.type !== "embed") continue;
+		const { schema: targetSchema, item } = resolveEmbed(field, record, embedCache);
+		const rows = [];
+		if (targetSchema && item) for (const [subKey, subField] of Object.entries(targetSchema.fields)) {
+			const value = item[subKey];
+			if (value === void 0 || value === null || value === "") continue;
+			rows.push({
+				key: subKey,
+				label: subField.label,
+				type: subField.type,
+				value,
+				display: formatEmbedValue(subField, value, item, locale)
+			});
+		}
+		out[key] = {
+			found: Boolean(item),
+			rows,
+			targetSlug: field.to ?? "",
+			recordId: embedTargetId(field, record)
+		};
+	}
+	return out;
+}
+function renderSubCell(subField, value, record, refCache, locale) {
+	if (subField.type === "money") return formatMoney(value, resolveCurrency(subField, record), locale);
+	if (subField.type === "ref" && subField.to && typeof value === "string" && value.length > 0) return lookupRefDisplay(refCache, subField.to, value);
+	return formatCell(value, subField.type);
+}
+function evaluateDerived(field, fieldKey, item, schema, refRecords) {
+	if (field.type !== "derived" || !schema) return null;
+	const result = deriveAll(schema, item, refRecords)[fieldKey];
+	return typeof result === "number" && Number.isFinite(result) ? result : null;
+}
+function renderDerived(field, computedValue, record, locale) {
+	if (computedValue === null || computedValue === void 0) return "—";
+	const display = field.type === "derived" ? field.display : void 0;
+	if (display === "money") return formatMoney(computedValue, resolveCurrency(field, record), locale);
+	return formatCell(computedValue, display ?? "number");
+}
+//#endregion
+//#region src/vue/useCollectionRendering.ts
+var STATELESS_RENDERERS = {
+	resolveCurrency,
+	formatMoney,
+	formatCell,
+	detailText,
+	isExternalUrl,
+	tableRows,
+	hasTableRows,
+	inputTypeFor,
+	stepFor: stepForFieldType,
+	deriveAll
+};
+function useCollectionRendering(collection, locale) {
+	const caches = useLinkedCollectionCaches(collection);
+	const { refCache, refRecordCache, embedCache } = caches;
+	return {
+		...caches,
+		...STATELESS_RENDERERS,
+		refDisplay: (targetSlug, itemSlug) => lookupRefDisplay(refCache.value, targetSlug, itemSlug),
+		refOptions: (targetSlug) => refOptionsFor(refCache.value, targetSlug),
+		embedOptions: (targetSlug) => embedOptionsFor(embedCache.value, targetSlug),
+		embedViewsFor: (record) => buildEmbedViews(collection.value?.schema ?? null, embedCache.value, record, locale.value),
+		currencySymbol: (currency) => currencySymbolForLocale(currency, locale.value),
+		artifactUrl: (value) => collectionUi().fileAssetUrl(value),
+		fileRoutePath: (value) => collectionUi().fileRoutePath(value),
+		formatSubCell: (subField, value, record) => renderSubCell(subField, value, record, refCache.value, locale.value),
+		evaluateDerivedAgainstItem: (field, fieldKey, item) => evaluateDerived(field, fieldKey, item, collection.value?.schema ?? null, refRecordCache.value),
+		derivedDisplay: (field, computedValue, record) => renderDerived(field, computedValue, record, locale.value)
 	};
 }
 //#endregion
@@ -3805,12 +3845,12 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 			return scalarSortValue(field, item[key]);
 		}
 		/** Derived rows sort by their display type: money/number → numeric,
-		*  date/datetime → epoch, anything else → the enriched value as a string. */
+		*  date → epoch, anything else → the enriched value as a string. */
 		function derivedSortValue(field, key, item) {
-			const { display } = field;
+			const display = field.type === "derived" ? field.display : void 0;
 			if (display === void 0 || display === "number" || display === "money") return numericSortValue(evaluateDerivedAgainstItem(field, key, item));
 			const enriched = collection.value ? render.deriveAll(collection.value.schema, item, render.refRecordCache.value) : item;
-			if (display === "date" || display === "datetime") return dateSortValue(enriched[key]);
+			if (display === "date") return dateSortValue(enriched[key]);
 			return stringSortValue(enriched[key]);
 		}
 		const sortedItems = computed(() => {
@@ -3988,10 +4028,12 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 		function buildChatSeed(slug, message, itemId) {
 			const current = collection.value;
 			if (current?.source !== "feed") return itemId ? `/${slug} id=${itemId} ${message}` : `/${slug} ${message}`;
+			const dataPath = current.schema.dataPath ?? `data/feeds/${slug}`;
+			const scoped = itemId ? `(for record \`${itemId}\`) ${message}` : message;
 			return t("collectionsView.feedChatSeed", {
 				slug,
-				dataPath: current.schema.dataPath ?? `data/feeds/${slug}`,
-				message: itemId ? `(for record \`${itemId}\`) ${message}` : message
+				dataPath,
+				message: scoped
 			});
 		}
 		/** Start a new general-role chat seeded from the current view. */
@@ -4066,7 +4108,10 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 			enumOriginallyEmpty.value = snapshotEmptyEnums(result.data.collection.schema, result.data.items);
 			await render.loadLinkedCollections(result.data.collection.schema, slug);
 			if (activeSlug.value !== slug) return;
-			if (viewing.value) viewing.value = findItemById(String(viewing.value[result.data.collection.schema.primaryKey] ?? "")) ?? null;
+			if (viewing.value) {
+				const openId = String(viewing.value[result.data.collection.schema.primaryKey] ?? "");
+				viewing.value = findItemById(openId) ?? null;
+			}
 		}
 		function maybeAutoRefreshFeed(slug) {
 			if (embedded.value) return;
@@ -4244,7 +4289,8 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 		}
 		/** Select a custom view by id (builds the `custom:<id>` mode key). */
 		function setCustomView(viewId) {
-			view.value = `custom:${viewId}`;
+			const mode = `custom:${viewId}`;
+			view.value = mode;
 		}
 		/** A short, slug-safe id not already used by a loaded record. Collisions
 		*  are astronomically unlikely (32 bits), but we still re-roll a few
@@ -4402,7 +4448,8 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 				viewing.value = null;
 				return;
 			}
-			viewing.value = findItemById(selected) ?? null;
+			const match = findItemById(selected) ?? null;
+			viewing.value = match;
 		}
 		/** Title for the open-mode header: the record's primary-key value
 		*  (e.g. `INV-2026-0001`), falling back to the collection title.
@@ -4496,19 +4543,17 @@ var CollectionView_default = /* @__PURE__ */ defineComponent({
 		/** Whether a `toggle` field reads as checked: its projected enum field
 		*  currently equals `onValue`. The toggle stores nothing itself. */
 		function toggleChecked(item, field) {
-			return field.field !== void 0 && String(item[field.field] ?? "") === field.onValue;
+			return field.type === "toggle" && String(item[field.field] ?? "") === field.onValue;
 		}
 		/** Flip a `toggle`: write the projected enum field to `offValue` when
 		*  currently checked, else `onValue`. Reuses the inline-edit PUT path
 		*  (optimistic + rollback) — the toggle has no value of its own. */
 		function commitToggle(item, field) {
+			if (field.type !== "toggle" || !collection.value) return;
 			const targetKey = field.field;
-			if (!targetKey || !collection.value) return;
 			const enumField = collection.value.schema.fields[targetKey];
 			if (!enumField) return;
-			const next = toggleChecked(item, field) ? field.offValue : field.onValue;
-			if (next === void 0) return;
-			commitInlineEdit(item, targetKey, enumField, next);
+			commitInlineEdit(item, targetKey, enumField, toggleChecked(item, field) ? field.offValue : field.onValue);
 		}
 		async function confirmDelete(item) {
 			if (!collection.value) return;