obey-cli 0.1.0__py3-none-any.whl

obey_cli/_data/demo/repo/scripts/gen-types.mjs

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Apache-2.0
+// Generates src/generated/api-types.ts from components.schemas in openapi.yaml.
+//
+// The parser only understands the small YAML subset that openapi.yaml uses: nested mappings,
+// scalars and one-line [a, b] lists. Usage: node scripts/gen-types.mjs [--check]
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const specPath = resolve(root, "openapi.yaml");
+const outPath = resolve(root, "src/generated/api-types.ts");
+
+const HEADER = [
+  "// SPDX-License-Identifier: Apache-2.0",
+  "// Generated from openapi.yaml by scripts/gen-types.mjs — do not edit.",
+];
+
+function unquote(text) {
+  const match = /^(['"])(.*)\1$/.exec(text);
+  return match ? match[2] : text;
+}
+
+function parseValue(text) {
+  if (text.startsWith("[") && text.endsWith("]")) {
+    const parts = text.slice(1, -1).split(",");
+    return parts.map((part) => unquote(part.trim())).filter((part) => part !== "");
+  }
+  return unquote(text);
+}
+
+function parseYaml(text) {
+  const rootNode = {};
+  const stack = [{ indent: -1, node: rootNode }];
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const indent = raw.length - raw.trimStart().length;
+    const match = /^([^:]+?):(?:\s+(.*))?$/.exec(line);
+    if (!match) throw new Error(`unsupported YAML line: ${raw}`);
+    while (stack[stack.length - 1].indent >= indent) stack.pop();
+    const parent = stack[stack.length - 1].node;
+    const key = unquote(match[1].trim());
+    if (match[2] === undefined) {
+      parent[key] = {};
+      stack.push({ indent, node: parent[key] });
+    } else {
+      parent[key] = parseValue(match[2].trim());
+    }
+  }
+  return rootNode;
+}
+
+const pascal = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+const upperSnake = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+
+function tsType(schemaName, propName, prop, extras) {
+  if (prop.$ref) return prop.$ref.split("/").pop();
+  if (prop.enum) {
+    const typeName = `${schemaName}${pascal(propName)}`;
+    const constName = `${upperSnake(schemaName)}_${upperSnake(propName)}_VALUES`;
+    const values = prop.enum.map((value) => JSON.stringify(value)).join(", ");
+    extras.push(`export const ${constName} = [${values}] as const;`);
+    extras.push(`export type ${typeName} = (typeof ${constName})[number];`, "");
+    return typeName;
+  }
+  switch (prop.type) {
+    case "string":
+      return "string";
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return `${tsType(schemaName, propName, prop.items, extras)}[]`;
+    default:
+      throw new Error(`unsupported type for ${schemaName}.${propName}: ${prop.type}`);
+  }
+}
+
+function render(spec) {
+  const lines = [...HEADER, ""];
+  for (const [name, schema] of Object.entries(spec.components.schemas)) {
+    const required = schema.required ?? [];
+    const extras = [];
+    const fields = Object.entries(schema.properties).map(([propName, prop]) => {
+      const optional = required.includes(propName) ? "" : "?";
+      return `  ${propName}${optional}: ${tsType(name, propName, prop, extras)};`;
+    });
+    lines.push(...extras, `export interface ${name} {`, ...fields, "}", "");
+  }
+  return lines.join("\n");
+}
+
+const output = render(parseYaml(readFileSync(specPath, "utf8")));
+
+if (process.argv.includes("--check")) {
+  if (readFileSync(outPath, "utf8") !== output) {
+    console.error("src/generated/api-types.ts is out of date; run `pnpm gen:types`.");
+    process.exitCode = 1;
+  } else {
+    console.log("src/generated/api-types.ts is up to date.");
+  }
+} else {
+  writeFileSync(outPath, output);
+  console.log("wrote src/generated/api-types.ts");
+}

obey_cli/_data/demo/repo/src/api/client.test.ts

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import { ApiClient, ApiError } from "./client.js";
+
+interface RecordedCall {
+  url: string;
+  init: RequestInit | undefined;
+}
+
+function stubFetch(body: unknown, status = 200): { fetchFn: typeof fetch; calls: RecordedCall[] } {
+  const calls: RecordedCall[] = [];
+  const fetchFn: typeof fetch = async (input, init) => {
+    calls.push({ url: String(input), init });
+    return new Response(JSON.stringify(body), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+  };
+  return { fetchFn, calls };
+}
+
+const shiftJson = { id: "s1", personId: "p1", start: "2026-03-04T09:00:00Z", end: "2026-03-04T17:00:00Z" };
+
+describe("ApiClient", () => {
+  it("lists people from the items envelope", async () => {
+    const { fetchFn, calls } = stubFetch({ items: [{ id: "p1", name: "Ada Example", role: "barista" }] });
+    const client = new ApiClient({ baseUrl: "https://team.example.com/api/", fetchFn });
+    await expect(client.listPeople()).resolves.toEqual([{ id: "p1", name: "Ada Example", role: "barista" }]);
+    expect(calls[0]?.url).toBe("https://team.example.com/api/people");
+  });
+
+  it("sends the week range as a query and posts new shifts as JSON", async () => {
+    const { fetchFn, calls } = stubFetch(shiftJson);
+    const client = new ApiClient({ baseUrl: "/api", fetchFn });
+    const from = new Date("2026-03-02T00:00:00Z");
+    await client.createShift({ personId: "p1", start: shiftJson.start, end: shiftJson.end });
+    expect(calls[0]?.init?.method).toBe("POST");
+    expect(JSON.parse(String(calls[0]?.init?.body))).toEqual({
+      personId: "p1",
+      start: shiftJson.start,
+      end: shiftJson.end,
+    });
+
+    const list = stubFetch({ items: [shiftJson] });
+    const listing = new ApiClient({ baseUrl: "/api", fetchFn: list.fetchFn });
+    await listing.listShifts({ from, to: new Date("2026-03-09T00:00:00Z") });
+    expect(list.calls[0]?.url).toBe("/api/shifts?from=2026-03-02T00%3A00%3A00.000Z&to=2026-03-09T00%3A00%3A00.000Z");
+  });
+
+  it("raises ApiError for HTTP failures and for bodies of the wrong shape", async () => {
+    const failing = new ApiClient({ baseUrl: "/api", fetchFn: stubFetch({ error: "boom" }, 503).fetchFn });
+    await expect(failing.listPeople()).rejects.toMatchObject({ name: "ApiError", status: 503 });
+
+    const malformed = new ApiClient({ baseUrl: "/api", fetchFn: stubFetch({ items: [{ id: 7 }] }).fetchFn });
+    await expect(malformed.listPeople()).rejects.toBeInstanceOf(ApiError);
+
+    const noEnvelope = new ApiClient({ baseUrl: "/api", fetchFn: stubFetch([]).fetchFn });
+    await expect(noEnvelope.listShifts({ from: new Date(0), to: new Date(1) })).rejects.toThrow(/no items array/);
+  });
+});

obey_cli/_data/demo/repo/src/api/client.ts

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+import type { NewShift, Person, Shift } from "../generated/api-types.js";
+import { isPerson, isRecord, isShift } from "./response-guards.js";
+
+export class ApiError extends Error {
+  readonly status: number | undefined;
+
+  constructor(message: string, status?: number) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+}
+
+export interface ApiClientOptions {
+  baseUrl: string;
+  fetchFn?: typeof fetch;
+}
+
+export interface DateRange {
+  from: Date;
+  to: Date;
+}
+
+export class ApiClient {
+  private readonly baseUrl: string;
+  private readonly fetchFn: typeof fetch;
+
+  constructor(options: ApiClientOptions) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+  }
+
+  async listPeople(): Promise<Person[]> {
+    return parseItems(await this.request("/people"), isPerson, "people");
+  }
+
+  async listShifts(range: DateRange): Promise<Shift[]> {
+    const query = new URLSearchParams({ from: range.from.toISOString(), to: range.to.toISOString() });
+    return parseItems(await this.request(`/shifts?${query.toString()}`), isShift, "shifts");
+  }
+
+  async createShift(input: NewShift): Promise<Shift> {
+    const body = await this.request("/shifts", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(input),
+    });
+    if (!isShift(body)) throw new ApiError("the server returned an unexpected shape for the new shift");
+    return body;
+  }
+
+  private async request(path: string, init?: RequestInit): Promise<unknown> {
+    const response = await this.fetchFn(`${this.baseUrl}${path}`, init);
+    if (!response.ok) {
+      throw new ApiError(`request to ${path} failed with status ${response.status}`, response.status);
+    }
+    const body: unknown = await response.json();
+    return body;
+  }
+}
+
+function parseItems<T>(body: unknown, guard: (value: unknown) => value is T, what: string): T[] {
+  if (!isRecord(body) || !Array.isArray(body["items"])) {
+    throw new ApiError(`the ${what} response has no items array`);
+  }
+  const items: unknown[] = body["items"];
+  const badIndex = items.findIndex((item) => !guard(item));
+  if (badIndex !== -1) throw new ApiError(`${what}[${badIndex}] has an unexpected shape`);
+  return items.filter(guard);
+}

