runloopable / web /src /sheet /cellLimits.ts
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
89af3b2 verified
Raw History Blame Contribute Delete
3.9 kB
import { gridLimitCopy, limitSummary } from "../customer-grid/counts";
import { LP_YELLOW_DEEP } from "../customer-grid/theme";
import type { GridLimit } from "../customer-grid/types";
import { tokenColour } from "./cellBorders";
import type { Cell } from "./types";
/** Keep refreshed limits on the cell without widening the shared Cell contract. */
export interface CellWithLimits extends Cell { limits?: unknown[] }
export interface CellLimitField { key: string; label: string }
/** An accepted answer replaces its previous limits, including an empty or absent list. */
export function withCellLimits(cell: Cell, limits: unknown): CellWithLimits {
const next: CellWithLimits = { ...cell };
if (Array.isArray(limits)) next.limits = limits;
else delete next.limits;
return next;
}
/** Every non-empty bound-cell list has a mark, even when it only describes the default scope. */
export function cellHasLimits(cell: CellWithLimits | null | undefined): boolean {
const limits = cell?.limits;
return cell?.kind === "bound" && Array.isArray(limits) && limits.length > 0;
}
/** Use the shared wording and keep scope causes visible without counting them as limits. */
export function cellLimitSummary(
cell: CellWithLimits | null | undefined, fields: readonly CellLimitField[] = [],
): { short: string; full: string } | null {
if (!cellHasLimits(cell)) return null;
const limits: GridLimit[] = (cell as CellWithLimits).limits!.map(raw => {
const entry = raw && typeof raw === "object" ? raw as Partial<GridLimit> : {};
return {
subject: typeof entry.subject === "string" ? entry.subject : "",
effect: typeof entry.effect === "string" ? entry.effect : "unknown",
cause: typeof entry.cause === "string" ? entry.cause : "",
recommendation: typeof entry.recommendation === "string" ? entry.recommendation : "",
};
});
const labelOf = (key: string) => key === "Totals" ? "Totals" : fields.find(field => field.key === key)?.label
?? fields.find(field => field.label === key)?.label;
const summary = limitSummary(limits, undefined, labelOf);
// C9's Totals subject is a readable scope label. Preserve its cause rather than scrubbing it as a key.
const scope = limits.filter(limit => limit.effect === "scope_default" && limit.subject === "Totals");
const causes = [...new Set(scope.map(limit => gridLimitCopy(limit.cause).trim()).filter(Boolean))];
const fixes = [...new Set(scope.map(limit => gridLimitCopy(limit.recommendation).trim()).filter(Boolean))];
const scopeNote = scope.length ? {
short: causes.join(" ") || "The total has a limit.",
full: [...causes, ...fixes].join("\n") || "The total has a limit.",
} : null;
const disclosure = limitSummary(limits.filter(limit => (limit.effect === "scope_default" && limit.subject !== "Totals")
|| limit.effect === "none")
.map(limit => ({ ...limit, effect: "cell_disclosure" })), undefined, labelOf);
const notes = [summary, disclosure, scopeNote].filter((note): note is NonNullable<typeof note> => note !== null);
return { short: notes.map(note => note.short).join(" · "), full: notes.map(note => note.full).join("\n\n") };
}
/** The lower-right attention diamond leaves state, note and validation marks visible. */
export function paintCellLimitMark(
ctx: CanvasRenderingContext2D,
rect: { x: number; y: number; width: number; height: number },
cell: CellWithLimits | null | undefined,
zoom = 1,
): void {
if (!cellHasLimits(cell)) return;
const x = rect.x + rect.width - 5 * zoom, y = rect.y + rect.height - 5 * zoom;
const radius = 3 * zoom;
ctx.save();
ctx.strokeStyle = tokenColour("--lp-yellow-deep", LP_YELLOW_DEEP);
ctx.lineWidth = zoom;
ctx.beginPath();
ctx.moveTo(x, y - radius);
ctx.lineTo(x + radius, y);
ctx.lineTo(x, y + radius);
ctx.lineTo(x - radius, y);
ctx.closePath();
ctx.stroke();
ctx.restore();
}