@lostgradient/cinder 0.9.0 → 0.11.0

package/dist/server/index.server-qbkxz7r2.js

@@ -0,0 +1,750 @@
+import {
+  Time_field
+} from "./index.server-c42b462p.js";
+import {
+  Select
+} from "./index.server-ex3ea9z0.js";
+import {
+  Number_input
+} from "./index.server-d146g8pr.js";
+import {
+  Segmented_control
+} from "./index.server-xeqtpv61.js";
+import {
+  Segment
+} from "./index.server-sedjxt36.js";
+import {
+  Input
+} from "./index.server-8xvc73zh.js";
+import {
+  Chip
+} from "./index.server-b6jr01st.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/schedule-builder/schedule-builder.svelte
+import * as $ from "svelte/internal/server";
+
+// src/components/schedule-builder/schedule-builder.utilities.ts
+var INTERVAL_UNITS = [
+  "minutes",
+  "hours",
+  "days",
+  "weeks"
+];
+var WEEKDAYS = [
+  { value: 1, short: "Mon", long: "Monday" },
+  { value: 2, short: "Tue", long: "Tuesday" },
+  { value: 3, short: "Wed", long: "Wednesday" },
+  { value: 4, short: "Thu", long: "Thursday" },
+  { value: 5, short: "Fri", long: "Friday" },
+  { value: 6, short: "Sat", long: "Saturday" },
+  { value: 0, short: "Sun", long: "Sunday" }
+];
+var CRON_FIELDS = [
+  { name: "Minute", min: 0, max: 59, hint: "0–59" },
+  { name: "Hour", min: 0, max: 23, hint: "0–23" },
+  { name: "Day of month", min: 1, max: 31, hint: "1–31" },
+  { name: "Month", min: 1, max: 12, hint: "1–12" },
+  { name: "Day of week", min: 0, max: 6, hint: "0–6 (Sun–Sat)" }
+];
+function defaultScheduleValue() {
+  return { mode: "interval", every: 15, unit: "minutes" };
+}
+function singularUnit(unit) {
+  return unit.slice(0, -1);
+}
+function validateCronField(rawValue, fieldIndex) {
+  const field = CRON_FIELDS[fieldIndex];
+  if (!field)
+    return "Unknown field.";
+  const value = rawValue.trim();
+  if (value === "")
+    return "Required.";
+  const inRange = (n) => Number.isInteger(n) && n >= field.min && n <= field.max;
+  for (const part of value.split(",")) {
+    const token = part.trim();
+    if (token === "")
+      return "Empty list item.";
+    if (token === "*")
+      continue;
+    const stepMatch = token.match(/^(\*|\d+-\d+)\/(\d+)$/);
+    if (stepMatch) {
+      const step = Number(stepMatch[2] ?? "");
+      if (!Number.isInteger(step) || step <= 0)
+        return "Step must be a positive integer.";
+      if (step > field.max)
+        return `Step is larger than ${field.hint}.`;
+      const rangeText = stepMatch[1] ?? "*";
+      if (rangeText !== "*") {
+        const [a, b] = rangeText.split("-").map(Number);
+        if (a === undefined || b === undefined || !inRange(a) || !inRange(b)) {
+          return `Out of range (${field.hint}).`;
+        }
+        if (a > b)
+          return "Range start is after its end.";
+      }
+      continue;
+    }
+    const rangeMatch = token.match(/^(\d+)-(\d+)$/);
+    if (rangeMatch) {
+      const a = Number(rangeMatch[1]);
+      const b = Number(rangeMatch[2]);
+      if (!inRange(a) || !inRange(b))
+        return `Out of range (${field.hint}).`;
+      if (a > b)
+        return "Range start is after its end.";
+      continue;
+    }
+    if (/^\d+$/.test(token)) {
+      if (!inRange(Number(token)))
+        return `Out of range (${field.hint}).`;
+      continue;
+    }
+    return "Not a valid cron token.";
+  }
+  return;
+}
+function cronFieldsValid(fields) {
+  return fields.length === 5 && fields.every((value, index) => validateCronField(value, index) === undefined);
+}
+function joinCron(fields) {
+  return fields.map((field) => field.trim()).join(" ");
+}
+function splitCron(expression) {
+  const parts = expression.trim().split(/\s+/).filter(Boolean);
+  const lastField = parts.length > 5 ? parts.slice(4).join(" ") : parts[4];
+  return [parts[0] ?? "*", parts[1] ?? "*", parts[2] ?? "*", parts[3] ?? "*", lastField ?? "*"];
+}
+function parseTime(time) {
+  const match = time.trim().match(/^(\d{1,2}):(\d{2})$/);
+  if (!match)
+    return { hour: 0, minute: 0 };
+  const hour = Math.min(23, Math.max(0, Number(match[1])));
+  const minute = Math.min(59, Math.max(0, Number(match[2])));
+  return { hour, minute };
+}
+function lowerEveryN(every, unit) {
+  const safeEvery = Number.isInteger(every) && every > 0 ? every : 1;
+  return { mode: "interval", every: safeEvery, unit };
+}
+function lowerDailyAt(time) {
+  const { hour, minute } = parseTime(time);
+  return { mode: "cron", expression: `${minute} ${hour} * * *` };
+}
+function lowerWeeklyAt(days, time) {
+  const { hour, minute } = parseTime(time);
+  const sortedDays = [...days];
+  sortedDays.sort((a, b) => a - b);
+  const dow = sortedDays.length > 0 ? sortedDays.join(",") : "*";
+  return { mode: "cron", expression: `${minute} ${hour} * * ${dow}` };
+}
+function lowerMonthlyOnDay(day, time) {
+  const { hour, minute } = parseTime(time);
+  const safeDay = Math.min(31, Math.max(1, Math.trunc(day)));
+  return { mode: "cron", expression: `${minute} ${hour} ${safeDay} * *` };
+}
+function isEvenDivisorStep(every, cycleLength) {
+  return Number.isInteger(every) && every > 0 && every < cycleLength && cycleLength % every === 0;
+}
+function valueToCronFields(value) {
+  if (value.mode === "cron")
+    return splitCron(value.expression);
+  switch (value.unit) {
+    case "minutes":
+      if (isEvenDivisorStep(value.every, 60))
+        return [`*/${value.every}`, "*", "*", "*", "*"];
+      if (value.every % 60 === 0)
+        return hoursIntervalFields(value.every / 60);
+      return ["0", "0", "*", "*", "*"];
+    case "hours":
+      return hoursIntervalFields(value.every);
+    case "days":
+    case "weeks":
+      return ["0", "0", "*", "*", "*"];
+  }
+}
+function hoursIntervalFields(everyHours) {
+  if (everyHours === 1)
+    return ["0", "*", "*", "*", "*"];
+  if (isEvenDivisorStep(everyHours, 24))
+    return ["0", `*/${everyHours}`, "*", "*", "*"];
+  return ["0", "0", "*", "*", "*"];
+}
+function valueToInterval(value) {
+  if (value.mode === "interval")
+    return { every: value.every, unit: value.unit };
+  const [minute, hour, dom, month, dow] = splitCron(value.expression);
+  if (month !== "*" || dow !== "*")
+    return;
+  if (dom === "*" && hour === "*" && minute === "*")
+    return { every: 1, unit: "minutes" };
+  if (dom === "*" && hour === "*" && minute === "0")
+    return { every: 1, unit: "hours" };
+  const minuteStep = cronFieldStep(minute);
+  if (minuteStep && isEvenDivisorStep(minuteStep, 60) && hour === "*" && dom === "*") {
+    return { every: minuteStep, unit: "minutes" };
+  }
+  const hourStep = cronFieldStep(hour);
+  if (hourStep && isEvenDivisorStep(hourStep, 24) && minute === "0" && dom === "*") {
+    return { every: hourStep, unit: "hours" };
+  }
+  return;
+}
+function cronFieldStep(token) {
+  const match = token.match(/^\*\/(\d+)$/);
+  return match ? Number(match[1]) : undefined;
+}
+var DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function pad2(n) {
+  return n.toString().padStart(2, "0");
+}
+function isFixedInRange(token, min, max) {
+  if (!/^\d+$/.test(token))
+    return false;
+  const n = Number(token);
+  return Number.isInteger(n) && n >= min && n <= max;
+}
+function describeValue(value) {
+  if (value.mode === "interval") {
+    return value.every === 1 ? `Every ${singularUnit(value.unit)}` : `Every ${value.every} ${value.unit}`;
+  }
+  const [minute, hour, dom, month, dow] = splitCron(value.expression);
+  const timeIsFixed = isFixedInRange(minute, 0, 59) && isFixedInRange(hour, 0, 23);
+  const at = timeIsFixed ? ` at ${pad2(Number(hour))}:${pad2(Number(minute))}` : "";
+  if (timeIsFixed && dom === "*" && month === "*" && dow !== "*" && /^[\d,]+$/.test(dow)) {
+    const dayNumbers = dow.split(",").map(Number);
+    const allDaysInRange = dayNumbers.every((day) => Number.isInteger(day) && day >= 0 && day <= 6);
+    if (allDaysInRange) {
+      const names = dayNumbers.map((day) => DOW_NAMES[day] ?? "").join(", ");
+      return `Weekly on ${names}${at}`;
+    }
+  }
+  if (timeIsFixed && isFixedInRange(dom, 1, 31) && month === "*" && dow === "*") {
+    return `Monthly on day ${dom}${at}`;
+  }
+  if (dom === "*" && month === "*" && dow === "*" && timeIsFixed) {
+    return `Daily${at}`;
+  }
+  return `Cron: ${joinCron([minute, hour, dom, month, dow])}`;
+}
+
+// src/components/schedule-builder/schedule-builder.svelte
+function Schedule_builder($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const baseId = $.props_id($$renderer2);
+    const PRESET_EVERY_UNIT_OPTIONS = [
+      { value: "minutes", label: "Minutes" },
+      { value: "hours", label: "Hours" }
+    ];
+    const INTERVAL_UNIT_LABELS = {
+      minutes: "Minutes",
+      hours: "Hours",
+      days: "Days",
+      weeks: "Weeks"
+    };
+    const INTERVAL_UNIT_OPTIONS = INTERVAL_UNITS.map((unit) => ({ value: unit, label: INTERVAL_UNIT_LABELS[unit] }));
+    let {
+      value,
+      onchange,
+      computeNextFires,
+      previewCount = 5,
+      timezoneLabel,
+      timezone,
+      label = "Schedule",
+      class: className,
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledby,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const normalizedAriaLabel = $.derived(() => typeof ariaLabel === "string" && ariaLabel.trim().length > 0 ? ariaLabel : undefined);
+    const normalizedAriaLabelledby = $.derived(() => typeof ariaLabelledby === "string" && ariaLabelledby.trim().length > 0 ? ariaLabelledby : undefined);
+    const resolvedAriaLabel = $.derived(() => normalizedAriaLabelledby() === undefined && normalizedAriaLabel() === undefined ? label : normalizedAriaLabel());
+    const seedValue = value ?? defaultScheduleValue();
+    function scheduleValuesEqual(a, b) {
+      if (a.mode !== b.mode)
+        return false;
+      if (a.mode === "cron" && b.mode === "cron")
+        return a.expression === b.expression;
+      if (a.mode === "interval" && b.mode === "interval") {
+        return a.every === b.every && a.unit === b.unit;
+      }
+      return false;
+    }
+    function initialAuthoringMode(candidateValue) {
+      if (candidateValue === undefined)
+        return "presets";
+      if (candidateValue.mode === "cron")
+        return "cron";
+      return candidateValue.unit === "minutes" || candidateValue.unit === "hours" ? "presets" : "interval";
+    }
+    function seedFieldsFromValue(seededValue) {
+      const interval = valueToInterval(seededValue);
+      const isMinutesOrHours = interval !== undefined && (interval.unit === "minutes" || interval.unit === "hours");
+      return {
+        authoringMode: initialAuthoringMode(seededValue),
+        cronFields: valueToCronFields(seededValue),
+        intervalEvery: interval?.every ?? 15,
+        intervalUnit: interval?.unit ?? "minutes",
+        presetKind: "every",
+        presetEveryValue: isMinutesOrHours ? interval.every : 15,
+        presetEveryUnit: isMinutesOrHours ? interval.unit : "minutes",
+        presetDailyTime: "09:00",
+        presetWeeklyDays: [],
+        presetWeeklyTime: "09:00",
+        presetMonthlyDay: 1,
+        presetMonthlyTime: "09:00"
+      };
+    }
+    const initialSeed = seedFieldsFromValue(seedValue);
+    let authoringMode = initialSeed.authoringMode;
+    let presetKind = initialSeed.presetKind;
+    let cronFields = initialSeed.cronFields;
+    let intervalEvery = initialSeed.intervalEvery;
+    let intervalUnit = initialSeed.intervalUnit;
+    let presetEveryValue = initialSeed.presetEveryValue;
+    let presetEveryUnit = initialSeed.presetEveryUnit;
+    let presetDailyTime = initialSeed.presetDailyTime;
+    let presetWeeklyDays = initialSeed.presetWeeklyDays;
+    let presetWeeklyTime = initialSeed.presetWeeklyTime;
+    let presetMonthlyDay = initialSeed.presetMonthlyDay;
+    let presetMonthlyTime = initialSeed.presetMonthlyTime;
+    function valueForPresets() {
+      switch (presetKind) {
+        case "every":
+          return lowerEveryN(presetEveryValue, presetEveryUnit);
+        case "daily":
+          return lowerDailyAt(presetDailyTime);
+        case "weekly":
+          return lowerWeeklyAt(presetWeeklyDays, presetWeeklyTime);
+        case "monthly":
+          return lowerMonthlyOnDay(presetMonthlyDay, presetMonthlyTime);
+      }
+    }
+    function valueForMode(mode) {
+      if (mode === "cron")
+        return { mode: "cron", expression: joinCron(cronFields) };
+      if (mode === "interval")
+        return { mode: "interval", every: intervalEvery, unit: intervalUnit };
+      return valueForPresets();
+    }
+    const currentValue = $.derived(() => valueForMode(authoringMode));
+    const currentValueIsValid = $.derived(() => authoringMode !== "cron" || cronFieldsValid(cronFields));
+    const resolvedPreviewCount = $.derived(() => Number.isInteger(previewCount) && previewCount > 0 ? previewCount : 5);
+    const previewResult = $.derived(() => {
+      if (!computeNextFires)
+        return { status: "hidden" };
+      if (!currentValueIsValid())
+        return { status: "invalid" };
+      try {
+        return {
+          status: "ok",
+          fires: computeNextFires(currentValue(), resolvedPreviewCount())
+        };
+      } catch {
+        return { status: "error" };
+      }
+    });
+    let lastKnownValue = seedValue;
+    let previousValueProp = value;
+    function emitChange() {
+      lastKnownValue = currentValue();
+      onchange?.(currentValue());
+    }
+    function handleAuthoringModeChange(nextMode) {
+      if (nextMode === authoringMode)
+        return;
+      authoringMode = nextMode;
+      if (nextMode === "cron") {
+        cronFields = valueToCronFields(lastKnownValue);
+      } else if (nextMode === "interval") {
+        const interval = valueToInterval(lastKnownValue);
+        if (interval) {
+          intervalEvery = interval.every;
+          intervalUnit = interval.unit;
+        }
+      } else if (nextMode === "presets") {
+        const seed = seedFieldsFromValue(lastKnownValue);
+        presetKind = seed.presetKind;
+        presetEveryValue = seed.presetEveryValue;
+        presetEveryUnit = seed.presetEveryUnit;
+        presetDailyTime = seed.presetDailyTime;
+        presetWeeklyDays = seed.presetWeeklyDays;
+        presetWeeklyTime = seed.presetWeeklyTime;
+        presetMonthlyDay = seed.presetMonthlyDay;
+        presetMonthlyTime = seed.presetMonthlyTime;
+      }
+    }
+    function handlePresetKindChange(nextKind) {
+      if (nextKind === presetKind)
+        return;
+      presetKind = nextKind;
+      emitChange();
+    }
+    function handleCronFieldChange(index, raw) {
+      const next = [...cronFields];
+      next[index] = raw;
+      cronFields = next;
+      if (cronFieldsValid(next))
+        emitChange();
+    }
+    function toPositiveInteger(next) {
+      if (next === null || !Number.isFinite(next) || next < 1)
+        return 1;
+      return Math.trunc(next);
+    }
+    function handleIntervalEveryChange(next) {
+      intervalEvery = toPositiveInteger(next);
+      emitChange();
+    }
+    function handleIntervalUnitChange(event) {
+      intervalUnit = event.currentTarget.value;
+      emitChange();
+    }
+    function handlePresetEveryValueChange(next) {
+      presetEveryValue = toPositiveInteger(next);
+      emitChange();
+    }
+    function handlePresetEveryUnitChange(event) {
+      presetEveryUnit = event.currentTarget.value;
+      emitChange();
+    }
+    function acceptPresetTime(next, commit) {
+      if (!next)
+        return;
+      commit(next);
+      emitChange();
+    }
+    function handlePresetDailyTimeChange(next) {
+      acceptPresetTime(next, (time) => presetDailyTime = time);
+    }
+    function toggleWeeklyDay(day) {
+      presetWeeklyDays = presetWeeklyDays.includes(day) ? presetWeeklyDays.filter((existing) => existing !== day) : [...presetWeeklyDays, day];
+      emitChange();
+    }
+    function handlePresetWeeklyTimeChange(next) {
+      acceptPresetTime(next, (time) => presetWeeklyTime = time);
+    }
+    function handlePresetMonthlyDayChange(next) {
+      presetMonthlyDay = next && next >= 1 ? Math.min(31, Math.trunc(next)) : 1;
+      emitChange();
+    }
+    function handlePresetMonthlyTimeChange(next) {
+      acceptPresetTime(next, (time) => presetMonthlyTime = time);
+    }
+    const modeTabId = (mode) => `${baseId}-mode-${mode}-tab`;
+    const modePanelId = (mode) => `${baseId}-mode-${mode}-panel`;
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$.attributes({
+        ...rest,
+        class: $.clsx(classNames("cinder-schedule-builder", className)),
+        role: "group",
+        "aria-label": resolvedAriaLabel(),
+        "aria-labelledby": normalizedAriaLabelledby(),
+        "data-sb-mode": authoringMode
+      })}>`);
+      Segmented_control($$renderer3, {
+        id: `${baseId}-mode`,
+        label: "Schedule authoring mode",
+        variant: "tablist",
+        value: authoringMode,
+        onchange: handleAuthoringModeChange,
+        class: "cinder-schedule-builder__mode-switch",
+        children: ($$renderer4) => {
+          Segment($$renderer4, {
+            id: modeTabId("presets"),
+            value: "presets",
+            controls: modePanelId("presets"),
+            children: ($$renderer5) => {
+              $$renderer5.push(`<!---->Presets`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!----> `);
+          Segment($$renderer4, {
+            id: modeTabId("cron"),
+            value: "cron",
+            controls: modePanelId("cron"),
+            children: ($$renderer5) => {
+              $$renderer5.push(`<!---->Cron`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!----> `);
+          Segment($$renderer4, {
+            id: modeTabId("interval"),
+            value: "interval",
+            controls: modePanelId("interval"),
+            children: ($$renderer5) => {
+              $$renderer5.push(`<!---->Interval`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----> `);
+      if (authoringMode === "presets") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div${$.attr("id", modePanelId("presets"))} role="tabpanel"${$.attr("aria-labelledby", modeTabId("presets"))} class="cinder-schedule-builder__panel" data-sb-panel="presets">`);
+        Segmented_control($$renderer3, {
+          id: `${baseId}-preset-kind`,
+          label: "Preset kind",
+          value: presetKind,
+          onchange: handlePresetKindChange,
+          class: "cinder-schedule-builder__preset-kind",
+          children: ($$renderer4) => {
+            Segment($$renderer4, {
+              id: `${baseId}-preset-kind-every`,
+              value: "every",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Every N`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Segment($$renderer4, {
+              id: `${baseId}-preset-kind-daily`,
+              value: "daily",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Daily`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Segment($$renderer4, {
+              id: `${baseId}-preset-kind-weekly`,
+              value: "weekly",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Weekly`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Segment($$renderer4, {
+              id: `${baseId}-preset-kind-monthly`,
+              value: "monthly",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Monthly`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!---->`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!----> `);
+        if (presetKind === "every") {
+          $$renderer3.push("<!--[0-->");
+          var bind_get = () => presetEveryValue;
+          var bind_set = handlePresetEveryValueChange;
+          $$renderer3.push(`<div class="cinder-schedule-builder__field-row">`);
+          Number_input($$renderer3, {
+            id: `${baseId}-preset-every-value`,
+            label: "Every",
+            min: 1,
+            step: 1,
+            get value() {
+              return bind_get();
+            },
+            set value($$value) {
+              bind_set($$value);
+            }
+          });
+          $$renderer3.push(`<!----> `);
+          Select($$renderer3, {
+            id: `${baseId}-preset-every-unit`,
+            label: "Unit",
+            options: PRESET_EVERY_UNIT_OPTIONS,
+            value: presetEveryUnit,
+            onchange: handlePresetEveryUnitChange
+          });
+          $$renderer3.push(`<!----></div>`);
+        } else if (presetKind === "daily") {
+          $$renderer3.push("<!--[1-->");
+          var bind_get_1 = () => presetDailyTime;
+          var bind_set_1 = handlePresetDailyTimeChange;
+          Time_field($$renderer3, {
+            id: `${baseId}-preset-daily-time`,
+            label: "At",
+            get value() {
+              return bind_get_1();
+            },
+            set value($$value) {
+              bind_set_1($$value);
+            }
+          });
+        } else if (presetKind === "weekly") {
+          $$renderer3.push("<!--[2-->");
+          var bind_get_2 = () => presetWeeklyTime;
+          var bind_set_2 = handlePresetWeeklyTimeChange;
+          $$renderer3.push(`<div class="cinder-schedule-builder__weekday-group" role="group" aria-label="Days of week"><!--[-->`);
+          const each_array = $.ensure_array_like(WEEKDAYS);
+          for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+            let day = each_array[$$index];
+            Chip($$renderer3, {
+              mode: "toggle",
+              label: day.short,
+              "aria-label": day.long,
+              pressed: presetWeeklyDays.includes(day.value),
+              onpressedchange: () => toggleWeeklyDay(day.value)
+            });
+          }
+          $$renderer3.push(`<!--]--></div> `);
+          Time_field($$renderer3, {
+            id: `${baseId}-preset-weekly-time`,
+            label: "At",
+            get value() {
+              return bind_get_2();
+            },
+            set value($$value) {
+              bind_set_2($$value);
+            }
+          });
+          $$renderer3.push(`<!---->`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          var bind_get_3 = () => presetMonthlyDay;
+          var bind_set_3 = handlePresetMonthlyDayChange;
+          var bind_get_4 = () => presetMonthlyTime;
+          var bind_set_4 = handlePresetMonthlyTimeChange;
+          $$renderer3.push(`<div class="cinder-schedule-builder__field-row">`);
+          Number_input($$renderer3, {
+            id: `${baseId}-preset-monthly-day`,
+            label: "Day of month",
+            min: 1,
+            max: 31,
+            get value() {
+              return bind_get_3();
+            },
+            set value($$value) {
+              bind_set_3($$value);
+            }
+          });
+          $$renderer3.push(`<!----> `);
+          Time_field($$renderer3, {
+            id: `${baseId}-preset-monthly-time`,
+            label: "At",
+            get value() {
+              return bind_get_4();
+            },
+            set value($$value) {
+              bind_set_4($$value);
+            }
+          });
+          $$renderer3.push(`<!----></div>`);
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      } else if (authoringMode === "cron") {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`<div${$.attr("id", modePanelId("cron"))} role="tabpanel"${$.attr("aria-labelledby", modeTabId("cron"))} class="cinder-schedule-builder__panel" data-sb-panel="cron"><div class="cinder-schedule-builder__cron-fields"><!--[-->`);
+        const each_array_1 = $.ensure_array_like(CRON_FIELDS);
+        for (let index = 0, $$length = each_array_1.length;index < $$length; index++) {
+          let field = each_array_1[index];
+          const fieldError = validateCronField(cronFields[index] ?? "*", index);
+          var bind_get_5 = () => cronFields[index] ?? "*";
+          var bind_set_5 = (next) => handleCronFieldChange(index, next);
+          Input($$renderer3, $.spread_props([
+            {
+              id: `${baseId}-cron-field-${index}`,
+              label: field.name,
+              description: field.hint,
+              get value() {
+                return bind_get_5();
+              },
+              set value($$value) {
+                bind_set_5($$value);
+              }
+            },
+            fieldError ? { error: fieldError } : {}
+          ]));
+        }
+        $$renderer3.push(`<!--]--></div></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        var bind_get_6 = () => intervalEvery;
+        var bind_set_6 = handleIntervalEveryChange;
+        $$renderer3.push(`<div${$.attr("id", modePanelId("interval"))} role="tabpanel"${$.attr("aria-labelledby", modeTabId("interval"))} class="cinder-schedule-builder__panel" data-sb-panel="interval"><div class="cinder-schedule-builder__field-row">`);
+        Number_input($$renderer3, {
+          id: `${baseId}-interval-every`,
+          label: "Every",
+          min: 1,
+          step: 1,
+          get value() {
+            return bind_get_6();
+          },
+          set value($$value) {
+            bind_set_6($$value);
+          }
+        });
+        $$renderer3.push(`<!----> `);
+        Select($$renderer3, {
+          id: `${baseId}-interval-unit`,
+          label: "Unit",
+          options: INTERVAL_UNIT_OPTIONS,
+          value: intervalUnit,
+          onchange: handleIntervalUnitChange
+        });
+        $$renderer3.push(`<!----></div></div>`);
+      }
+      $$renderer3.push(`<!--]--> <dl class="cinder-schedule-builder__summary"><dt class="cinder-schedule-builder__section-label">Summary</dt> <dd class="cinder-schedule-builder__summary-text">${$.escape(describeValue(currentValue()))}</dd></dl> `);
+      if (previewResult().status !== "hidden") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div class="cinder-schedule-builder__preview"><span class="cinder-schedule-builder__section-label"${$.attr("id", `${baseId}-preview-label`)}>Upcoming fires</span> `);
+        if (previewResult().status === "invalid") {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<p class="cinder-schedule-builder__empty">Preview unavailable — fix the cron expression above.</p>`);
+        } else if (previewResult().status === "error") {
+          $$renderer3.push("<!--[1-->");
+          $$renderer3.push(`<p class="cinder-schedule-builder__empty">Preview unavailable.</p>`);
+        } else if (previewResult().fires.length > 0) {
+          $$renderer3.push("<!--[2-->");
+          $$renderer3.push(`<ul class="cinder-schedule-builder__preview-list"${$.attr("aria-labelledby", `${baseId}-preview-label`)}><!--[-->`);
+          const each_array_2 = $.ensure_array_like(previewResult().fires);
+          for (let $$index_2 = 0, $$length = each_array_2.length;$$index_2 < $$length; $$index_2++) {
+            let fire = each_array_2[$$index_2];
+            $$renderer3.push(`<li class="cinder-schedule-builder__preview-item">${$.escape(fire.label)}</li>`);
+          }
+          $$renderer3.push(`<!--]--></ul>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<p class="cinder-schedule-builder__empty">No upcoming fires.</p>`);
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> <dl class="cinder-schedule-builder__timezone"><dt class="cinder-schedule-builder__section-label">Timezone</dt> <dd class="cinder-schedule-builder__timezone-value">`);
+      if (timezone) {
+        $$renderer3.push("<!--[0-->");
+        timezone($$renderer3);
+        $$renderer3.push(`<!---->`);
+      } else if (timezoneLabel) {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`${$.escape(timezoneLabel)}`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<span class="cinder-schedule-builder__empty">Not set</span>`);
+      }
+      $$renderer3.push(`<!--]--></dd></dl></div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+  }, Schedule_builder);
+}
+
+// src/components/schedule-builder/index.ts
+var schedule_builder_default = Schedule_builder;
+export { Schedule_builder, schedule_builder_default };
+
+//# debugId=302BB8070B07926364756E2164756E21