obey_cli/_data/demo/repo/src/api/response-guards.test.ts

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import { isPerson, isPersonRole, isRecord, isShift } from "./response-guards.js";
+
+describe("response guards", () => {
+  it("accept well-formed values and reject everything else", () => {
+    expect(isRecord({})).toBe(true);
+    expect(isRecord([])).toBe(false);
+    expect(isRecord(null)).toBe(false);
+
+    expect(isPersonRole("baker")).toBe(true);
+    expect(isPersonRole("pilot")).toBe(false);
+
+    expect(isPerson({ id: "p1", name: "Ada", role: "barista", maxWeeklyHours: 20 })).toBe(true);
+    expect(isPerson({ id: "p1", name: "Ada", role: "pilot" })).toBe(false);
+    expect(isPerson({ id: "p1", name: "Ada", role: "barista", maxWeeklyHours: "20" })).toBe(false);
+
+    expect(isShift({ id: "s", personId: "p", start: "a", end: "b", location: "Bar" })).toBe(true);
+    expect(isShift({ id: "s", personId: "p", start: "a" })).toBe(false);
+  });
+});

obey_cli/_data/demo/repo/src/api/response-guards.ts

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+// The team API is not under our control and returns plain JSON, so every response is checked
+// by hand before it is treated as one of the generated types.
+import { PERSON_ROLE_VALUES } from "../generated/api-types.js";
+import type { Person, PersonRole, Shift } from "../generated/api-types.js";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isOptional(value: unknown, type: "string" | "number"): boolean {
+  return value === undefined || typeof value === type;
+}
+
+export function isPersonRole(value: unknown): value is PersonRole {
+  return PERSON_ROLE_VALUES.some((role) => role === value);
+}
+
+export function isPerson(value: unknown): value is Person {
+  return (
+    isRecord(value) &&
+    typeof value["id"] === "string" &&
+    typeof value["name"] === "string" &&
+    isPersonRole(value["role"]) &&
+    isOptional(value["maxWeeklyHours"], "number")
+  );
+}
+
+export function isShift(value: unknown): value is Shift {
+  return (
+    isRecord(value) &&
+    typeof value["id"] === "string" &&
+    typeof value["personId"] === "string" &&
+    typeof value["start"] === "string" &&
+    typeof value["end"] === "string" &&
+    isOptional(value["location"], "string")
+  );
+}

