@marktiderman/genesis-forms-studio 0.0.0-stage → 0.2.0

package/dist/chunk-HAEZ7G3G.js

@@ -0,0 +1,705 @@
+import { summarizeValue, isOtherValue, otherOption, choiceOptions } from '@marktiderman/genesis-forms';
+
+// src/answers.ts
+function carryAnswers(from, to, answers, extra = {}) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const block of from.blocks) {
+    if (block.kind === "field" && answers[block.id] !== void 0)
+      byKey.set(block.key, answers[block.id]);
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== null && value !== void 0 && !byKey.has(key)) byKey.set(key, value);
+  }
+  const out = {};
+  for (const block of to.blocks) {
+    if (block.kind === "field" && byKey.has(block.key)) out[block.id] = byKey.get(block.key);
+  }
+  return out;
+}
+function answerCell(field, value) {
+  if (value === void 0 || value === null) return "";
+  if (field.type === "yes-no")
+    return value === true ? "Yes" : value === false ? "No" : String(value);
+  if (field.type === "consent")
+    return value === true ? "Agreed" : value === false ? "Didn't agree" : String(value);
+  const options = Array.isArray(field.props?.["options"]) ? field.props["options"] : [];
+  const label = (v) => options.find((o) => o.value === v)?.label ?? String(v);
+  const structured = Array.isArray(value) ? value.some((v) => v !== null && typeof v === "object") : typeof value === "object";
+  if (structured) {
+    const summary = summarizeValue(value, field);
+    return summary && !summary.includes("[object Object]") ? summary : JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return value.map(label).join(", ");
+  if (options.length) return label(value);
+  return typeof value === "number" || typeof value === "boolean" ? value : String(value);
+}
+var plainLabel = (label) => label.replace(/\{\{[^}|]*\|?([^}]*)\}\}/g, (_, fallback) => fallback || "\u2026");
+function answerColumns(definitions, skip = /* @__PURE__ */ new Set()) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    for (const block of definition.blocks) {
+      if (block.kind !== "field" || seen.has(block.key) || skip.has(block.key)) continue;
+      seen.add(block.key);
+      columns.push({ key: block.key, label: plainLabel(block.label) });
+    }
+  }
+  return columns;
+}
+function answersByKey(definition, answers) {
+  const cells = {};
+  for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    const value = answers[block.id];
+    if (value !== void 0) cells[block.key] = answerCell(block, value);
+  }
+  return cells;
+}
+function valuesByKey(definition, answers) {
+  const values = /* @__PURE__ */ new Map();
+  for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    const value = answers[block.id];
+    if (value !== void 0 && value !== null) values.set(block.key, { field: block, value });
+  }
+  return values;
+}
+function toCsv(header, rows) {
+  const quote = (v) => {
+    const raw = String(v);
+    const s = typeof v === "string" && /^[=+\-@\t\r]/.test(raw) ? `'${raw}` : raw;
+    return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  return [header, ...rows].map((r) => r.map(quote).join(",")).join("\r\n") + "\r\n";
+}
+var STATUS_FILTER_LABEL = {
+  counted: "Sent and partial",
+  completed: "Sent",
+  partial: "Partial",
+  in_progress: "In progress"
+};
+var RESPONSE_STATUS_LABEL = {
+  in_progress: "In progress",
+  partial: "Partial",
+  completed: "Sent"
+};
+function matchesStatus(item, filter = "counted") {
+  const status = item.status ?? "completed";
+  return filter === "counted" ? status !== "in_progress" : status === filter;
+}
+var CHOICE_TYPES = /* @__PURE__ */ new Set([
+  "single-choice",
+  "multi-choice",
+  "dropdown",
+  "yes-no",
+  "consent"
+]);
+var YES_NO = [
+  { value: "true", label: "Yes" },
+  { value: "false", label: "No" }
+];
+var CONSENT = [
+  { value: "true", label: "Agreed" },
+  { value: "false", label: "Didn't agree" }
+];
+var OTHER_BUCKET = "__other__";
+var optionsOf = (field) => field.type === "yes-no" ? YES_NO : field.type === "consent" ? CONSENT : choiceOptions(field).map((o) => ({ value: o.value, label: o.label ?? o.value }));
+var ratingMax = (field) => {
+  const max = field.props?.["max"];
+  return typeof max === "number" && Number.isInteger(max) && max >= 1 && max <= 100 ? max : 5;
+};
+var scaleOf = (field) => field.type === "nps" ? { min: 0, max: 10 } : field.type === "rating" ? { min: 1, max: ratingMax(field) } : null;
+var newestFirst = (items) => items.map((item, index) => ({ item, index })).sort(
+  (x, y) => x.item.date < y.item.date ? 1 : x.item.date > y.item.date ? -1 : x.index - y.index
+).map((x) => x.item);
+function summarizeResponses(items, definitions, skip = /* @__PURE__ */ new Set()) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    for (const block of definition.blocks) {
+      if (block.kind === "field" && !newest.has(block.key)) newest.set(block.key, block);
+    }
+  }
+  const answered = newestFirst(items).map((item) => ({
+    item,
+    values: valuesByKey(item.definition, item.answers),
+    cells: answersByKey(item.definition, item.answers)
+  }));
+  return answerColumns(definitions, skip).flatMap((column) => {
+    const field = newest.get(column.key);
+    if (!field) return [];
+    const { key, label } = column;
+    if (field.type === "rating" || field.type === "nps") {
+      const nps = field.type === "nps";
+      const min = nps ? 0 : 1;
+      const max = nps ? 10 : ratingMax(field);
+      const counts = new Array(max - min + 1).fill(0);
+      let count = 0;
+      let sum = 0;
+      let promoters = 0;
+      let detractors = 0;
+      let rescaled = 0;
+      let excluded = 0;
+      for (const { values } of answered) {
+        const answer = values.get(key);
+        if (!answer) continue;
+        const v = answer.value;
+        const own = scaleOf(answer.field);
+        if (!own || typeof v !== "number" || !Number.isInteger(v) || v < own.min || v > own.max) {
+          excluded++;
+          continue;
+        }
+        let x = v;
+        if (own.min !== min || own.max !== max) {
+          x = own.max === own.min ? max : min + (v - own.min) * (max - min) / (own.max - own.min);
+          rescaled++;
+        }
+        const point = Math.round(x);
+        counts[point - min] += 1;
+        count++;
+        sum += x;
+        if (point >= 9) promoters++;
+        else if (point <= 6) detractors++;
+      }
+      return [
+        {
+          kind: "scale",
+          key,
+          label,
+          type: field.type,
+          fieldType: field.type,
+          count,
+          min,
+          max,
+          average: count ? sum / count : null,
+          buckets: counts.map((c, i) => ({ value: min + i, count: c })),
+          rescaled,
+          excluded,
+          nps: nps && count ? {
+            promoters,
+            passives: count - promoters - detractors,
+            detractors,
+            score: Math.round((promoters - detractors) / count * 100)
+          } : null
+        }
+      ];
+    }
+    if (CHOICE_TYPES.has(field.type)) {
+      const options = optionsOf(field).map((o) => ({ ...o, count: 0 }));
+      const find = (value, from) => {
+        if (isOtherValue(from, value) && !options.some((o) => o.value === value)) {
+          value = OTHER_BUCKET;
+          let bucket = options.find((o) => o.value === OTHER_BUCKET);
+          if (!bucket) {
+            bucket = { value: OTHER_BUCKET, label: (otherOption(field) ?? otherOption(from)).label, count: 0 };
+            options.push(bucket);
+          }
+          return bucket;
+        }
+        let option = options.find((o) => o.value === value);
+        if (!option) {
+          const old = optionsOf(from).find((o) => o.value === value);
+          option = { value, label: old?.label ?? value, count: 0 };
+          options.push(option);
+        }
+        return option;
+      };
+      let count = 0;
+      for (const { values } of answered) {
+        const answer = values.get(key);
+        if (!answer) continue;
+        const chosen = (Array.isArray(answer.value) ? answer.value : [answer.value]).filter(
+          (v) => typeof v === "string" || typeof v === "boolean"
+        );
+        if (!chosen.length) continue;
+        count++;
+        for (const v of new Set(chosen.map(String))) find(v, answer.field).count++;
+      }
+      return [
+        {
+          kind: "choice",
+          key,
+          label,
+          fieldType: field.type,
+          count,
+          multiple: field.type === "multi-choice",
+          options: options.map((o) => ({ ...o, percent: count ? o.count / count * 100 : 0 }))
+        }
+      ];
+    }
+    const answers = answered.flatMap(({ item, cells }) => {
+      const text = String(cells[key] ?? "").trim();
+      return text ? [{ id: item.id, date: item.date, text }] : [];
+    });
+    return [{ kind: "text", key, label, fieldType: field.type, count: answers.length, answers }];
+  });
+}
+function highestRating(definitions) {
+  let max = null;
+  for (const definition of definitions) {
+    for (const block of definition.blocks) {
+      if (block.kind === "field" && block.type === "rating")
+        max = Math.max(max ?? 0, ratingMax(block));
+    }
+  }
+  return max;
+}
+function lowestRating(item) {
+  let lowest = null;
+  for (const { field, value } of valuesByKey(item.definition, item.answers).values()) {
+    if (field.type === "rating" && typeof value === "number" && (lowest === null || value < lowest))
+      lowest = value;
+  }
+  return lowest;
+}
+var LOW_SHARE = 0.4;
+var NPS_LOW = 6;
+function lowRatingAtMost(field) {
+  if (field.type === "nps") return NPS_LOW;
+  if (field.type !== "rating") return null;
+  return lowScaleAtMost("rating", ratingMax(field));
+}
+function lowScaleAtMost(type, max) {
+  return type === "nps" ? NPS_LOW : Math.max(1, Math.floor(max * LOW_SHARE));
+}
+function hasLowRating(item) {
+  return hasLowRatingExcept(item, /* @__PURE__ */ new Set());
+}
+function hasLowRatingExcept(item, skip) {
+  for (const [key, { field, value }] of valuesByKey(item.definition, item.answers)) {
+    if (skip.has(key)) continue;
+    const atMost = lowRatingAtMost(field);
+    if (atMost !== null && typeof value === "number" && value <= atMost) return true;
+  }
+  return false;
+}
+function lowRatingLabel(definitions) {
+  const scales = /* @__PURE__ */ new Set();
+  let nps = false;
+  for (const definition of definitions) {
+    for (const block of definition.blocks) {
+      if (block.kind !== "field") continue;
+      if (block.type === "nps") nps = true;
+      else if (block.type === "rating") scales.add(ratingMax(block));
+    }
+  }
+  const several = scales.size + (nps ? 1 : 0) > 1;
+  const parts = [...scales].sort((a, b) => a - b).map((max) => {
+    const atMost = Math.max(1, Math.floor(max * LOW_SHARE));
+    return several ? `${atMost} or below out of ${max}` : `${atMost} or below`;
+  });
+  if (nps) parts.push(several ? `0\u2013${NPS_LOW} on NPS` : `0\u2013${NPS_LOW}`);
+  return parts.length ? parts.join(", ") : null;
+}
+function isFiltered(filter) {
+  return Boolean(
+    filter.from || filter.to || filter.ratingAtMost != null || filter.low || filter.status && filter.status !== "counted" || Object.values(filter.match ?? {}).some((v) => v != null && v !== "")
+  );
+}
+function filterResponses(items, filter) {
+  const match = Object.entries(filter.match ?? {}).filter(
+    (e) => e[1] != null && e[1] !== ""
+  );
+  return items.filter((item) => {
+    if (!matchesStatus(item, filter.status)) return false;
+    if (filter.from && item.date < filter.from) return false;
+    if (filter.to && item.date > filter.to) return false;
+    if (match.some(([key, value]) => String(item.extra?.[key] ?? "") !== value)) return false;
+    if (filter.ratingAtMost != null) {
+      const lowest = lowestRating(item);
+      if (lowest === null || lowest > filter.ratingAtMost) return false;
+    }
+    if (filter.low && !hasLowRating(item)) return false;
+    return true;
+  });
+}
+var addDays = (day, n) => {
+  const t = Date.parse(`${day}T00:00:00Z`) + n * 864e5;
+  return new Date(t).toISOString().slice(0, 10);
+};
+function presetRange(preset, today) {
+  switch (preset) {
+    case "all":
+      return { from: null, to: null };
+    case "today":
+      return { from: today, to: today };
+    case "week": {
+      const weekday = (/* @__PURE__ */ new Date(`${today}T00:00:00Z`)).getUTCDay();
+      return { from: addDays(today, -((weekday + 6) % 7)), to: today };
+    }
+    case "7d":
+      return { from: addDays(today, -6), to: today };
+    case "30d":
+      return { from: addDays(today, -29), to: today };
+    case "month":
+      return { from: `${today.slice(0, 7)}-01`, to: today };
+  }
+}
+var NO_FILTERS = {
+  when: "all",
+  from: "",
+  to: "",
+  match: {},
+  ratingAtMost: null,
+  low: false
+};
+function toResponseFilter(value, today) {
+  const range = value.when === "custom" ? { from: value.from || null, to: value.to || null } : presetRange(value.when, today);
+  return {
+    ...range,
+    match: value.match,
+    ratingAtMost: value.ratingAtMost,
+    low: value.low,
+    ...value.status ? { status: value.status } : {}
+  };
+}
+var lowThisWeek = (value) => ({
+  ...value,
+  when: "week",
+  low: true
+});
+
+// src/headline.ts
+function headlineNumbers(items, definitions, options = {}) {
+  const previous = options.previous ?? null;
+  const summaries = summarizeResponses(items, definitions, options.skip);
+  const partial = items.filter((i) => i.status === "partial").length;
+  const before = previous ? summarizeResponses(previous, definitions, options.skip) : null;
+  const scale = summaries.find((s) => s.kind === "scale" && s.type === "rating");
+  let rating = null;
+  if (scale && scale.kind === "scale") {
+    const old = before?.find((s) => s.kind === "scale" && s.key === scale.key);
+    const previousAverage = old && old.kind === "scale" ? old.average : null;
+    rating = {
+      key: scale.key,
+      label: scale.label,
+      max: scale.max,
+      average: scale.average,
+      previousAverage,
+      change: scale.average !== null && previousAverage !== null ? Math.round((scale.average - previousAverage) * 10) / 10 : null
+    };
+  }
+  const scored = summaries.some((s) => s.kind === "scale");
+  const choice = summaries.find((s) => s.kind === "choice" && s.fieldType === "consent") ?? summaries.find((s) => s.kind === "choice" && s.fieldType === "yes-no");
+  let rate = null;
+  if (choice && choice.kind === "choice") {
+    const yes = choice.options.find((o) => o.value === "true")?.count ?? 0;
+    rate = {
+      key: choice.key,
+      label: choice.label,
+      type: choice.fieldType,
+      yes,
+      count: choice.count,
+      percent: choice.count ? Math.round(yes / choice.count * 100) : null
+    };
+  }
+  return {
+    responses: {
+      count: items.length,
+      previous: previous ? previous.length : null,
+      change: previous ? items.length - previous.length : null,
+      ...partial ? { partial } : {}
+    },
+    rating,
+    // The same skip as needsFollowUp, so the Low ratings card and the follow-up list agree.
+    low: scored ? { count: items.filter((i) => hasLowRatingExcept(i, options.skip ?? /* @__PURE__ */ new Set())).length } : null,
+    rate
+  };
+}
+var addDays2 = (day, n) => new Date(Date.parse(`${day}T00:00:00Z`) + n * 864e5).toISOString().slice(0, 10);
+var daysBetween = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 864e5);
+function comparisonFilter(value, today) {
+  const range = value.when === "custom" ? { from: value.from || null, to: value.to || null } : presetRange(value.when, today);
+  if (!range.from || !range.to || range.to < range.from) return null;
+  let from;
+  let to;
+  if (value.when === "month") {
+    const first = `${range.from.slice(0, 7)}-01`;
+    const lastMonth = addDays2(first, -1);
+    from = `${lastMonth.slice(0, 7)}-01`;
+    const day = Math.min(Number(range.to.slice(8, 10)), Number(lastMonth.slice(8, 10)));
+    to = `${lastMonth.slice(0, 7)}-${String(day).padStart(2, "0")}`;
+  } else if (value.when === "week") {
+    from = addDays2(range.from, -7);
+    to = addDays2(range.to, -7);
+  } else {
+    const length = daysBetween(range.from, range.to) + 1;
+    to = addDays2(range.from, -1);
+    from = addDays2(range.from, -length);
+  }
+  const label = value.when === "today" ? "yesterday" : value.when === "week" ? "last week" : value.when === "month" ? "last month" : value.when === "7d" ? "the 7 days before" : value.when === "30d" ? "the 30 days before" : "the days before";
+  return {
+    filter: {
+      from,
+      to,
+      match: value.match,
+      ratingAtMost: value.ratingAtMost,
+      low: value.low,
+      ...value.status ? { status: value.status } : {}
+    },
+    label
+  };
+}
+var signed = (n, digits = 0) => {
+  const s = Math.abs(n).toFixed(digits);
+  return n > 0 ? `+${s}` : n < 0 ? `\u2212${s}` : s;
+};
+function headlineCards(headline, options = {}) {
+  const cards = [];
+  const { responses, rating, low, rate } = headline;
+  const partial = responses.partial ? `${responses.partial} partial` : null;
+  cards.push({
+    key: "responses",
+    label: "Responses",
+    value: responses.count,
+    ...responses.change !== null && options.period ? {
+      detail: (responses.change === 0 ? `Same as ${options.period}` : `${signed(responses.change)} vs ${options.period}`) + (partial ? ` \xB7 ${partial}` : ""),
+      tone: responses.change > 0 ? "positive" : responses.change < 0 ? "negative" : "muted"
+    } : partial ? { detail: `Including ${partial}` } : {}
+  });
+  if (rating) {
+    const change = rating.change;
+    cards.push({
+      key: "rating",
+      label: "Average rating",
+      value: rating.average === null ? "\u2013" : `${rating.average.toFixed(1)} / ${rating.max}`,
+      ...change !== null && options.period ? {
+        detail: change === 0 ? `Same as ${options.period}` : `${change > 0 ? "Up" : "Down"} ${Math.abs(change).toFixed(1)}`,
+        tone: change > 0 ? "positive" : change < 0 ? "warning" : "muted"
+      } : rating.average === null ? { detail: "No ratings yet" } : {}
+    });
+  }
+  if (low) {
+    const open = options.lowOpen ?? low.count;
+    cards.push({
+      key: "low",
+      label: "Low ratings",
+      value: low.count,
+      ...open ? { detail: open === 1 ? "Needs a follow-up" : `${open} need a follow-up`, tone: "negative" } : { detail: low.count ? "All followed up" : "None" }
+    });
+  }
+  if (rate) {
+    cards.push({
+      key: "rate",
+      label: rate.label || (rate.type === "consent" ? "Agreed" : "Yes"),
+      value: rate.percent === null ? "\u2013" : `${rate.percent}%`,
+      detail: rate.count ? `${rate.yes} of ${rate.count} ${rate.type === "consent" ? "agreed" : "said yes"}` : "No answers yet"
+    });
+  }
+  return cards;
+}
+
+// src/dropoff.ts
+function dropOffByQuestion(items, definitions, skip = /* @__PURE__ */ new Set()) {
+  const views = /* @__PURE__ */ new Map();
+  const stopped = /* @__PURE__ */ new Map();
+  const add = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+  for (const item of items) {
+    const status = item.status ?? "completed";
+    if (status === "in_progress") continue;
+    const keys = item.definition.blocks.flatMap((b) => b.kind === "field" ? [{ id: b.id, key: b.key }] : []);
+    if (status === "completed") {
+      for (const { key } of keys) add(views, key);
+      continue;
+    }
+    const at = item.furthest ? keys.findIndex((k) => k.id === item.furthest) : -1;
+    if (at < 0) continue;
+    for (const { key } of keys.slice(0, at + 1)) add(views, key);
+    add(stopped, keys[at].key);
+  }
+  return answerColumns(definitions, skip).map(({ key, label }) => {
+    const reached = views.get(key) ?? 0;
+    const left = stopped.get(key) ?? 0;
+    return {
+      key,
+      label,
+      views: reached,
+      stopped: left,
+      dropOff: reached ? Math.round(left / reached * 100) : null
+    };
+  });
+}
+
+// src/followups.ts
+var TEXT_TYPES = /* @__PURE__ */ new Set(["long-text", "short-text", "text"]);
+var scaleMax = (type, props) => type === "nps" ? 10 : typeof props?.["max"] === "number" ? props["max"] : 5;
+function followUpOf(item, skip = /* @__PURE__ */ new Set()) {
+  let rating = null;
+  let comment = null;
+  for (const [key, { field, value }] of valuesByKey(item.definition, item.answers)) {
+    if (skip.has(key)) continue;
+    const atMost = lowRatingAtMost(field);
+    if (atMost !== null && typeof value === "number" && value <= atMost) {
+      const max = scaleMax(field.type, field.props);
+      if (!rating || value / max < rating.value / rating.max)
+        rating = { value, max, type: field.type };
+    } else if (comment === null && TEXT_TYPES.has(field.type)) {
+      const text = String(answerCell(field, value)).trim();
+      if (text) comment = text;
+    }
+  }
+  return rating ? { item, rating, comment } : null;
+}
+function needsFollowUp(items, options = {}) {
+  return items.map((item, index) => ({ index, f: options.isHandled?.(item) ? null : followUpOf(item, options.skip) })).filter((x) => x.f !== null).sort(
+    (x, y) => x.f.item.date < y.f.item.date ? 1 : x.f.item.date > y.f.item.date ? -1 : x.index - y.index
+  ).map((x) => x.f);
+}
+
+// src/generic/days.ts
+var MONTH_DAY = new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+var MONTH_DAY_YEAR = new Intl.DateTimeFormat("en-US", {
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+  timeZone: "UTC"
+});
+function dayLabel(day, today) {
+  const t = Date.parse(`${day}T00:00:00Z`);
+  if (Number.isNaN(t)) return day;
+  if (today) {
+    const diff = Math.round((Date.parse(`${today}T00:00:00Z`) - t) / 864e5);
+    if (diff === 0) return "Today";
+    if (diff === 1) return "Yesterday";
+    if (day.slice(0, 4) !== today.slice(0, 4)) return MONTH_DAY_YEAR.format(t);
+  }
+  return MONTH_DAY.format(t);
+}
+
+// src/generic/share.ts
+var RELATIVE_BASE = "http://relative.invalid";
+function prefilledUrl(url, values) {
+  let absolute = true;
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    absolute = false;
+    u = new URL(url, RELATIVE_BASE);
+  }
+  for (const [k, v] of Object.entries(values)) if (v) u.searchParams.set(k, v);
+  if (absolute) return u.toString();
+  const path = url.startsWith("/") ? u.pathname : u.pathname.replace(/^\//, "");
+  return `${path}${u.search}${u.hash}`;
+}
+var attr = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function embedSnippet(url, title) {
+  return `<iframe src="${attr(url)}" title="${attr(title)}" width="100%" height="720" style="border:0;max-width:100%" loading="lazy"></iframe>`;
+}
+
+// src/availability.ts
+function isFull(form) {
+  if (form.full !== void 0) return form.full;
+  return form.responseCap != null && form.completedResponses != null && form.completedResponses >= form.responseCap;
+}
+var INSTANT = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})$/i;
+function parseInstant(value) {
+  const v = value.trim();
+  return INSTANT.test(v) ? Date.parse(v.replace(" ", "T")) : Number.NaN;
+}
+function formAvailability(form, at = /* @__PURE__ */ new Date()) {
+  if (form.status === "archived") return "archived";
+  if (form.status === "draft" || form.published === false) return "draft";
+  if (form.paused) return "paused";
+  const t = at.getTime();
+  if (form.opensAt) {
+    const opens = parseInstant(form.opensAt);
+    if (Number.isNaN(opens)) return "closed";
+    if (t < opens) return "scheduled";
+  }
+  if (form.closesAt) {
+    const closes = parseInstant(form.closesAt);
+    if (Number.isNaN(closes) || t >= closes) return "closed";
+  }
+  if (isFull(form)) return "full";
+  return "live";
+}
+function takesResponses(form, at = /* @__PURE__ */ new Date()) {
+  return formAvailability(form, at) === "live";
+}
+
+// src/status.ts
+function formStatusChip(availability, version) {
+  const v = version ? ` \xB7 version ${version}` : "";
+  switch (availability) {
+    case "live":
+      return { label: `Live${v}`, tone: "success" };
+    case "draft":
+      return { label: "Draft", tone: "muted" };
+    case "paused":
+      return { label: `Paused${v}`, tone: "warning" };
+    case "scheduled":
+      return { label: `Scheduled${v}`, tone: "info" };
+    case "closed":
+      return { label: `Closed${v}`, tone: "muted" };
+    case "full":
+      return { label: `Full${v}`, tone: "warning" };
+    case "archived":
+      return { label: "Archived", tone: "muted" };
+  }
+}
+function formCounts(definition) {
+  if (!definition) return { questions: 0, logic: 0 };
+  return {
+    questions: definition.blocks.filter((b) => b.kind === "field").length,
+    logic: (definition.logic?.length ?? 0) + (definition.endings?.length ?? 0)
+  };
+}
+function formNavItems(at, counts = {}, icons) {
+  const to = typeof at === "function" ? at : (tab) => tab === "questions" ? at : `${at}?tab=${tab}`;
+  const item = (id, label, badge) => {
+    const icon = icons?.[id];
+    return {
+      id,
+      to: to(id),
+      label,
+      ...badge == null ? {} : { badge },
+      ...icon ? { icon } : {}
+    };
+  };
+  return [
+    item("questions", "Questions", counts.questions),
+    item("logic", "Logic and endings", counts.logic),
+    item("responses", "Responses", counts.responses),
+    item("settings", "Settings")
+  ];
+}
+
+// src/generic/status.ts
+var SAVE_STATE_LABEL = {
+  saved: "Changes saved",
+  saving: "Saving\u2026",
+  unsaved: "Unsaved changes",
+  failed: "Couldn't save; trying again",
+  stopped: "Couldn't save",
+  conflict: "Changed elsewhere; reload"
+};
+function readinessOf(findings, options = {}) {
+  if (findings.some((f) => f.code === "no-questions")) return { state: "empty", count: 0 };
+  const errors = findings.filter((f) => f.level === "error").length;
+  if (errors) return { state: "problems", count: errors };
+  if (options.pending) return { state: "pending", count: 0 };
+  const warnings = findings.filter((f) => f.level === "warning").length;
+  if (warnings) return { state: "warnings", count: warnings };
+  return { state: "ready", count: 0 };
+}
+function readinessChip(readiness) {
+  switch (readiness.state) {
+    case "ready":
+      return { label: "Ready to publish", tone: "success" };
+    case "empty":
+      return { label: "Add a question", tone: "muted" };
+    case "pending":
+      return { label: "In progress", tone: "muted" };
+    case "problems":
+      return {
+        label: `${readiness.count} ${readiness.count === 1 ? "problem" : "problems"} to fix`,
+        tone: "danger"
+      };
+    case "warnings":
+      return { label: `${readiness.count} to check`, tone: "warning" };
+  }
+}
+
+export { NO_FILTERS, RESPONSE_STATUS_LABEL, SAVE_STATE_LABEL, STATUS_FILTER_LABEL, answerCell, answerColumns, answersByKey, carryAnswers, comparisonFilter, dayLabel, dropOffByQuestion, embedSnippet, filterResponses, followUpOf, formAvailability, formCounts, formNavItems, formStatusChip, hasLowRating, hasLowRatingExcept, headlineCards, headlineNumbers, highestRating, isFiltered, isFull, lowRatingAtMost, lowRatingLabel, lowScaleAtMost, lowThisWeek, lowestRating, matchesStatus, needsFollowUp, parseInstant, plainLabel, prefilledUrl, presetRange, readinessChip, readinessOf, summarizeResponses, takesResponses, toCsv, toResponseFilter, valuesByKey };
+//# sourceMappingURL=chunk-HAEZ7G3G.js.map
+//# sourceMappingURL=chunk-HAEZ7G3G.js.map