@heyramzi/ui 2.0.1 → 2.2.0

package/src/tasks/record/record.test.ts

@@ -1,350 +0,0 @@
-import { describe, expect, it } from "vite-plus/test";
-import {
-	activeProjects,
-	dayRelation,
-	eventsForFilter,
-	filterCounts,
-	foldGroups,
-	groupEventsByDay,
-	groupSteps,
-	latestWhereWeAre,
-	mergeClientEvents,
-	nextAcrossProjects,
-	nudgeStep,
-	reorderIds,
-	rollupProjects,
-	stepMarkers,
-	stepProgress,
-} from "./logic.js";
-import { formatRange } from "./format.js";
-import { fieldRow, groupFields, isFieldVisible, parseSaved, pickableOptions } from "./fields.js";
-import type { FieldDef, RecordEvent, RecordSummary, StageDef, StepDef } from "./types.js";
-
-const ev = (id: string, kind: string, occurredAt: string): RecordEvent => ({
-	id,
-	kind,
-	occurredAt,
-	title: id,
-});
-
-const stages: StageDef[] = [
-	{ key: "lead", label: "Lead", tone: "neutral", category: "open" },
-	{ key: "sent", label: "Proposal sent", tone: "info", category: "proposal" },
-	{ key: "build", label: "In build", tone: "accent", category: "ongoing" },
-	{ key: "paid", label: "Paid", tone: "success", category: "completed" },
-	{ key: "lost", label: "Lost", tone: "destructive", category: "lost" },
-];
-
-const project = (over: Partial<RecordSummary> & { id: string }): RecordSummary => ({
-	name: over.id,
-	stageKey: "lead",
-	...over,
-});
-
-describe("groupEventsByDay", () => {
-	it("groups by calendar day, newest day and newest event first", () => {
-		const groups = groupEventsByDay(
-			[
-				ev("a", "note", "2026-10-20T09:00:00Z"),
-				ev("b", "call", "2026-10-21T08:00:00Z"),
-				ev("c", "note", "2026-10-21T16:00:00Z"),
-			],
-			"UTC",
-		);
-		expect(groups.map((g) => g.day)).toEqual(["2026-10-21", "2026-10-20"]);
-		expect(groups[0]?.events.map((e) => e.id)).toEqual(["c", "b"]);
-	});
-
-	it("reads the day in the given zone, so late evening UTC is tomorrow in Tokyo", () => {
-		const events = [ev("a", "note", "2026-10-21T20:00:00Z")];
-		expect(groupEventsByDay(events, "UTC")[0]?.day).toBe("2026-10-21");
-		expect(groupEventsByDay(events, "Asia/Tokyo")[0]?.day).toBe("2026-10-22");
-	});
-
-	it("returns nothing for no events and does not mutate its input", () => {
-		expect(groupEventsByDay([], "UTC")).toEqual([]);
-		const input = [ev("a", "note", "2026-10-20T09:00:00Z"), ev("b", "note", "2026-10-21T09:00:00Z")];
-		groupEventsByDay(input, "UTC");
-		expect(input.map((e) => e.id)).toEqual(["a", "b"]);
-	});
-});
-
-describe("dayRelation", () => {
-	it("says today, yesterday, or date", () => {
-		expect(dayRelation("2026-10-21", "2026-10-21")).toBe("today");
-		expect(dayRelation("2026-10-20", "2026-10-21")).toBe("yesterday");
-		expect(dayRelation("2026-10-19", "2026-10-21")).toBe("date");
-		expect(dayRelation("2026-09-30", "2026-10-01")).toBe("yesterday");
-	});
-});
-
-describe("filters", () => {
-	const filters = [
-		{ key: "calls", label: "Calls", kinds: ["call", "meeting"] },
-		{ key: "notes", label: "Notes", kinds: ["note"] },
-	];
-	const events = [ev("a", "call", "2026-10-21T08:00:00Z"), ev("b", "note", "2026-10-21T09:00:00Z"), ev("c", "x:custom", "2026-10-21T10:00:00Z")];
-
-	it("keeps only the kinds of the chosen chip", () => {
-		expect(eventsForFilter(events, "calls", filters).map((e) => e.id)).toEqual(["a"]);
-	});
-	it("shows everything for all or an unknown key", () => {
-		expect(eventsForFilter(events, "all", filters)).toHaveLength(3);
-		expect(eventsForFilter(events, "nope", filters)).toHaveLength(3);
-	});
-	it("counts per chip", () => {
-		expect(filterCounts(events, filters)).toEqual({ calls: 1, notes: 1 });
-	});
-});
-
-describe("foldGroups", () => {
-	const groups = groupEventsByDay(
-		[
-			ev("a", "note", "2026-10-21T09:00:00Z"),
-			ev("b", "note", "2026-10-21T08:00:00Z"),
-			ev("c", "note", "2026-10-20T08:00:00Z"),
-			ev("d", "note", "2026-10-19T08:00:00Z"),
-		],
-		"UTC",
-	);
-	it("cuts inside a day when the limit falls there and counts the rest", () => {
-		const folded = foldGroups(groups, 1);
-		expect(folded.groups.map((g) => g.events.length)).toEqual([1]);
-		expect(folded.hidden).toBe(3);
-	});
-	it("hides nothing when the limit covers it", () => {
-		expect(foldGroups(groups, 10)).toEqual({ groups, hidden: 0 });
-	});
-	it("spans days up to the limit", () => {
-		const folded = foldGroups(groups, 3);
-		expect(folded.groups.map((g) => g.day)).toEqual(["2026-10-21", "2026-10-20"]);
-		expect(folded.hidden).toBe(1);
-	});
-});
-
-describe("mergeClientEvents", () => {
-	it("tags project events with their project and keeps client events untagged", () => {
-		const merged = mergeClientEvents(
-			[ev("form", "form", "2026-10-01T10:00:00Z")],
-			[
-				{ id: "p1", name: "Website", href: "/p/1", events: [ev("a", "call", "2026-10-03T10:00:00Z")] },
-				{ id: "p2", name: "Retainer", events: [ev("b", "note", "2026-10-02T10:00:00Z")] },
-			],
-		);
-		expect(merged.map((e) => e.id)).toEqual(["a", "b", "form"]);
-		expect(merged[0]).toMatchObject({ projectId: "p1", projectName: "Website", projectHref: "/p/1" });
-		expect(merged[1]).toMatchObject({ projectId: "p2", projectHref: null });
-		expect(merged[2]).toMatchObject({ projectId: null, projectName: null });
-	});
-
-	it("draws an id seen twice once", () => {
-		const shared = ev("same", "call", "2026-10-03T10:00:00Z");
-		const merged = mergeClientEvents([shared], [{ id: "p1", name: "Website", events: [shared] }]);
-		expect(merged).toHaveLength(1);
-		expect(merged[0]?.projectId).toBe("p1");
-	});
-
-	it("handles a client with no projects", () => {
-		expect(mergeClientEvents([ev("a", "note", "2026-10-03T10:00:00Z")], [])).toHaveLength(1);
-		expect(mergeClientEvents([], [])).toEqual([]);
-	});
-});
-
-describe("client rollup", () => {
-	const projects = [
-		project({ id: "lost", stageKey: "lost", value: 9000, lastCallAt: "2026-09-01T10:00:00Z" }),
-		project({ id: "paid", stageKey: "paid", value: 12000, paid: 12000, lastCallAt: "2026-10-10T10:00:00Z" }),
-		project({ id: "live", stageKey: "sent", value: 8000, next: { label: "Kickoff", date: "2026-10-26" }, whereWeAre: { text: "Waiting on legal", at: "2026-10-18T10:00:00Z" } }),
-		project({ id: "late", stageKey: "build", value: 5000, paid: 1000, next: { label: "Review", date: "2026-10-23" }, whereWeAre: { text: "Building", at: "2026-10-20T10:00:00Z" } }),
-		project({ id: "closed", stageKey: "build", closed: true, next: { label: "Old", date: "2026-10-01" } }),
-	];
-
-	it("counts a lost project in no total and sums each currency apart", () => {
-		const rollup = rollupProjects(
-			[...projects, project({ id: "usd", stageKey: "lead", value: 700, currency: "USD" })],
-			stages,
-		);
-		expect(rollup.totals.EUR).toEqual({ pipeline: 8000, won: 17000, paid: 13000 });
-		expect(rollup.totals.USD).toEqual({ pipeline: 700, won: 0, paid: 0 });
-		expect(rollup.count).toBe(6);
-		expect(rollup.lastCallAt).toBe("2026-10-10T10:00:00Z");
-	});
-
-	it("keeps lost, completed and closed out of the active list", () => {
-		expect(activeProjects(projects, stages).map((p) => p.id)).toEqual(["live", "late"]);
-	});
-
-	it("picks the earliest dated next across active projects, skipping closed ones", () => {
-		expect(nextAcrossProjects(projects, stages)).toMatchObject({ label: "Review", projectName: "late" });
-	});
-
-	it("puts a dated next ahead of an undated one", () => {
-		const next = nextAcrossProjects(
-			[
-				project({ id: "a", next: { label: "Someday" } }),
-				project({ id: "b", next: { label: "Dated", date: "2027-01-01" } }),
-			],
-			stages,
-		);
-		expect(next?.label).toBe("Dated");
-	});
-
-	it("returns null when nothing is next", () => {
-		expect(nextAcrossProjects([project({ id: "a" })], stages)).toBeNull();
-		expect(nextAcrossProjects([], stages)).toBeNull();
-	});
-
-	it("takes the newest where-we-are, even from a closed project", () => {
-		expect(latestWhereWeAre(projects)).toMatchObject({ text: "Building", projectName: "late" });
-		expect(latestWhereWeAre([project({ id: "a" })])).toBeNull();
-	});
-});
-
-describe("steps", () => {
-	const step = (id: string, over: Partial<StepDef> = {}): StepDef => ({ id, label: id, done: false, ...over });
-
-	it("marks done, the first open one current, earlier-skipped and overdue ones late", () => {
-		const steps = [
-			step("a", { done: true }),
-			step("b"),
-			step("c", { end: "2026-10-01" }),
-			step("d", { start: "2026-12-01" }),
-			step("e"),
-		];
-		const m = stepMarkers(steps, "2026-10-21");
-		expect([...m.entries()]).toEqual([
-			["a", "complete"],
-			["b", "current"],
-			["c", "late"],
-			["d", "pending"],
-			["e", "pending"],
-		]);
-	});
-
-	it("calls an open step before the current one late, when an earlier one is open but out of order", () => {
-		// c done, b open: b is current (first open), nothing before it is open.
-		const m = stepMarkers([step("a", { hidden: true }), step("b"), step("c", { done: true })], "2026-10-21");
-		expect(m.has("a")).toBe(false);
-		expect(m.get("b")).toBe("current");
-		expect(m.get("c")).toBe("complete");
-	});
-
-	it("has no current step when all are done", () => {
-		const m = stepMarkers([step("a", { done: true })], "2026-10-21");
-		expect([...m.values()]).toEqual(["complete"]);
-	});
-
-	it("counts progress over visible steps only", () => {
-		expect(stepProgress([step("a", { done: true }), step("b"), step("c", { hidden: true, done: true })])).toEqual({ done: 1, total: 2 });
-	});
-
-	it("buckets by group in declared order and puts ungrouped steps last, headerless", () => {
-		const buckets = groupSteps(
-			[step("a", { group: "delivery" }), step("b", { group: "sales" }), step("c"), step("d", { group: "delivery" }), step("e", { group: "gone" })],
-			[
-				{ key: "sales", label: "Sales" },
-				{ key: "delivery", label: "Delivery" },
-				{ key: "empty", label: "Empty" },
-			],
-		);
-		expect(buckets.map((b) => [b.key, b.steps.map((s) => s.id)])).toEqual([
-			["sales", ["b"]],
-			["delivery", ["a", "d"]],
-			["", ["c", "e"]],
-		]);
-		expect(buckets[2]?.label).toBeNull();
-	});
-
-	it("reorders before or after a target and leaves the list on a no-op", () => {
-		const ids = ["a", "b", "c", "d"];
-		expect(reorderIds(ids, "d", "b", true)).toEqual(["a", "d", "b", "c"]);
-		expect(reorderIds(ids, "a", "c", false)).toEqual(["b", "c", "a", "d"]);
-		expect(reorderIds(ids, "a", "a", true)).toEqual(ids);
-		expect(reorderIds(ids, "zz", "a", true)).toEqual(ids);
-		expect(reorderIds(ids, "a", "zz", true)).toEqual(ids);
-	});
-
-	it("nudges within a group and stops at its edge", () => {
-		const steps = [step("a", { group: "s" }), step("x", { group: "t" }), step("b", { group: "s" })];
-		expect(nudgeStep(steps, "a", 1)).toEqual(["b", "x", "a"]);
-		expect(nudgeStep(steps, "a", -1)).toEqual(["a", "x", "b"]);
-		expect(nudgeStep(steps, "b", 1)).toEqual(["a", "x", "b"]);
-		expect(nudgeStep(steps, "nope", 1)).toEqual(["a", "x", "b"]);
-	});
-});
-
-describe("formatRange", () => {
-	it("draws a day, a same-month range and a cross-month range", () => {
-		expect(formatRange("2026-10-24", null)).toBe("Sat 24 Oct");
-		expect(formatRange("2026-10-24", "2026-10-24")).toBe("Sat 24 Oct");
-		expect(formatRange("2026-10-24", "2026-10-25")).toBe("Sat 24 to Sun 25 Oct");
-		expect(formatRange("2026-10-31", "2026-11-01")).toBe("Sat 31 Oct to Sun 1 Nov");
-	});
-});
-
-describe("fields", () => {
-	const reason: FieldDef = {
-		key: "reason",
-		label: "Reason",
-		type: "choice",
-		section: "loss",
-		options: [
-			{ key: "price", label: "Price" },
-			{ key: "old", label: "Old reason", archived: true },
-			{ key: "ghost", label: "Unresponsive" },
-		],
-	};
-	const words: FieldDef = { key: "words", label: "In their words", type: "text", section: "loss", showWhen: { key: "reason", equals: ["price", "ghost"] } };
-	const size: FieldDef = { key: "size", label: "Size", type: "choice", options: [{ key: "s", label: "Small" }] };
-	const sections = [{ key: "loss", label: "Loss" }, { key: "empty", label: "Empty" }];
-
-	it("hides a field whose showWhen isn't met and shows it once it is", () => {
-		expect(isFieldVisible(words, {})).toBe(false);
-		expect(isFieldVisible(words, { reason: "old" })).toBe(false);
-		expect(isFieldVisible(words, { reason: "price" })).toBe(true);
-		expect(isFieldVisible({ ...words, showWhen: { key: "reason" } }, { reason: "old" })).toBe(true);
-		expect(isFieldVisible({ ...words, showWhen: { key: "reason" } }, { reason: "" })).toBe(false);
-	});
-
-	it("drops a section with no visible field and puts unsectioned fields last", () => {
-		const groups = groupFields([reason, words, size], sections, { reason: "price" });
-		expect(groups.map((g) => [g.key, g.fields.map((f) => f.key)])).toEqual([
-			["loss", ["reason", "words"]],
-			["", ["size"]],
-		]);
-		expect(groupFields([words], sections, {})).toEqual([]);
-	});
-
-	it("keeps an archived option readable on a record that holds it, but never offers it", () => {
-		expect(pickableOptions(reason, "price").map((o) => o.key)).toEqual(["price", "ghost"]);
-		expect(pickableOptions(reason, "old").map((o) => o.key)).toEqual(["price", "old", "ghost"]);
-		expect(fieldRow(reason, "old").value).toBe("Old reason");
-	});
-
-	it("reads each type back as the type it declares", () => {
-		expect(parseSaved({ key: "v", label: "V", type: "money" }, "12,5")).toBe(12.5);
-		expect(parseSaved({ key: "v", label: "V", type: "money" }, "abc")).toBeNull();
-		expect(parseSaved(words, "  hi ")).toBe("hi");
-		expect(parseSaved(words, "   ")).toBeNull();
-		expect(parseSaved({ key: "m", label: "M", type: "multi" }, ["a", "b"])).toEqual(["a", "b"]);
-	});
-
-	it("builds a row that saves under its key with the parsed value", async () => {
-		const saved: [string, unknown][] = [];
-		const row = fieldRow({ key: "budget", label: "Budget", type: "money" }, 12000, {
-			currency: "EUR",
-			onSave: (k, v) => void saved.push([k, v]),
-		});
-		expect(row.value).toBe("€12,000");
-		expect(row.editValue).toBe("12000");
-		await row.onSave?.("9000");
-		expect(saved).toEqual([["budget", 9000]]);
-	});
-
-	it("leaves a row read-only when no onSave is given, and empty values undrawn", () => {
-		const row = fieldRow(size, null);
-		expect(row.onSave).toBeUndefined();
-		expect(row.value).toBeUndefined();
-		expect(row.editValue).toBe("");
-	});
-});