obey_cli/_data/demo/repo/src/date-utils.test.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import {
+  addDays,
+  formatDayLabel,
+  formatTime,
+  hoursBetween,
+  parseIsoDateTime,
+  rangesOverlap,
+  startOfWeek,
+  toDayKey,
+} from "./date-utils.js";
+
+describe("parseIsoDateTime", () => {
+  it("accepts date-times with an explicit offset", () => {
+    expect(parseIsoDateTime("2026-03-04T09:00:00Z").toISOString()).toBe("2026-03-04T09:00:00.000Z");
+    expect(parseIsoDateTime("2026-03-04T10:00:00+01:00").toISOString()).toBe("2026-03-04T09:00:00.000Z");
+  });
+
+  it("rejects date-only, zone-less and garbage input", () => {
+    for (const bad of ["2026-03-04", "2026-03-04T09:00:00", "not a date", "2026-13-40T00:00:00Z"]) {
+      expect(() => parseIsoDateTime(bad)).toThrow(RangeError);
+    }
+  });
+});
+
+describe("week helpers", () => {
+  it("finds the Monday of the week, including for a Sunday", () => {
+    expect(toDayKey(startOfWeek(new Date("2026-03-04T15:30:00Z")))).toBe("2026-03-02");
+    expect(toDayKey(startOfWeek(new Date("2026-03-08T23:59:00Z")))).toBe("2026-03-02");
+  });
+
+  it("adds days across a month boundary", () => {
+    expect(toDayKey(addDays(new Date("2026-02-27T00:00:00Z"), 3))).toBe("2026-03-02");
+  });
+});
+
+describe("time helpers", () => {
+  it("measures hours and formats times in UTC", () => {
+    const start = new Date("2026-03-04T09:05:00Z");
+    expect(hoursBetween(start, new Date("2026-03-04T17:35:00Z"))).toBe(8.5);
+    expect(formatTime(start)).toBe("09:05");
+    expect(formatDayLabel(start)).toBe("Wed 4 Mar");
+  });
+
+  it("treats touching ranges as not overlapping", () => {
+    const at = (hour: number): Date => new Date(Date.UTC(2026, 2, 4, hour));
+    expect(rangesOverlap(at(9), at(12), at(12), at(15))).toBe(false);
+    expect(rangesOverlap(at(9), at(13), at(12), at(15))).toBe(true);
+  });
+});

