@flamingo-stack/openframe-frontend-core 0.0.740 → 0.0.741

package/dist/components/features/scripts/schedule-form/schedule-timing.d.ts

@@ -0,0 +1,288 @@
+import { type ScheduleOfflineBehavior, type ScheduleTimeReference, type ScriptScheduleTrigger } from './schedule-enums';
+/**
+ * Timing model helpers for Script Schedules v2.
+ *
+ * The backend models a schedule's timing as two fields on `ScriptSchedule`:
+ * - `startAt: Instant` — the first scheduled run as an absolute **UTC** instant,
+ *   pinned to a 30-minute boundary (`xx:00` / `xx:30`).
+ * - `repeat: Long` — the recurrence interval in **seconds**, a whole number of
+ *   30-minute slots (1800, 3600, …). Null / 0 means a one-shot that fires once
+ *   at `startAt`.
+ *
+ * The UI offers repeat units that are all clean multiples of 1800s (hour, day,
+ * week, month=30d), so anything produced here is always a valid interval on the
+ * backend's 30-minute grid. (The backend also accepts a bare 30-minute repeat;
+ * the UI simply doesn't surface a sub-hour unit.)
+ *
+ * Two more fields say what happens when the instant arrives and the device is
+ * NOT there — `offlineBehavior` (`SKIP` | `RETRY_ON_RECONNECT`) and, for the
+ * latter, `reconnectWindowSeconds`, the deadline past which a queued run is
+ * abandoned. They live here because they only mean anything against a scheduled
+ * time: a `DEVICE_ONLINE` schedule already fires on reconnect, so it has no
+ * offline case to decide and is stored as `SKIP`.
+ *
+ * **Everything the user sees or picks is their LOCAL wall clock**; UTC exists
+ * only on the wire. See `toScheduleInstant` (the host's write side).
+ */
+/** True when the schedule is event-driven and has no date/time/repeat. */
+export declare function isEventTrigger(trigger: ScriptScheduleTrigger | string | null | undefined): boolean;
+/**
+ * Which clock the picked date + time mean — `timeReference`, the second half of
+ * what `startAt` says.
+ *
+ * - `SERVER` (the default, and what every schedule authored before the field
+ *   existed carries): `startAt` is an absolute instant. One moment, worldwide.
+ * - `DEVICE_LOCAL`: `startAt` carries the picked WALL CLOCK with no zone applied
+ *   — local 09:00 is stored as `…T09:00:00Z` — and the runner re-bases it into
+ *   each device's own timezone. One reading, many moments; a fleet across three
+ *   zones runs at 9 AM three times.
+ *
+ * The distinction reaches almost every function below, because it decides
+ * whether a stored instant is converted through the viewer's offset or read
+ * digit for digit: `toScheduleInstant`, {@link fromScheduleInstant},
+ * {@link getTimeSlotOptions} (the 30-minute grid is UTC's, and only the SERVER
+ * reading has to be shifted onto it) and `formatScheduleStartAt`.
+ *
+ * A predicate rather than `=== ENUM.X` at the call sites, for the same reason
+ * {@link isEventTrigger} is one: Relay types every schema enum with a
+ * `%future added value` member, so asking "is it the non-default arm" is what
+ * lets an unknown value fall back to SERVER — which is what the write side
+ * documents null as meaning.
+ */
+export declare function isDeviceLocalTime(timeReference: ScheduleTimeReference | string | null | undefined): boolean;
+/**
+ * The units an `[interval] [unit]` pair is built from, finest first — one list,
+ * so the dropdowns, the form schema and the seconds table cannot drift apart.
+ *
+ * Two different settings are spelled in this vocabulary, and they are NOT the
+ * same quantity: the repeat cadence (`repeat`, how often the schedule fires) and
+ * the reconnect window (`reconnectWindowSeconds`, how long an offline device's
+ * queued run is still worth running). They share the units and the seconds
+ * table; nothing else. In particular {@link MIN_REPEAT_MINUTES} is a property of
+ * the RUNNER'S grid and constrains the cadence only — a reconnect window is a
+ * plain deadline and may sit anywhere.
+ */
+export declare const DURATION_UNIT_VALUES: readonly ["minute", "hour", "day", "week", "month"];
+export type DurationUnit = (typeof DURATION_UNIT_VALUES)[number];
+export declare const DURATION_UNIT_SECONDS: Record<DurationUnit, number>;
+export declare const DURATION_UNIT_LABELS: Record<DurationUnit, string>;
+/**
+ * The smallest cadence the backend's grid allows: `repeat` must be a whole
+ * number of 30-minute slots, so 30 minutes is one slot and there is nothing
+ * below it. Every other unit clears this by construction (an hour is two slots),
+ * which is why the rule only ever has to be enforced on minutes.
+ */
+export declare const MIN_REPEAT_MINUTES = 30;
+export declare const DURATION_UNIT_OPTIONS: {
+    label: string;
+    value: DurationUnit;
+}[];
+/**
+ * Snaps a repeat interval onto what its unit can legally express. Only minutes
+ * can be illegal — see {@link MIN_REPEAT_MINUTES} — so every other unit is
+ * returned untouched.
+ *
+ * Used when the unit CHANGES: switching "1 Day" to minutes would otherwise leave
+ * "1 Minute" sitting in the form, a value the user never typed and cannot save.
+ */
+export declare function snapRepeatInterval(interval: number | null, unit: DurationUnit): number | null;
+/**
+ * True when a schedule QUEUES a run for a device that was offline at its
+ * scheduled time, instead of logging the miss and moving on.
+ *
+ * The counterpart of {@link isEventTrigger}, and the reason both are predicates
+ * rather than `=== ENUM.X` at the call sites: Relay types every schema enum with
+ * a `%future added value` member, so a stored value this client doesn't know
+ * reads as neither arm. Asking "is it the non-default one" answers that safely —
+ * an unknown behavior falls back to SKIP, which is also what the backend
+ * documents as the default.
+ */
+export declare function isRetryOnReconnect(behavior: ScheduleOfflineBehavior | string | null | undefined): boolean;
+/**
+ * The floor on the reconnect window, in minutes.
+ *
+ * NOT the runner's grid — this field sits on none, the backend accepts any
+ * number of seconds. It is the same 30 as {@link MIN_REPEAT_MINUTES} and a
+ * separate constant on purpose: that one follows the runner, this one follows
+ * the shortest cadence a schedule can have, and there is no reason the two must
+ * move together.
+ *
+ * Unlike the repeat floor it is a MINIMUM only — no multiple-of-30 rule, because
+ * there is no grid for a value to land on. A 45-minute window is legal.
+ */
+export declare const MIN_RECONNECT_MINUTES = 30;
+/**
+ * Raises a reconnect interval to its floor when the unit switches to minutes —
+ * the counterpart of {@link snapRepeatInterval}, minus the multiple half.
+ *
+ * `null` (the field cleared while typing) passes through untouched: snapping it
+ * to a number would refill a box the user is in the middle of emptying, which is
+ * the behaviour this whole pair of fields was reported for.
+ */
+export declare function snapReconnectInterval(interval: number | null, unit: DurationUnit): number | null;
+/**
+ * What the "Stop Retry after" pair starts at.
+ *
+ * The design shows 1 Week (node 460:63425); the product rule is the floor —
+ * minutes, at the minimum — so a new schedule starts at the smallest legal
+ * window and the user raises it, rather than starting at a week they may not
+ * want. It is only ever a SEED: the field is required whenever
+ * RETRY_ON_RECONNECT is picked, so every saved schedule carries a window the
+ * user could see, and `reconnectWindowSeconds` is never written blind.
+ */
+export declare const DEFAULT_RECONNECT_WINDOW: {
+    interval: number;
+    unit: DurationUnit;
+};
+/**
+ * Whether an `HH:mm` the form already holds is a slot the given reading offers.
+ *
+ * Only ever false where the two grids differ — the 45-minute zones — which is
+ * exactly where switching the Timezone control leaves a picked time the new
+ * dropdown cannot show. Asked about the GRID and not about the option list, so
+ * a stored start that has simply gone by (which the list withholds, and which
+ * the form is allowed to keep) is not mistaken for one the grid rejects.
+ */
+export declare function isSlotOnGrid(slot: string, timeReference: ScheduleTimeReference | string | null | undefined): boolean;
+/**
+ * The Time dropdown's options — one per 30-minute slot of the **local** day,
+ * shifted onto the grid `startAt` must land on (see {@link slotBaseMinutes}).
+ * `value` is 24h `HH:mm` (what the form stores); `label` is the 12h form.
+ *
+ * A function rather than a const because the grid depends on the viewer's
+ * timezone, which a module evaluated during prerender does not know.
+ *
+ * `forDate` drops the slots that have already gone by: a schedule cannot start
+ * in the past, and offering "8:00 AM" at noon means offering a save the backend
+ * refuses. Only a `forDate` of TODAY narrows the list — a later day keeps the
+ * full 48, and so does a day not yet picked (the user may well be about to pick
+ * tomorrow; picking today afterwards is what clears a time that has gone by).
+ * A PAST day keeps them too: it can only be a stored start, and the value that
+ * schedule already holds has to stay readable.
+ *
+ * **None of that narrowing applies to DEVICE_LOCAL**, which keeps all 48 slots
+ * always. The reading is not the viewer's clock, so "already gone by" is not the
+ * viewer's to judge: the fleet's own clocks span 26 hours (UTC−12 … UTC+14), so
+ * 8:00 AM at the author's noon is still hours ahead for every device west of
+ * them. Withholding it would hide a perfectly good schedule behind the accident
+ * of where the admin sits. See {@link earliestDeviceLocalDay} for the one bound
+ * that IS meaningful, and note the backend agrees — it validates no start
+ * against the past, for either reading.
+ */
+export declare function getTimeSlotOptions(forDate?: Date | null, timeReference?: ScheduleTimeReference | string | null): {
+    value: string;
+    label: string;
+}[];
+/**
+ * The dropdown reading for an `HH:mm` the option list no longer carries — a
+ * stored start whose slot has already gone by today. The form's value has to
+ * stay VISIBLE (it is what will be saved if nothing else changes), so the Select
+ * gets its option back with the same label the live slots use.
+ */
+export declare function slotToLabel(slot: string): string;
+/**
+ * Local midnight today — the earliest day a schedule may start, and what the
+ * date picker takes as its `fromDate`.
+ *
+ * Midnight rather than "now": the calendar selects whole days, so today has to
+ * stay pickable all day long. Which of today's SLOTS are still available is the
+ * time dropdown's half of the same rule ({@link getTimeSlotOptions}).
+ *
+ * Built per call — a module-level constant would freeze the boundary at import
+ * time and let a tab left open overnight pick yesterday.
+ */
+export declare function startOfToday(): Date;
+/**
+ * The earliest day a DEVICE_LOCAL schedule may start: today **as read on the
+ * westernmost clock on Earth** (UTC−12), returned as a local `Date` the calendar
+ * can take as its `fromDate`.
+ *
+ * The viewer's own midnight is the wrong bound here. A wall clock is not an
+ * instant, so a day is "gone" only once it has gone everywhere — and the fleet's
+ * clocks span 26 hours, so for a viewer in Kyiv or Auckland the calendar day
+ * that already ended for THEM is still running for a device in Baker Island.
+ * Bounding by the viewer would refuse a date that is genuinely in the future for
+ * part of the fleet; bounding by UTC−12 refuses only what no device anywhere can
+ * still reach.
+ *
+ * In practice this is today, or yesterday for viewers far enough east — which is
+ * the whole of the correction, and it is deliberately the only one: within a day
+ * that is still live somewhere, WHICH devices are still ahead of the picked time
+ * is the runner's business (it fires each device at its own local reading and
+ * marks the ones that have gone past their catch-up window MISSED), not a rule
+ * the form can usefully pre-empt.
+ */
+export declare function earliestDeviceLocalDay(): Date;
+/**
+ * The earliest day the picker may offer, for either reading — the calendar's
+ * `fromDate`, and the day the "start in the past" rules measure against.
+ */
+export declare function earliestScheduleDay(timeReference?: ScheduleTimeReference | string | null): Date;
+/**
+ * Whether a picked day + slot has already gone by. Compared as instants, so a
+ * slot that is still minutes away passes.
+ *
+ * Always false for DEVICE_LOCAL: the pair is a wall clock every device reads on
+ * its own timezone, so there is no single instant to have gone by — see
+ * {@link getTimeSlotOptions}.
+ */
+export declare function isScheduleStartInPast(date: Date | null | undefined, slot: string, timeReference?: ScheduleTimeReference | string | null): boolean;
+/** What both the field and the schema say about a start that has gone by. */
+export declare const PAST_START_MESSAGE = "Start time must be in the future";
+/**
+ * What a picked TODAY says once its last 30-minute slot has gone by.
+ *
+ * The dead end this names: `getTimeSlotOptions` correctly withholds every slot,
+ * so the Time dropdown has nothing to offer — and an empty popup states no
+ * reason and offers no way on. It is the DATE that has to change, which is why
+ * the message says so and why the field showing it is the date's.
+ *
+ * Not a schema rule: a schedule with no time already fails the save on
+ * `scheduledTime` being required. This is the earlier, more useful half of the
+ * same fact, said while the user can still act on it.
+ */
+export declare const NO_SLOTS_TODAY_MESSAGE = "No start times left today \u2014 pick another day";
+/**
+ * The "no start in the past" rule as the FORM applies it — stated once, and read
+ * by both the fields (which show it the moment it happens) and the schema (which
+ * refuses the save).
+ *
+ * The exemption is the whole reason it needs a name: a schedule already stored
+ * with a past start keeps it. Recurring schedules legitimately started long ago,
+ * and without this, renaming one would demand re-picking its date. So the stored
+ * instant stays legal for exactly as long as the form still shows it; moving
+ * either half makes the choice a new one, held to the same rule as any other.
+ *
+ * The rule does not exist at all for DEVICE_LOCAL — `isScheduleStartInPast`
+ * answers false there — which is why the day bound
+ * ({@link earliestDeviceLocalDay}) is the only thing left holding that reading
+ * to a future the fleet can still reach.
+ */
+export declare function isStartInPastAndChanged(date: Date | null | undefined, slot: string, storedIso: string | null | undefined, timeReference?: ScheduleTimeReference | string | null): boolean;
+/**
+ * A picked date → the local `HH:mm` slot it sits on (empty when no date yet).
+ *
+ * A stored `startAt` always lands on a slot exactly, since the backend enforces
+ * the same grid this builds from; the flooring is for values authored outside
+ * this UI, and it keeps them on a slot the dropdown can actually show.
+ */
+export declare function dateToTimeSlot(date: Date | null | undefined, timeReference?: ScheduleTimeReference | string | null): string;
+/**
+ * Applies an `HH:mm` slot to the picked date. Choosing a time before a date
+ * anchors it to today — the same fallback the core date-time picker uses.
+ */
+export declare function applyTimeSlot(date: Date | null | undefined, slot: string): Date;
+/**
+ * Inverse of `toScheduleInstant`: a stored UTC instant → the `Date` for
+ * that moment, which the picker and every formatter below then read through the
+ * viewer's own clock.
+ *
+ * A DEVICE_LOCAL start carries no moment to convert — its digits are a wall
+ * clock — so they are lifted back out of UTC and rebuilt as LOCAL components.
+ * The `Date` that comes back is therefore not the instant the string names; it
+ * is the reading, in the only form the pickers and formatters here can hold one.
+ * Passing the reference through is what keeps "9 AM on every device" from
+ * displaying as noon to the viewer who typed it.
+ */
+export declare function fromScheduleInstant(iso: string, timeReference?: ScheduleTimeReference | string | null): Date;
+//# sourceMappingURL=schedule-timing.d.ts.map