package/src/tasks/record/types.ts

@@ -1,280 +0,0 @@
-// The view types of a client or project record. Plain data in, nothing loaded:
-// the host maps its own rows onto these and passes them down.
-import type { PhosphorIcon } from "../../lib/icon-types.js";
-import type { Tone } from "../../lib/tone.js";
-
-/** Where a stage sits in the pipeline. Structure, not an agency's own names. */
-export type StageCategory = "open" | "proposal" | "ongoing" | "completed" | "lost";
-
-/** One stage an agency declares. The record draws its label and tone. */
-export type StageDef = {
-	key: string;
-	label: string;
-	tone: Tone;
-	category: StageCategory;
-};
-
-/**
- * One thing that happened. Append-only. It belongs to a project, or to a client
- * when no project exists yet. `occurredAt` is an ISO timestamp.
- */
-export type RecordEvent = {
-	id: string;
-	/** A registry key: `call`, `note`, `stage`, or a module's own `slug:name`. */
-	kind: string;
-	occurredAt: string;
-	title: string;
-	body?: string | null;
-	/** Money, in the currency's major unit. */
-	amount?: number | null;
-	currency?: string | null;
-	/** Who or what wrote it. The host resolves the name. */
-	actor?: string | null;
-	/** A note that changed after posting. */
-	edited?: boolean;
-	/** The kind's own declared fields, already formatted by the host for display. */
-	details?: { label: string; value: string }[];
-	/** The project it belongs to. Set in client mode, so each entry can say which. */
-	projectId?: string | null;
-	projectName?: string | null;
-	projectHref?: string | null;
-	/** Where the event's source lives: the call, the invoice, the deck. */
-	href?: string | null;
-};
-
-/** The numbers and lines one project rolls up to. The host computes them. */
-export type RecordSummary = {
-	id: string;
-	name: string;
-	href?: string;
-	stageKey: string;
-	/** Short qualifier drawn after the stage, such as a loss reason. */
-	stageDetail?: string | null;
-	/** Money, in the currency's major unit. */
-	value?: number | null;
-	currency?: string | null;
-	/** Money received, from payment events. */
-	paid?: number | null;
-	startDate?: string | null;
-	endDate?: string | null;
-	whereWeAre?: {
-		text: string;
-		/** ISO timestamp of the status event. */
-		at?: string | null;
-		actor?: string | null;
-		health?: { label: string; tone: Tone } | null;
-	} | null;
-	next?: RecordNext | null;
-	lastCallAt?: string | null;
-	lastTouchAt?: string | null;
-	progress?: { done: number; total: number } | null;
-	/** A cancelled or archived project: dropped from "active" and "next". */
-	closed?: boolean;
-};
-
-/** The next milestone, or the next dated task when there are no milestones. */
-export type RecordNext = {
-	label: string;
-	/** ISO date. */
-	date?: string | null;
-	/** ISO date, for a range. */
-	endDate?: string | null;
-	owner?: string | null;
-	href?: string | null;
-	projectId?: string | null;
-	projectName?: string | null;
-};
-
-export type FieldType =
-	| "text"
-	| "longtext"
-	| "choice"
-	| "multi"
-	| "money"
-	| "date"
-	| "url"
-	| "email"
-	| "timezone";
-
-export type FieldOption = {
-	key: string;
-	label: string;
-	tone?: Tone;
-	/** Still reads on old records, cannot be picked. */
-	archived?: boolean;
-};
-
-/** What a field holds. A choice is its option key, a multi is its keys. */
-export type FieldValue = string | number | string[] | null;
-
-/** One attribute a module declares. The record draws it and calls `onSave`. */
-export type FieldDef = {
-	key: string;
-	label: string;
-	type: FieldType;
-	options?: FieldOption[];
-	section?: string;
-	required?: boolean;
-	/** Shown only while another field has this value. Without `equals`, any value. */
-	showWhen?: { key: string; equals?: string | string[] };
-	/** For money. Defaults to the record's currency. */
-	currency?: string;
-	placeholder?: string;
-};
-
-export type FieldSectionDef = { key: string; label: string };
-
-/** One step of the rail. A step is a milestone task. */
-export type StepDef = {
-	id: string;
-	label: string;
-	done: boolean;
-	/** Which group header it sits under, such as Sales or Delivery. */
-	group?: string;
-	/** ISO dates. Both set draws a range, one draws a day. */
-	start?: string | null;
-	end?: string | null;
-	/** Hidden from the rail, still in the edit menu. */
-	hidden?: boolean;
-	/** The label was renamed: the menu offers a reset. */
-	renamed?: boolean;
-};
-
-export type StepGroupDef = { key: string; label: string };
-
-export type StepMarker = "complete" | "current" | "late" | "pending";
-
-/** One row of an `InfoList`. The value is already formatted for display. */
-export type InfoRow = {
-	/** Names the row for a host to find it. Falls back to the label. */
-	id?: string;
-	label: string;
-	icon?: PhosphorIcon;
-	value?: string | null;
-	/** A coloured chip in place of plain text. */
-	tone?: Tone;
-	/** Chips for a multi value. Wins over `value`. */
-	chips?: { label: string; tone?: Tone }[];
-	/** What the editor starts from, when it differs from what is drawn. */
-	editValue?: string | string[] | null;
-	href?: string;
-	muted?: boolean;
-	/** `select` becomes a searchable list past seven options. */
-	input?: "text" | "longtext" | "select" | "multi" | "date" | "number" | "url" | "email";
-	options?: { value: string; label: string; tone?: Tone }[];
-	placeholder?: string;
-	required?: boolean;
-	/** Without it the row is read-only. A multi row passes the picked keys. */
-	onSave?: (value: string | string[]) => void | Promise<void>;
-	divider?: boolean;
-};
-
-/** A kind of event: how its filter chip and its default row read. */
-export type RecordKindDef = {
-	key: string;
-	label: string;
-	icon?: PhosphorIcon;
-	tone?: Tone;
-};
-
-/** A filter chip: a label over the kinds it shows. */
-export type RecordFilterDef = { key: string; label: string; kinds: string[] };
-
-export type RecordLabels = {
-	whereWeAre: string;
-	more: string;
-	less: string;
-	next: string;
-	late: string;
-	steps: string;
-	stepsCount: (done: number, total: number) => string;
-	editSteps: string;
-	rename: string;
-	resetName: string;
-	hide: string;
-	show: string;
-	moveUp: string;
-	moveDown: string;
-	shownCount: (shown: number, total: number) => string;
-	openSteps: string;
-	activity: string;
-	all: string;
-	noEvents: string;
-	older: (count: number) => string;
-	today: string;
-	yesterday: string;
-	by: (name: string) => string;
-	projects: string;
-	projectCount: (count: number) => string;
-	noProjects: string;
-	details: string;
-	edit: (field: string) => string;
-	add: (field: string) => string;
-	save: string;
-	cancel: string;
-	search: string;
-	noMatch: string;
-	pipeline: string;
-	won: string;
-	paid: string;
-	lastCall: string;
-	lastTouch: string;
-	noCall: string;
-	open: string;
-	edited: string;
-	noSteps: string;
-	saveFailed: string;
-	required: string;
-};
-
-export const DEFAULT_RECORD_LABELS: RecordLabels = {
-	whereWeAre: "Where we are",
-	more: "More",
-	less: "Less",
-	next: "Next",
-	late: "Late",
-	steps: "Steps",
-	stepsCount: (done, total) => `${done}/${total}`,
-	editSteps: "Choose visible steps",
-	rename: "Rename",
-	resetName: "Reset name",
-	hide: "Hide",
-	show: "Show",
-	moveUp: "Move up",
-	moveDown: "Move down",
-	shownCount: (shown, total) => `${shown} of ${total} shown`,
-	openSteps: "Open steps",
-	activity: "Activity",
-	all: "All",
-	noEvents: "Nothing logged yet",
-	older: (count) => `Show ${count} older`,
-	today: "Today",
-	yesterday: "Yesterday",
-	by: (name) => `by ${name}`,
-	projects: "Projects",
-	projectCount: (count) => (count === 1 ? "1 project" : `${count} projects`),
-	noProjects: "No projects",
-	details: "Details",
-	edit: (field) => `Edit ${field}`,
-	add: (field) => `Add ${field.toLowerCase()}`,
-	save: "Save",
-	cancel: "Cancel",
-	search: "Search",
-	noMatch: "No match",
-	pipeline: "Pipeline",
-	won: "Won",
-	paid: "Paid",
-	lastCall: "Last call",
-	lastTouch: "Last touch",
-	noCall: "None yet",
-	open: "Open",
-	edited: "edited",
-	noSteps: "No steps yet",
-	saveFailed: "Couldn't save",
-	required: "Required",
-};
-
-/** Merge a partial label set over the defaults. */
-export function resolveLabels(labels?: Partial<RecordLabels>): RecordLabels {
-	return labels ? { ...DEFAULT_RECORD_LABELS, ...labels } : DEFAULT_RECORD_LABELS;
-}