obey_cli/_data/demo/repo/src/date-utils.ts

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// All scheduling maths is done in UTC so results do not depend on the viewer's time zone.
+
+const MS_PER_HOUR = 3_600_000;
+const MS_PER_DAY = 24 * MS_PER_HOUR;
+
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
+
+// A full ISO 8601 date-time with an explicit offset; date-only and zone-less values are rejected.
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})$/;
+
+/** Parse an ISO 8601 date-time that carries a time zone, or throw a RangeError. */
+export function parseIsoDateTime(value: string): Date {
+  const parsed = new Date(value);
+  if (!ISO_DATE_TIME.test(value) || Number.isNaN(parsed.getTime())) {
+    throw new RangeError(`invalid ISO date-time: ${value}`);
+  }
+  return parsed;
+}
+
+/** Midnight UTC on the Monday of the week that contains `date`. */
+export function startOfWeek(date: Date): Date {
+  const daysSinceMonday = (date.getUTCDay() + 6) % 7;
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() - daysSinceMonday));
+}
+
+export function addDays(date: Date, days: number): Date {
+  return new Date(date.getTime() + days * MS_PER_DAY);
+}
+
+/** The seven days of the week that starts at `weekStart`. */
+export function weekDays(weekStart: Date): Date[] {
+  return Array.from({ length: 7 }, (_, offset) => addDays(weekStart, offset));
+}
+
+/** `YYYY-MM-DD` in UTC, used as a map key for a calendar day. */
+export function toDayKey(date: Date): string {
+  return date.toISOString().slice(0, 10);
+}
+
+export function hoursBetween(start: Date, end: Date): number {
+  return (end.getTime() - start.getTime()) / MS_PER_HOUR;
+}
+
+/** True when the half-open ranges [aStart, aEnd) and [bStart, bEnd) share any time. */
+export function rangesOverlap(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
+  return aStart < bEnd && bStart < aEnd;
+}
+
+/** `HH:MM` in UTC. */
+export function formatTime(date: Date): string {
+  const pad = (n: number): string => String(n).padStart(2, "0");
+  return `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}`;
+}
+
+/** A short column label such as `Mon 3 Mar`. */
+export function formatDayLabel(date: Date): string {
+  return `${WEEKDAYS[date.getUTCDay()]} ${date.getUTCDate()} ${MONTHS[date.getUTCMonth()]}`;
+}