package/dist/components/features/scripts/schedule-form/schedule-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-timing.d.ts","sourceRoot":"","sources":["../../../../../src/components/features/scripts/schedule-form/schedule-timing.ts"],"names":[],"mappings":"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"}

package/dist/components/features/scripts/schedule-form/schedule-timing.js

@@ -0,0 +1,165 @@
+"use client";
+import { formatTime } from "../../../../utils/format-date.js";
+import {
+  SCHEDULE_OFFLINE_BEHAVIOR,
+  SCHEDULE_TIME_REFERENCE,
+  SCRIPT_SCHEDULE_TRIGGER
+} from "./schedule-enums.js";
+function isEventTrigger(trigger) {
+  return trigger === SCRIPT_SCHEDULE_TRIGGER.DEVICE_ONLINE;
+}
+function isDeviceLocalTime(timeReference) {
+  return timeReference === SCHEDULE_TIME_REFERENCE.DEVICE_LOCAL;
+}
+const DURATION_UNIT_VALUES = ["minute", "hour", "day", "week", "month"];
+const DURATION_UNIT_SECONDS = {
+  minute: 60,
+  hour: 3600,
+  day: 86400,
+  week: 604800,
+  month: 2592e3
+  // 30 days — the only "calendar" unit the seconds model can approximate
+};
+const DURATION_UNIT_LABELS = {
+  minute: "Minute",
+  hour: "Hour",
+  day: "Day",
+  week: "Week",
+  month: "Month"
+};
+const MIN_REPEAT_MINUTES = 30;
+const DURATION_UNIT_OPTIONS = DURATION_UNIT_VALUES.map((value) => ({
+  value,
+  label: DURATION_UNIT_LABELS[value]
+}));
+function snapRepeatInterval(interval, unit) {
+  if (unit !== "minute" || interval === null) return interval;
+  if (!Number.isFinite(interval) || interval < MIN_REPEAT_MINUTES) return MIN_REPEAT_MINUTES;
+  return Math.ceil(interval / MIN_REPEAT_MINUTES) * MIN_REPEAT_MINUTES;
+}
+function isRetryOnReconnect(behavior) {
+  return behavior === SCHEDULE_OFFLINE_BEHAVIOR.RETRY_ON_RECONNECT;
+}
+const MIN_RECONNECT_MINUTES = 30;
+function snapReconnectInterval(interval, unit) {
+  if (unit !== "minute" || interval === null) return interval;
+  return Math.max(interval, MIN_RECONNECT_MINUTES);
+}
+const DEFAULT_RECONNECT_WINDOW = {
+  interval: MIN_RECONNECT_MINUTES,
+  unit: "minute"
+};
+const SLOTS_PER_DAY = 48;
+const SLOT_MINUTES = 30;
+function slotBaseMinutes(timeReference) {
+  if (isDeviceLocalTime(timeReference)) return 0;
+  const offset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  return (-offset % SLOT_MINUTES + SLOT_MINUTES) % SLOT_MINUTES;
+}
+function isSlotOnGrid(slot, timeReference) {
+  if (!slot) return true;
+  const [hours, minutes] = slot.split(":").map(Number);
+  const offGrid = (hours * 60 + minutes - slotBaseMinutes(timeReference)) % SLOT_MINUTES;
+  return (offGrid % SLOT_MINUTES + SLOT_MINUTES) % SLOT_MINUTES === 0;
+}
+function slotValue(minutesOfDay) {
+  const hours = Math.floor(minutesOfDay / 60);
+  const minutes = minutesOfDay % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+function slotLabel(minutesOfDay) {
+  return formatTime(new Date(1970, 0, 1, Math.floor(minutesOfDay / 60), minutesOfDay % 60));
+}
+function getTimeSlotOptions(forDate, timeReference) {
+  const base = slotBaseMinutes(timeReference);
+  const cutoff = !isDeviceLocalTime(timeReference) && forDate && isToday(forDate) ? nowMinutesOfDay() : -1;
+  return Array.from({ length: SLOTS_PER_DAY }, (_, slot) => {
+    const minutesOfDay = base + slot * SLOT_MINUTES;
+    return { value: slotValue(minutesOfDay), label: slotLabel(minutesOfDay), minutesOfDay };
+  }).filter((slot) => slot.minutesOfDay > cutoff).map(({ value, label }) => ({ value, label }));
+}
+function slotToLabel(slot) {
+  const [hours, minutes] = slot.split(":").map(Number);
+  return slotLabel(hours * 60 + minutes);
+}
+function nowMinutesOfDay() {
+  const now = /* @__PURE__ */ new Date();
+  return now.getHours() * 60 + now.getMinutes();
+}
+function isToday(date) {
+  const now = /* @__PURE__ */ new Date();
+  return date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+}
+function startOfToday() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+}
+function earliestDeviceLocalDay() {
+  const westernmostNow = new Date(Date.now() - 12 * 60 * 60 * 1e3);
+  return new Date(westernmostNow.getUTCFullYear(), westernmostNow.getUTCMonth(), westernmostNow.getUTCDate());
+}
+function earliestScheduleDay(timeReference) {
+  return isDeviceLocalTime(timeReference) ? earliestDeviceLocalDay() : startOfToday();
+}
+function isScheduleStartInPast(date, slot, timeReference) {
+  if (!date || !slot || isDeviceLocalTime(timeReference)) return false;
+  return applyTimeSlot(date, slot).getTime() < Date.now();
+}
+const PAST_START_MESSAGE = "Start time must be in the future";
+const NO_SLOTS_TODAY_MESSAGE = "No start times left today \u2014 pick another day";
+function isStartInPastAndChanged(date, slot, storedIso, timeReference) {
+  if (!isScheduleStartInPast(date, slot, timeReference) || !date) return false;
+  const stored = storedIso ? fromScheduleInstant(storedIso, timeReference).getTime() : null;
+  return applyTimeSlot(date, slot).getTime() !== stored;
+}
+function dateToTimeSlot(date, timeReference) {
+  if (!date) return "";
+  const base = slotBaseMinutes(timeReference);
+  const minutesOfDay = date.getHours() * 60 + date.getMinutes();
+  const slot = Math.min(SLOTS_PER_DAY - 1, Math.max(0, Math.floor((minutesOfDay - base) / SLOT_MINUTES)));
+  return slotValue(base + slot * SLOT_MINUTES);
+}
+function applyTimeSlot(date, slot) {
+  const [hours, minutes] = slot.split(":").map(Number);
+  const next = date ? new Date(date) : /* @__PURE__ */ new Date();
+  next.setHours(hours, minutes, 0, 0);
+  return next;
+}
+function fromScheduleInstant(iso, timeReference) {
+  const instant = new Date(iso);
+  if (!isDeviceLocalTime(timeReference)) return instant;
+  return new Date(
+    instant.getUTCFullYear(),
+    instant.getUTCMonth(),
+    instant.getUTCDate(),
+    instant.getUTCHours(),
+    instant.getUTCMinutes()
+  );
+}
+export {
+  DEFAULT_RECONNECT_WINDOW,
+  DURATION_UNIT_LABELS,
+  DURATION_UNIT_OPTIONS,
+  DURATION_UNIT_SECONDS,
+  DURATION_UNIT_VALUES,
+  MIN_RECONNECT_MINUTES,
+  MIN_REPEAT_MINUTES,
+  NO_SLOTS_TODAY_MESSAGE,
+  PAST_START_MESSAGE,
+  applyTimeSlot,
+  dateToTimeSlot,
+  earliestDeviceLocalDay,
+  earliestScheduleDay,
+  fromScheduleInstant,
+  getTimeSlotOptions,
+  isDeviceLocalTime,
+  isEventTrigger,
+  isRetryOnReconnect,
+  isScheduleStartInPast,
+  isSlotOnGrid,
+  isStartInPastAndChanged,
+  slotToLabel,
+  snapReconnectInterval,
+  snapRepeatInterval,
+  startOfToday
+};