obey_cli/_data/demo/repo/src/generated/api-types.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// Generated from openapi.yaml by scripts/gen-types.mjs — do not edit.
+
+export const PERSON_ROLE_VALUES = ["barista", "baker", "cashier", "manager"] as const;
+export type PersonRole = (typeof PERSON_ROLE_VALUES)[number];
+
+export interface Person {
+  id: string;
+  name: string;
+  role: PersonRole;
+  maxWeeklyHours?: number;
+}
+
+export interface Shift {
+  id: string;
+  personId: string;
+  start: string;
+  end: string;
+  location?: string;
+}
+
+export interface NewShift {
+  personId: string;
+  start: string;
+  end: string;
+  location?: string;
+}
+
+export interface PersonList {
+  items: Person[];
+}
+
+export interface ShiftList {
+  items: Shift[];
+}

obey_cli/_data/demo/repo/src/logger.test.ts

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import { createLogger } from "./logger.js";
+import type { LogSink } from "./logger.js";
+
+describe("createLogger", () => {
+  it("prefixes messages with the scope and drops levels below the minimum", () => {
+    const seen: string[] = [];
+    const record =
+      (level: string) =>
+      (...args: unknown[]): void => {
+        seen.push(`${level}:${String(args[0])}`);
+      };
+    const sink: LogSink = { debug: record("debug"), info: record("info"), warn: record("warn"), error: record("error") };
+
+    const logger = createLogger("planner", { level: "warn", sink });
+    logger.debug("hidden");
+    logger.info("hidden too");
+    logger.warn("two shifts overlap");
+    logger.error("failed");
+
+    expect(seen).toEqual(["warn:[planner] two shifts overlap", "error:[planner] failed"]);
+  });
+});

obey_cli/_data/demo/repo/src/logger.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LogSink {
+  debug(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}
+
+export interface Logger {
+  debug(message: string, ...context: unknown[]): void;
+  info(message: string, ...context: unknown[]): void;
+  warn(message: string, ...context: unknown[]): void;
+  error(message: string, ...context: unknown[]): void;
+}
+
+export interface LoggerOptions {
+  level?: LogLevel;
+  sink?: LogSink;
+}
+
+const LEVEL_ORDER: Record<LogLevel, number> = { debug: 10, info: 20, warn: 30, error: 40 };
+
+/** Create a scoped logger; this is the only place in the app that talks to the console. */
+export function createLogger(scope: string, options: LoggerOptions = {}): Logger {
+  const minimum = LEVEL_ORDER[options.level ?? "info"];
+  const sink = options.sink ?? console;
+  const emit =
+    (level: LogLevel) =>
+    (message: string, ...context: unknown[]): void => {
+      if (LEVEL_ORDER[level] < minimum) return;
+      sink[level](`[${scope}] ${message}`, ...context);
+    };
+  return { debug: emit("debug"), info: emit("info"), warn: emit("warn"), error: emit("error") };
+}

obey_cli/_data/demo/repo/src/main.ts

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+import { ApiClient } from "./api/client.js";
+import { addDays, startOfWeek } from "./date-utils.js";
+import { createLogger } from "./logger.js";
+import { renderWeekTable } from "./render-table.js";
+
+const logger = createLogger("main");
+
+async function main(): Promise<void> {
+  const root = document.querySelector<HTMLElement>("#app");
+  if (!root) {
+    logger.error("missing #app element");
+    return;
+  }
+  const client = new ApiClient({ baseUrl: root.dataset["apiBase"] ?? "/api" });
+  const weekStart = startOfWeek(new Date());
+  try {
+    const [people, shifts] = await Promise.all([
+      client.listPeople(),
+      client.listShifts({ from: weekStart, to: addDays(weekStart, 7) }),
+    ]);
+    root.innerHTML = renderWeekTable(people, shifts, weekStart);
+    logger.info("rendered the week", { people: people.length, shifts: shifts.length });
+  } catch (error) {
+    logger.error("could not load the schedule", error);
+    root.textContent = "The schedule could not be loaded. Please try again later.";
+  }
+}
+
+void main();

obey_cli/_data/demo/repo/src/render-table.test.ts

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import type { Person, Shift } from "./generated/api-types.js";
+import { escapeHtml, renderWeekTable } from "./render-table.js";
+
+const WEEK = new Date("2026-03-02T00:00:00Z");
+
+describe("escapeHtml", () => {
+  it("escapes markup characters", () => {
+    expect(escapeHtml(`<b onclick="x">Tom & 'Jerry'</b>`)).toBe(
+      "&lt;b onclick=&quot;x&quot;&gt;Tom &amp; &#39;Jerry&#39;&lt;/b&gt;",
+    );
+  });
+});
+
+describe("renderWeekTable", () => {
+  const people: Person[] = [
+    { id: "p1", name: "Ada <Example>", role: "barista" },
+    { id: "p2", name: "Bo Example", role: "baker" },
+  ];
+  const shifts: Shift[] = [
+    { id: "s1", personId: "p1", start: "2026-03-04T09:00:00Z", end: "2026-03-04T17:00:00Z", location: "Front & bar" },
+  ];
+
+  it("renders one row per person with escaped names, times and total hours", () => {
+    const html = renderWeekTable(people, shifts, WEEK);
+    expect(html.match(/<tr>/g)).toHaveLength(3);
+    expect(html).toContain("Ada &lt;Example&gt;");
+    expect(html).toContain("Wed 4 Mar");
+    expect(html).toContain('<span class="shift">09:00-17:00 Front &amp; bar</span>');
+    expect(html).toContain('<td class="total">8h</td>');
+    expect(html).toContain('<td class="total">0h</td>');
+  });
+});

obey_cli/_data/demo/repo/src/render-table.ts

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+import { formatDayLabel, formatTime, parseIsoDateTime, toDayKey, weekDays } from "./date-utils.js";
+import type { Person, Shift } from "./generated/api-types.js";
+import { groupByDay, weeklyHours } from "./shift-planner.js";
+
+const HTML_ESCAPES: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+/** Escape text for use inside HTML element content or a quoted attribute. */
+export function escapeHtml(text: string): string {
+  return text.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char);
+}
+
+function renderCell(shifts: readonly Shift[]): string {
+  const items = shifts.map((shift) => {
+    const range = `${formatTime(parseIsoDateTime(shift.start))}-${formatTime(parseIsoDateTime(shift.end))}`;
+    const place = shift.location ? ` ${escapeHtml(shift.location)}` : "";
+    return `<span class="shift">${range}${place}</span>`;
+  });
+  return `<td>${items.join("<br>")}</td>`;
+}
+
+/** Render the weekly rota as an HTML table: one row per person, one column per day. */
+export function renderWeekTable(people: readonly Person[], shifts: readonly Shift[], weekStart: Date): string {
+  const days = weekDays(weekStart);
+  const hours = weeklyHours(shifts, weekStart);
+  const header = days.map((day) => `<th scope="col">${escapeHtml(formatDayLabel(day))}</th>`).join("");
+  const rows = people.map((person) => {
+    const own = groupByDay(
+      shifts.filter((shift) => shift.personId === person.id),
+      weekStart,
+    );
+    const cells = days.map((day) => renderCell(own.get(toDayKey(day)) ?? [])).join("");
+    const total = hours.get(person.id) ?? 0;
+    return `<tr><th scope="row">${escapeHtml(person.name)}</th>${cells}<td class="total">${total}h</td></tr>`;
+  });
+  return [
+    '<table class="week">',
+    `<thead><tr><th scope="col">Team</th>${header}<th scope="col">Hours</th></tr></thead>`,
+    `<tbody>${rows.join("")}</tbody>`,
+    "</table>",
+  ].join("");
+}