package/dist/components/features/scripts/script-cells.d.ts

@@ -0,0 +1,11 @@
+/** A name over its description: the first column of both Scripts tables. */
+export declare function ScriptNameCell({ name, description }: {
+    name: string;
+    description?: string | null;
+}): import("react").JSX.Element;
+/** When a schedule starts: the date over the time (and whose clock the time is read on). */
+export declare function ScheduleDateTimeCell({ date, time }: {
+    date: string;
+    time: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=script-cells.d.ts.map

package/dist/components/features/scripts/script-cells.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-cells.d.ts","sourceRoot":"","sources":["../../../../src/components/features/scripts/script-cells.tsx"],"names":[],"mappings":"AAIA,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,+BAWlG;AAED,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,+BASlF"}

package/dist/components/features/scripts/script-cells.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { TruncateText } from "../../ui/truncate-text.js";
+function ScriptNameCell({ name, description }) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col justify-center gap-1", children: [
+    /* @__PURE__ */ jsx(TruncateText, { children: name }),
+    description && /* @__PURE__ */ jsx(TruncateText, { variant: "h6", tone: "secondary", children: description })
+  ] });
+}
+function ScheduleDateTimeCell({ date, time }) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col justify-center gap-1", children: [
+    /* @__PURE__ */ jsx(TruncateText, { children: date }),
+    /* @__PURE__ */ jsx(TruncateText, { variant: "h6", tone: "secondary", children: time })
+  ] });
+}
+export {
+  ScheduleDateTimeCell,
+  ScriptNameCell
+};

package/dist/components/features/scripts/script-executions-table.d.ts

@@ -0,0 +1,58 @@
+import { type ReactNode } from 'react';
+import { type ScriptsTableColumnLayout } from './scripts-table-columns';
+/** One execution, as the Execution History shows it. */
+export interface ScriptExecutionTableRow {
+    id: string;
+    executionId: string;
+    /** When it was dispatched, already formatted. */
+    timestamp: string;
+    /** `'QUEUED'`, `'RUNNING'`, `'SUCCESS'` or `'FAILED'`. */
+    status: string;
+    machineName: string;
+    /** The device's customer. */
+    organization?: string | null;
+    /** Who it ran for. */
+    initiator: {
+        name: string;
+        initials: string;
+        image?: string;
+    };
+    /** `'MANUAL'`, `'SCHEDULED'` or `'AI_ASSISTANT'`. */
+    source?: string | null;
+    /** Which script ran: only where a list runs several (a schedule's). */
+    scriptName?: string | null;
+    /** Everything the run printed. */
+    result?: string | null;
+    /** The execution's page: the row's link and the open-in-new-tab button. */
+    href?: string;
+}
+export interface ScriptExecutionsTableProps {
+    rows: ScriptExecutionTableRow[];
+    /**
+     * The columns and their widths. Defaults to the product's
+     * (`EXECUTIONS_TABLE_COLUMNS`); a host narrower than the product's page
+     * passes its own arrangement of `EXECUTION_COLUMNS`.
+     */
+    columns?: readonly ScriptsTableColumnLayout[];
+    /** Column ids to leave out (`'result'`, `'open'`). */
+    hideColumns?: readonly string[];
+    /** Content under a row, inside its card: an execution's output, for one. */
+    renderSubRow?: (row: ScriptExecutionTableRow) => ReactNode;
+    /** The table's dense rows, as tall as their two lines (the product's page uses the full row). */
+    compact?: boolean;
+    isLoading?: boolean;
+    emptyMessage?: string;
+    /** Draw the column header row; a picture short of height leaves it out. */
+    showHeader?: boolean;
+    /** Rendered at the right edge of the header (a row count). */
+    rightSlot?: ReactNode;
+    skeletonRows?: number;
+}
+/**
+ * The Execution History of a script or a schedule, presentational: every
+ * run with its time, status, device and who it ran for. Rows are a view-model
+ * the host maps its executions into. The product's own page keeps its live
+ * table (filters, paging, the date header) over the same cells and layout.
+ */
+export declare function ScriptExecutionsTable({ rows, columns: layout, hideColumns, renderSubRow, compact, isLoading, emptyMessage, showHeader: withHeader, rightSlot, skeletonRows, }: ScriptExecutionsTableProps): import("react").JSX.Element;
+//# sourceMappingURL=script-executions-table.d.ts.map

package/dist/components/features/scripts/script-executions-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-executions-table.d.ts","sourceRoot":"","sources":["../../../../src/components/features/scripts/script-executions-table.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAwB,MAAM,OAAO,CAAC;AAU7D,OAAO,EAA+C,KAAK,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGrH,wDAAwD;AACxD,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,sBAAsB;IACtB,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9D,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,uBAAuB,EAAE,CAAC;IAChC;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC9C,sDAAsD;IACtD,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,4EAA4E;IAC5E,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,uBAAuB,KAAK,SAAS,CAAC;IAC3D,iGAAiG;IACjG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,OAAO,EAAE,MAAiC,EAC1C,WAAW,EACX,YAAY,EACZ,OAAe,EACf,SAAiB,EACjB,YAAqC,EACrC,UAAU,EAAE,UAAiB,EAC7B,SAAS,EACT,YAAiB,GAClB,EAAE,0BAA0B,+BAkE5B"}

package/dist/components/features/scripts/script-executions-table.js

@@ -0,0 +1,88 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import { DataTable, useDataTable } from "../../ui/data-table/index.js";
+import { SquareAvatar } from "../../ui/square-avatar.js";
+import {
+  ExecutionDeviceCell,
+  ExecutionInitiatorCell,
+  ExecutionResultCell,
+  ExecutionStatusCell,
+  ExecutionTimestampCell
+} from "./execution-cells.js";
+import { EXECUTION_COLUMNS, EXECUTIONS_TABLE_COLUMNS } from "./scripts-table-columns.js";
+import { OpenInNewTabCell, scriptsColumnMeta } from "./scripts-table-shared.js";
+function ScriptExecutionsTable({
+  rows,
+  columns: layout = EXECUTIONS_TABLE_COLUMNS,
+  hideColumns,
+  renderSubRow,
+  compact = false,
+  isLoading = false,
+  emptyMessage = "No executions found.",
+  showHeader: withHeader = true,
+  rightSlot,
+  skeletonRows = 10
+}) {
+  const columns = useMemo(() => {
+    const renderers = {
+      [EXECUTION_COLUMNS.executionId.id]: (row) => /* @__PURE__ */ jsx(ExecutionTimestampCell, { timestamp: row.timestamp, executionId: row.executionId }),
+      [EXECUTION_COLUMNS.status.id]: (row) => /* @__PURE__ */ jsx(ExecutionStatusCell, { status: row.status }),
+      [EXECUTION_COLUMNS.machineId.id]: (row) => /* @__PURE__ */ jsx(ExecutionDeviceCell, { name: row.machineName, organization: row.organization }),
+      [EXECUTION_COLUMNS.initiatorId.id]: (row) => /* @__PURE__ */ jsx(
+        ExecutionInitiatorCell,
+        {
+          avatar: /* @__PURE__ */ jsx(
+            SquareAvatar,
+            {
+              variant: "round",
+              size: "md",
+              src: row.initiator.image,
+              fallback: row.initiator.initials,
+              alt: row.initiator.name,
+              initialsClassName: "text-ods-text-secondary"
+            }
+          ),
+          name: row.initiator.name,
+          source: row.source,
+          scriptName: row.scriptName
+        }
+      ),
+      [EXECUTION_COLUMNS.result.id]: (row) => /* @__PURE__ */ jsx(ExecutionResultCell, { result: row.result }),
+      [EXECUTION_COLUMNS.open.id]: (row) => row.href ? /* @__PURE__ */ jsx(OpenInNewTabCell, { href: row.href }) : null
+    };
+    return layout.filter((column) => renderers[column.id] && !hideColumns?.includes(column.id)).map((column) => ({
+      id: column.id,
+      header: column.header ?? "",
+      cell: ({ row }) => renderers[column.id](row.original),
+      enableSorting: false,
+      meta: scriptsColumnMeta(column)
+    }));
+  }, [layout, hideColumns]);
+  const table = useDataTable({
+    data: rows,
+    columns,
+    getRowId: (row) => row.id,
+    enableSorting: false
+  });
+  const rowHref = useCallback((row) => row.href, []);
+  const showHeader = withHeader && (isLoading || rows.length > 0);
+  return /* @__PURE__ */ jsxs(DataTable, { table, children: [
+    showHeader && /* @__PURE__ */ jsx(DataTable.Header, { rightSlot }),
+    /* @__PURE__ */ jsx(
+      DataTable.Body,
+      {
+        loading: isLoading,
+        skeletonRows,
+        emptyMessage,
+        rowClassName: "mb-1",
+        compact,
+        rowHref,
+        renderSubRow
+      }
+    )
+  ] });
+}
+export {
+  ScriptExecutionsTable
+};