gtfs-garage-web 0.0.1

package/dist/mount-Bpr3Nw4_.js

@@ -0,0 +1,1064 @@
+var B = Object.defineProperty;
+var z = (n, e, t) => e in n ? B(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var b = (n, e, t) => z(n, typeof e != "symbol" ? e + "" : e, t);
+function j(n) {
+  return {
+    el(e) {
+      const t = n.querySelector(`[data-el="${CSS.escape(e)}"]`);
+      if (!t) throw new Error(`Missing element ${e}`);
+      return t;
+    }
+  };
+}
+function I(n, e, t) {
+  const s = document.createElement("button");
+  return s.textContent = n, s.title = e, s.addEventListener("click", t), s;
+}
+const G = { load: !0, report: !0, map: !0 }, Y = (n) => `
+  <header>
+    <h1>GTFS Garage</h1>
+    <div data-el="source-label">No feed loaded</div>
+    ${n.report ? '<button data-el="metrics-btn" title="What this feed cost to open" hidden></button>' : ""}
+    ${n.map ? '<button data-el="toggle-map-btn">Hide map</button>' : ""}
+    ${n.load ? '<button data-el="open-load-btn">Load feed</button>' : ""}
+  </header>`, J = () => `
+  <div data-el="metrics-panel" class="hidden">
+    <div data-el="metrics-header">
+      <strong>Load report</strong>
+      <button data-el="metrics-close-btn" title="Close">&times;</button>
+    </div>
+    <div data-el="metrics-body"></div>
+  </div>`, K = (n) => `
+  <div data-el="layout">
+    <div data-el="sidebar"></div>
+    <div data-el="content">
+      <div data-el="table-pane">
+        <div data-el="filter-bar">
+          <button data-el="back-btn" title="Back to the previous view" disabled>&larr; Back</button>
+          <button data-el="add-filter-btn">+ Filter</button>
+          <label data-el="raw-values" class="raw-toggle"
+                 title="Show the characters the feed contains, without formatting">
+            <input data-el="raw-values-input" type="checkbox" /> Raw values
+          </label>
+        </div>
+        <div data-el="add-filter-form">
+          <select data-el="filter-column"></select>
+          <select data-el="filter-op">
+            <option value="eq">is</option>
+            <option value="ne">is not</option>
+            <option value="contains">contains</option>
+            <option value="in">is one of (comma sep.)</option>
+            <option value="is_empty">is empty</option>
+            <option value="is_not_empty">is not empty</option>
+          </select>
+          <input data-el="filter-value" type="text" placeholder="value" />
+          <select data-el="filter-value-picker" style="display:none"></select>
+          <button data-el="filter-apply-btn" class="primary">Add</button>
+          <button data-el="filter-cancel-btn">Cancel</button>
+        </div>
+        <div data-el="table-scroll">
+          <div data-el="empty-state">Load a GTFS feed to start browsing.</div>
+        </div>
+        <div data-el="pager" style="display:none">
+          <button data-el="prev-page">&laquo; Prev</button>
+          <span data-el="page-info"></span>
+          <button data-el="next-page">Next &raquo;</button>
+          <span class="spacer"></span>
+          <span data-el="row-count"></span>
+        </div>
+      </div>
+      ${n.map ? `<div data-el="map-pane">
+        <div data-el="map"></div>
+        <!-- Filled in while a layer streams; hidden the rest of the time. -->
+        <div data-el="map-progress" hidden></div>
+      </div>` : ""}
+    </div>
+  </div>`, W = () => `
+  <div data-el="load-overlay" class="hidden">
+    <div data-el="load-panel">
+      <h2>Load a GTFS feed</h2>
+      <div data-el="dropzone">Drop a GTFS .zip here, or click to choose one</div>
+      <input data-el="file-input" type="file" accept=".zip" style="display:none" />
+      <!-- webkitdirectory turns this into a folder chooser. -->
+      <input data-el="folder-input" type="file" webkitdirectory directory multiple style="display:none" />
+      <div data-el="pick-row">
+        <button data-el="pick-file-btn">Choose a .zip…</button>
+        <button data-el="pick-folder-btn">Choose a folder…</button>
+      </div>
+      <div class="or">or</div>
+      <label class="field-label">Local path or URL</label>
+      <input
+        data-el="path-input"
+        type="text"
+        autocomplete="off"
+        spellcheck="false"
+        placeholder="/path/to/feed.zip, /path/to/extracted/folder, or https://example.org/gtfs.zip"
+      />
+      <div data-el="load-actions">
+        <button data-el="load-path-btn" class="primary" disabled>Load</button>
+        <button data-el="load-cancel-btn">Cancel</button>
+      </div>
+      <div data-el="load-status"></div>
+      <div data-el="load-error"></div>
+    </div>
+  </div>`;
+function X(n, e = {}) {
+  const t = { ...G, ...e };
+  n.classList.add("gtfs-viewer"), n.innerHTML = [
+    Y(t),
+    t.report ? J() : "",
+    K(t),
+    t.load ? W() : ""
+  ].join(`
+`);
+}
+function Z(n) {
+  const e = n.split(`
+`), t = e.pop() ?? "";
+  return { lines: e.filter((s) => s.length > 0), rest: t };
+}
+async function Q(n, e) {
+  const t = n.getReader(), s = new TextDecoder();
+  let o = "";
+  for (; ; ) {
+    const { done: l, value: i } = await t.read();
+    if (l) break;
+    o += s.decode(i, { stream: !0 });
+    const { lines: r, rest: h } = Z(o);
+    o = h;
+    for (const d of r)
+      try {
+        e(JSON.parse(d));
+      } catch {
+      }
+  }
+  const a = o.trim();
+  if (a)
+    try {
+      e(JSON.parse(a));
+    } catch {
+    }
+}
+class D extends Error {
+  constructor(e, t) {
+    super(e), this.status = t;
+  }
+}
+async function m(n, e) {
+  const t = await fetch(n, e);
+  if (!t.ok) {
+    const s = await t.json().catch(() => ({}));
+    throw new D(
+      s.detail ?? `${t.status} ${t.statusText}`,
+      t.status
+    );
+  }
+  return t.json();
+}
+const ee = {
+  stops: "stop_ids",
+  shapes: "shape_ids",
+  routes: "shape_ids",
+  locations: "location_ids"
+};
+class te {
+  constructor(e = "") {
+    this.baseUrl = e;
+  }
+  config() {
+    return m(`${this.baseUrl}/api/config`);
+  }
+  tables() {
+    return m(`${this.baseUrl}/api/tables`);
+  }
+  query(e, t, s, o) {
+    const a = new URLSearchParams({
+      page: String(s),
+      page_size: String(o),
+      filters: JSON.stringify(t)
+    });
+    return m(
+      `${this.baseUrl}/api/table/${encodeURIComponent(e)}?${a}`
+    );
+  }
+  async distinct(e, t, s = 100) {
+    const { values: o } = await m(
+      `${this.baseUrl}/api/table/${encodeURIComponent(e)}/distinct/${encodeURIComponent(t)}?limit=${s}`
+    );
+    return o;
+  }
+  geojson(e, t) {
+    const s = new URLSearchParams();
+    for (const a of t ?? []) s.append(ee[e], a);
+    const o = s.toString();
+    return m(
+      `${this.baseUrl}/api/geojson/${e}${o ? `?${o}` : ""}`
+    );
+  }
+  loadProgress() {
+    return m(`${this.baseUrl}/api/load/progress`);
+  }
+  /**
+   * Stream a whole layer, one batch at a time.
+   *
+   * Used instead of `geojson` for the full-feed layers: a large feed runs to
+   * hundreds of MB, which is neither transferable nor parseable in one piece.
+   */
+  async geojsonStream(e, t, s) {
+    const o = await fetch(`${this.baseUrl}/api/geojson/${e}`, { signal: s });
+    if (!o.ok) {
+      const a = await o.json().catch(() => ({}));
+      throw new D(
+        a.detail ?? `${o.status} ${o.statusText}`,
+        o.status
+      );
+    }
+    if (!o.body) throw new Error("This browser cannot stream responses.");
+    await Q(o.body, t);
+  }
+  /**
+   * Load a feed: an uploaded zip, a chosen folder's files, a local path, or a
+   * URL for the server to download.
+   */
+  load(e) {
+    var s;
+    if ((s = e.files) != null && s.length) {
+      const o = new FormData();
+      for (const l of e.files) o.append("files", l);
+      const a = e.name ? `?name=${encodeURIComponent(e.name)}` : "";
+      return m(`${this.baseUrl}/api/load${a}`, {
+        method: "POST",
+        body: o
+      });
+    }
+    if (e.file) {
+      const o = new FormData();
+      return o.append("file", e.file), m(`${this.baseUrl}/api/load`, {
+        method: "POST",
+        body: o
+      });
+    }
+    const t = new URLSearchParams();
+    return e.url ? t.set("url", e.url) : t.set("path", e.path ?? ""), m(`${this.baseUrl}/api/load?${t}`, { method: "POST" });
+  }
+}
+function ne() {
+  return {
+    tables: [],
+    missing: [],
+    columnInfoByName: {},
+    view: { table: "", filters: [], page: 1 },
+    pageSize: 100,
+    routeShapes: /* @__PURE__ */ new Map(),
+    mapDataLoaded: !1,
+    rawValues: !1
+  };
+}
+function oe(n, e) {
+  return n.tables.find((t) => t.name === e);
+}
+const M = ["B", "KB", "MB", "GB", "TB"], se = {
+  path: "Local path",
+  upload: "Upload",
+  folder: "Folder upload",
+  download: "Download"
+};
+function f(n) {
+  let e = n, t = 0;
+  for (; e >= 1024 && t < M.length - 1; )
+    e /= 1024, t += 1;
+  const s = t === 0 ? 0 : e < 10 ? 1 : 0;
+  return `${e.toFixed(s)} ${M[t]}`;
+}
+function p(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)} s` : n >= 10 ? `${Math.round(n)} ms` : `${n.toFixed(1)} ms`;
+}
+function H(n) {
+  return n.files.reduce((e, t) => e + t.bytes, 0);
+}
+function ae(n, e) {
+  const t = [
+    `${n.files.length} ${n.files.length === 1 ? "file" : "files"}`,
+    f(H(n)),
+    // Only a server load is time spent on a server. A source that described its
+    // own phases spent that time here, in this browser.
+    n.phases ? p(n.total_ms) : `${p(n.total_ms)} server`
+  ];
+  return e !== void 0 && t.push(`${p(e)} round trip`), t.join(" · ");
+}
+function ie(n) {
+  if (n.phases)
+    return n.phases.map(({ label: t, ms: s, note: o }) => [t, o ? `${p(s)} · ${o}` : p(s)]);
+  const e = [];
+  if (n.acquire_ms != null && n.kind) {
+    const t = n.acquire_bytes == null ? "" : ` · ${f(n.acquire_bytes)}`;
+    e.push([se[n.kind], `${p(n.acquire_ms)}${t}`]);
+  }
+  if (n.extract_ms != null && e.push(["Unzip", `${p(n.extract_ms)} · ${f(n.total_bytes)} archive`]), n.register_ms != null && e.push(["Read headers", p(n.register_ms)]), n.convert_ms != null) {
+    const t = n.stored_bytes === null ? "" : ` · ${f(n.stored_bytes)} stored`;
+    e.push(["Convert to Parquet", `${p(n.convert_ms)}${t}`]);
+  }
+  return n.count_ms != null && e.push(["Count rows", p(n.count_ms)]), e;
+}
+function le(n) {
+  const e = H(n);
+  return [...n.files].sort((t, s) => s.bytes - t.bytes).map((t) => ({
+    name: t.name,
+    bytes: f(t.bytes),
+    share: e === 0 ? 0 : Math.round(t.bytes / e * 100),
+    compressed: t.compressed_bytes === null ? "—" : f(t.compressed_bytes),
+    stored: t.parquet_bytes === null ? "—" : f(t.parquet_bytes),
+    costMs: re(n, t),
+    rows: t.row_count === null ? "—" : t.row_count.toLocaleString(),
+    columns: t.columns
+  }));
+}
+function O(n) {
+  return n.convert_ms !== null;
+}
+function re(n, e) {
+  const t = O(n) ? e.convert_ms : e.count_ms;
+  return t === null ? "—" : p(t);
+}
+function de(n) {
+  const e = n.phases ? null : O(n) ? {
+    label: "Convert",
+    title: "Time to rewrite this file as Parquet, which is what every query then reads.",
+    value: (t) => t.costMs
+  } : {
+    label: "Count",
+    title: "Time to read this file end to end to count its rows.",
+    value: (t) => t.costMs
+  };
+  return [
+    { label: "File", value: (t) => t.name },
+    { label: "Size", title: "Uncompressed, and its share of the feed", value: (t) => `${t.bytes} (${t.share}%)` },
+    { label: "Zipped", title: "Size inside the archive", value: (t) => t.compressed },
+    { label: "Stored", title: "Size as Parquet, which is what queries read", value: (t) => t.stored },
+    { label: "Rows", value: (t) => t.rows },
+    { label: "Cols", value: (t) => String(t.columns) },
+    ...e ? [e] : []
+  ];
+}
+function ce(n) {
+  const e = document.createElement("dl");
+  e.dataset.el = "metrics-phases";
+  for (const [t, s] of ie(n)) {
+    const o = document.createElement("dt");
+    o.textContent = t;
+    const a = document.createElement("dd");
+    a.textContent = s, e.append(o, a);
+  }
+  return e;
+}
+function he(n) {
+  const e = de(n), t = document.createElement("table"), s = document.createElement("tr");
+  for (const o of e) {
+    const a = document.createElement("th");
+    a.textContent = o.label, o.title && (a.title = o.title), s.appendChild(a);
+  }
+  t.appendChild(s);
+  for (const o of le(n)) {
+    const a = document.createElement("tr");
+    for (const l of e) {
+      const i = document.createElement("td");
+      i.textContent = l.value(o), a.appendChild(i);
+    }
+    t.appendChild(a);
+  }
+  return t;
+}
+function ue(n, e, t) {
+  const s = n.el("metrics-btn");
+  s.textContent = ae(e, t), s.hidden = !1;
+  const o = n.el("metrics-body");
+  o.innerHTML = "", o.append(ce(e), he(e)), n.el("metrics-panel").classList.add("hidden");
+}
+function pe(n) {
+  const e = n.el("metrics-panel");
+  n.el("metrics-btn").addEventListener("click", () => e.classList.toggle("hidden")), n.el("metrics-close-btn").addEventListener("click", () => e.classList.add("hidden"));
+}
+const me = {
+  start: "Loading",
+  download: "Downloading",
+  upload: "Receiving",
+  extract: "Unzipping",
+  convert: "Converting",
+  summarise: "Counting rows",
+  done: "Loading"
+};
+function fe(n, e) {
+  if (!n || !n.running) return `Loading ${e}…`;
+  if (n.phase === "start") return `Loading ${e}…`;
+  const t = me[n.phase] ?? "Loading";
+  if (n.phase === "summarise") return `${t}…`;
+  if (n.phase === "download") {
+    const o = f(n.done);
+    return n.total > 0 ? `${t} ${o} of ${f(n.total)}` : `${t} ${o}`;
+  }
+  const s = n.detail ? ` ${n.detail}` : "";
+  return n.total > 0 ? `${t}${s} (${n.done} of ${n.total})` : `${t}${s}…`;
+}
+const be = /^https?:\/\//i, ye = 400;
+class ge {
+  constructor(e, t, s, o) {
+    b(this, "busy", !1);
+    this.dom = e, this.source = t, this.onLoaded = s, this.canCancel = o, this.dom.el("open-load-btn").addEventListener("click", () => this.open()), this.dom.el("load-cancel-btn").addEventListener("click", () => this.close());
+    const a = this.dom.el("path-input");
+    a.addEventListener("input", () => this.syncSubmitState()), a.addEventListener("keydown", (h) => {
+      h.key === "Enter" && this.submitTyped(), h.key === "Escape" && this.canCancel() && this.close();
+    }), this.dom.el("load-path-btn").addEventListener("click", () => this.submitTyped());
+    const l = this.dom.el("dropzone"), i = this.dom.el("file-input"), r = this.dom.el("folder-input");
+    l.addEventListener("click", () => i.click()), this.dom.el("pick-file-btn").addEventListener("click", () => i.click()), this.dom.el("pick-folder-btn").addEventListener("click", () => r.click()), r.addEventListener("change", (h) => {
+      const d = Array.from(h.target.files ?? []);
+      d.length && this.loadFolder(d);
+    });
+    for (const h of ["dragenter", "dragover"])
+      l.addEventListener(h, (d) => {
+        d.preventDefault(), l.classList.add("drag");
+      });
+    for (const h of ["dragleave", "drop"])
+      l.addEventListener(h, (d) => {
+        d.preventDefault(), l.classList.remove("drag");
+      });
+    l.addEventListener("drop", (h) => {
+      var g;
+      const d = (g = h.dataTransfer) == null ? void 0 : g.files[0];
+      d && this.load(() => this.source.load({ file: d }), d.name);
+    }), this.dom.el("file-input").addEventListener("change", (h) => {
+      var g;
+      const d = (g = h.target.files) == null ? void 0 : g[0];
+      d && this.load(() => this.source.load({ file: d }), d.name);
+    });
+  }
+  open() {
+    this.dom.el("load-overlay").classList.remove("hidden"), this.dom.el("load-error").textContent = "", this.syncSubmitState(), this.dom.el("path-input").focus();
+  }
+  close() {
+    this.dom.el("load-overlay").classList.add("hidden");
+  }
+  /**
+   * A chosen folder arrives as its individual files. Only the feed's own files
+   * are sent: a folder can also hold documentation, archives or editor cruft,
+   * and uploading those would be slow for nothing.
+   */
+  async loadFolder(e) {
+    const t = e.filter((a) => /\.(txt|geojson)$/i.test(a.name));
+    if (t.length === 0) {
+      this.dom.el("load-error").textContent = "That folder has no GTFS .txt files in it.";
+      return;
+    }
+    const s = t[0].webkitRelativePath, o = (s == null ? void 0 : s.split("/")[0]) || "chosen folder";
+    await this.load(() => this.source.load({ files: t, name: o }), o);
+  }
+  /** A path or URL is sent to a different parameter, so the server knows which. */
+  submitTyped() {
+    const e = this.dom.el("path-input").value.trim();
+    if (!e || this.busy) return;
+    const t = be.test(e) ? () => this.source.load({ url: e }) : () => this.source.load({ path: e });
+    this.load(t, e);
+  }
+  syncSubmitState() {
+    const e = this.dom.el("path-input").value.trim() === "";
+    this.dom.el("load-path-btn").disabled = e || this.busy, this.dom.el("load-cancel-btn").hidden = !this.canCancel();
+  }
+  /**
+   * Poll the server for the load's phase until it is told to stop.
+   *
+   * Only answerable at all because the load runs in a worker thread; while it
+   * sat on the event loop no other request could be served, which is why a big
+   * feed looked like a hung page.
+   */
+  pollProgress(e) {
+    let t = !1;
+    return (async () => {
+      for (; !t; ) {
+        try {
+          const o = await this.source.loadProgress();
+          t || (this.dom.el("load-status").textContent = fe(o, e));
+        } catch {
+        }
+        await new Promise((o) => window.setTimeout(o, ye));
+      }
+    })(), () => {
+      t = !0;
+    };
+  }
+  async load(e, t) {
+    this.busy = !0, this.syncSubmitState(), this.dom.el("load-error").textContent = "", this.dom.el("load-status").textContent = `Loading ${t}…`;
+    const s = this.pollProgress(t);
+    try {
+      const o = performance.now(), a = await e();
+      this.onLoaded(a, performance.now() - o), this.close();
+    } catch (o) {
+      this.dom.el("load-error").textContent = o.message;
+    } finally {
+      s(), this.busy = !1, this.dom.el("load-status").textContent = "", this.syncSubmitState();
+    }
+  }
+}
+const ve = {
+  eq: "=",
+  ne: "!=",
+  contains: "contains",
+  in: "in",
+  is_empty: "is empty",
+  is_not_empty: "is not empty"
+}, q = ["is_empty", "is_not_empty"];
+class we {
+  constructor(e, t, s, o) {
+    this.dom = e, this.state = t, this.source = s, this.onChange = o, this.dom.el("add-filter-btn").addEventListener("click", () => {
+      this.dom.el("add-filter-form").classList.add("open"), this.updateValueInput();
+    }), this.dom.el("filter-cancel-btn").addEventListener(
+      "click",
+      () => this.dom.el("add-filter-form").classList.remove("open")
+    ), this.dom.el("filter-column").addEventListener("change", () => void this.updateValueInput()), this.dom.el("filter-op").addEventListener("change", () => void this.updateValueInput()), this.dom.el("filter-apply-btn").addEventListener("click", () => this.apply());
+  }
+  render() {
+    const e = this.dom.el("filter-bar");
+    e.querySelectorAll(".chip").forEach((t) => t.remove()), this.state.view.filters.forEach((t, s) => {
+      const o = document.createElement("span");
+      o.className = "chip";
+      const a = t.value === "" || t.value == null ? "(empty)" : t.value, l = !q.includes(t.op), i = document.createElement("span");
+      i.textContent = `${t.column} ${ve[t.op]} ${l ? a : ""}`.trim();
+      const r = document.createElement("button");
+      r.textContent = "×", r.addEventListener(
+        "click",
+        () => this.onChange(this.state.view.filters.filter((h, d) => d !== s))
+      ), o.append(i, r), e.appendChild(o);
+    }), this.dom.el("filter-column").innerHTML = Object.keys(this.state.columnInfoByName).map((t) => `<option value="${t}">${t}</option>`).join("");
+  }
+  /**
+   * Enumerated columns get a picklist of the values actually present, with
+   * counts, so nobody has to guess what a feed uses.
+   */
+  async updateValueInput() {
+    const e = this.dom.el("filter-column").value, t = this.dom.el("filter-op").value, s = this.dom.el("filter-value"), o = this.dom.el("filter-value-picker");
+    if (q.includes(t)) {
+      s.style.display = "none", o.style.display = "none";
+      return;
+    }
+    const a = this.state.columnInfoByName[e];
+    if (!((a == null ? void 0 : a.enum_like) && t !== "contains" && t !== "in")) {
+      s.style.display = "inline-block", o.style.display = "none";
+      return;
+    }
+    s.style.display = "none", o.style.display = "inline-block", o.innerHTML = "<option value=''>Loading...</option>";
+    const i = await this.source.distinct(this.state.view.table, e, 100);
+    o.innerHTML = i.map(({ value: r, count: h }) => `<option value="${r ?? ""}">${r === "" || r === null ? "(empty)" : r} (${h})</option>`).join("");
+  }
+  apply() {
+    const e = this.dom.el("filter-column").value;
+    if (!e) return;
+    const t = this.dom.el("filter-op").value, s = this.dom.el("filter-value-picker"), o = this.dom.el("filter-value"), a = s.style.display !== "none" ? s.value : o.value;
+    this.dom.el("add-filter-form").classList.remove("open"), o.value = "", this.onChange([...this.state.view.filters, { column: e, op: t, value: a }]);
+  }
+}
+function _(n) {
+  const e = new URLSearchParams({ table: n.table, page: String(n.page || 1) });
+  return n.filters.length && e.set("filters", JSON.stringify(n.filters)), `?${e}`;
+}
+function V(n) {
+  const e = new URLSearchParams(n), t = e.get("table");
+  if (!t) return null;
+  let s = [];
+  try {
+    const o = JSON.parse(e.get("filters") || "[]");
+    s = Array.isArray(o) ? o : [];
+  } catch {
+    s = [];
+  }
+  return { table: t, filters: s, page: Number(e.get("page")) || 1 };
+}
+function Be() {
+  const n = (e) => ({
+    gtfsView: { ...e.view, depth: e.depth },
+    feed: e.feed
+  });
+  return {
+    push: (e) => history.pushState(n(e), "", _(e.view)),
+    replace: (e) => history.replaceState(n(e), "", _(e.view)),
+    back: () => history.back(),
+    onPop(e) {
+      const t = (s) => {
+        const o = s.state;
+        if (!(o != null && o.gtfsView)) return e(null);
+        const { depth: a, ...l } = o.gtfsView;
+        e({ view: l, depth: a ?? 0, feed: o.feed });
+      };
+      return window.addEventListener("popstate", t), () => window.removeEventListener("popstate", t);
+    },
+    initialView: () => V(location.search)
+  };
+}
+function Le(n = null) {
+  const e = [];
+  let t = () => {
+  };
+  return {
+    push: (s) => void e.push(s),
+    replace(s) {
+      e.length = 0, e.push(s);
+    },
+    back() {
+      e.length <= 1 || (e.pop(), t(e[e.length - 1]));
+    },
+    onPop(s) {
+      return t = s, () => {
+        t = () => {
+        };
+      };
+    },
+    initialView: () => n
+  };
+}
+const Ee = ["feed_info", "agency", "routes"];
+function $e(n, e) {
+  if (e && n.some((s) => s.name === e.table))
+    return e;
+  const t = Ee.map((s) => n.find((o) => o.name === s)).find(Boolean) ?? n[0];
+  return t ? { table: t.name, filters: [], page: 1 } : null;
+}
+class x {
+  constructor(e, t, s, o) {
+    b(this, "depth", 0);
+    b(this, "feed", "");
+    /** Undoes the history subscription taken in the constructor. */
+    b(this, "stopListening");
+    this.dom = e, this.history = t, this.state = s, this.onChange = o, this.stopListening = this.history.onPop((a) => {
+      if (a) {
+        if (a.feed !== this.feed) {
+          this.history.replace(this.entryFor(this.state.view));
+          return;
+        }
+        this.depth = a.depth, this.apply(a.view, !1);
+      }
+    }), this.dom.el("back-btn").addEventListener("click", () => this.back());
+  }
+  /** Stop responding to the host's history. See `mount`'s `destroy`. */
+  destroy() {
+    this.stopListening();
+  }
+  entryFor(e) {
+    return { view: e, depth: this.depth, feed: this.feed };
+  }
+  /** The view named by the current location, for an app that owns its page. */
+  fromLocation() {
+    return this.history.initialView();
+  }
+  current() {
+    return this.state.view;
+  }
+  /**
+   * Start a fresh history for a newly opened feed.
+   *
+   * `feed` identifies it, so entries left in the browser's history by an
+   * earlier feed can be recognised and ignored.
+   */
+  reset(e, t) {
+    this.depth = 0, this.feed = t, this.history.replace(this.entryFor(e)), this.apply(e, !1);
+  }
+  go(e) {
+    this.apply(e, !0);
+  }
+  /** Step back one view. Public so an embedding host can offer its own control. */
+  back() {
+    this.history.back();
+  }
+  selectTable(e, t = []) {
+    this.go({ table: e, filters: t, page: 1 });
+  }
+  apply(e, t) {
+    const s = oe(this.state, e.table);
+    s && (this.state.view = {
+      table: e.table,
+      filters: structuredClone(e.filters ?? []),
+      page: e.page || 1
+    }, this.state.columnInfoByName = Object.fromEntries(s.columns.map((o) => [o.name, o])), t && (this.depth += 1, this.history.push(this.entryFor(this.state.view))), this.dom.el("back-btn").disabled = this.depth <= 0, this.onChange(this.state.view));
+  }
+}
+/** Re-exported so callers need not know where the URL shape is defined. */
+b(x, "urlFor", _), b(x, "parseUrl", V);
+function Ce(n) {
+  if (n.presence !== "conditional") return "Required. This feed does not have it.";
+  const e = n.condition ?? "Conditionally required.", t = n.condition_outcome ? ` Required here: ${n.condition_outcome.evidence}.` : "";
+  return `${e}${t}`;
+}
+function ke(n) {
+  const e = n.forbidden;
+  return e ? `${e.condition} Forbidden here: ${e.outcome.evidence}.` : "";
+}
+function F(n, e, t) {
+  const s = n.el("sidebar");
+  s.innerHTML = "";
+  for (const o of e.tables) {
+    const a = document.createElement("div");
+    a.className = "table-tab" + (o.name === e.view.table ? " active" : "");
+    const l = document.createElement("span");
+    l.textContent = o.name;
+    const i = document.createElement("span");
+    i.className = "count", i.textContent = o.row_count.toLocaleString();
+    const r = ke(o);
+    r && (a.classList.add("forbidden"), a.title = r, i.textContent = "forbidden"), a.append(l, i), a.addEventListener("click", () => t(o.name)), s.appendChild(a);
+  }
+  for (const o of e.missing) {
+    const a = document.createElement("div");
+    a.className = "table-tab missing", a.title = Ce(o), a.dataset.el = "missing-file";
+    const l = document.createElement("span");
+    l.textContent = o.name;
+    const i = document.createElement("span");
+    i.className = "count", i.textContent = "missing", a.append(l, i), s.appendChild(a);
+  }
+}
+const Se = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]), y = (n) => ({ text: n, kind: "plain" }), v = (n, e) => ({
+  text: n,
+  kind: "plain",
+  malformed: e
+});
+function A(n, e, t) {
+  const s = t && !n.includes(":") ? `${t}${n}` : n;
+  try {
+    const o = new URL(s);
+    return Se.has(o.protocol) ? { text: n, kind: "link", href: o.href } : v(n, e);
+  } catch {
+    return v(n, e);
+  }
+}
+function _e(n, e, t) {
+  const s = t.minimum ?? void 0, o = t.maximum ?? void 0;
+  if (!/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(n.trim()))
+    return v(n, e);
+  const a = Number(n);
+  return !Number.isFinite(a) || s !== void 0 && a < s || o !== void 0 && a > o ? v(n, e) : { text: n, kind: "numeric" };
+}
+function xe(n, e) {
+  const [t, s, o] = [n.slice(0, 4), n.slice(4, 6), n.slice(6, 8)].map(Number), a = new Date(t, s - 1, o);
+  return a.getMonth() !== s - 1 || a.getDate() !== o ? v(n, e) : y(a.toLocaleDateString(void 0, { year: "numeric", month: "short", day: "numeric" }));
+}
+function Re(n) {
+  return { text: n, kind: "color", swatch: `#${n}` };
+}
+function Te(n, e) {
+  const t = e == null ? void 0 : e[n];
+  return y(!t || t === n ? n : `${t} (${n})`);
+}
+const Ne = {
+  COLOR: "six hex digits, without a leading #",
+  DATE: "a date as YYYYMMDD",
+  EMAIL: "an email address",
+  URL: "a URL",
+  LATITUDE: "a latitude",
+  LONGITUDE: "a longitude",
+  INTEGER: "a number",
+  FLOAT: "a number",
+  CURRENCY_AMOUNT: "a number"
+};
+function E(n) {
+  const e = Ne[n.type ?? ""] ?? n.type_description ?? "a value GTFS recognises", { minimum: t, maximum: s } = n;
+  return t !== null && s !== null ? `${e} between ${t} and ${s}` : e;
+}
+const k = /* @__PURE__ */ new Map();
+function Pe(n) {
+  if (!k.has(n))
+    try {
+      k.set(n, new RegExp(n));
+    } catch {
+      k.set(n, null);
+    }
+  return k.get(n) ?? null;
+}
+function Ue(n, e) {
+  if (e.pattern) {
+    const t = Pe(e.pattern);
+    if (t && !t.test(n)) return v(n, E(e));
+  }
+  switch (e.type) {
+    case "ENUM":
+      return Te(n, e.values);
+    case "COLOR":
+      return Re(n);
+    case "URL":
+      return A(n, E(e));
+    case "EMAIL":
+      return A(n, E(e), "mailto:");
+    case "DATE":
+      return xe(n, E(e));
+    case "LATITUDE":
+    case "LONGITUDE":
+    case "INTEGER":
+    case "FLOAT":
+    case "CURRENCY_AMOUNT":
+      return _e(n, E(e), e);
+    // TIME has a pattern and so is checked above, but is deliberately not
+    // reformatted: GTFS times legitimately exceed 24:00:00 for trips running
+    // past midnight, and a formatter that "corrected" 25:30:00 would be worse
+    // than none.
+    default:
+      return y(n);
+  }
+}
+function Ie(n) {
+  const e = n.when_empty;
+  return e ? {
+    text: e.code ? `${e.label} (${e.code})` : e.label,
+    kind: "plain",
+    implied: e.code ? `Empty. GTFS implies ${e.code} - ${e.label}.` : `Empty. GTFS implies: ${e.label}`
+  } : y("");
+}
+function Me(n, e, t = !1) {
+  if (n == null)
+    return !t && e ? Ie(e) : y("");
+  if (t || !e) return y(n);
+  try {
+    return Ue(n, e);
+  } catch {
+    return y(n);
+  }
+}
+function qe(n) {
+  if (n.required === "always") return "Required";
+  if (n.required !== "conditional") return "";
+  const e = n.condition_outcome;
+  let t;
+  return e ? t = `${e.holds ? "Required" : "Not required"} in this feed (${e.evidence})` : n.condition_scope === "row_context" ? t = "Conditionally required, row by row" : t = "Conditionally required", n.condition ? `${t} - ${n.condition}` : t;
+}
+function Fe(n) {
+  if (!n) return "";
+  const e = [];
+  n.type && e.push(n.type);
+  const t = qe(n);
+  if (t && e.push(t), n.when_empty) {
+    const { code: s, label: o } = n.when_empty;
+    e.push(s ? `empty implies ${s} - ${o}` : `empty implies: ${o}`);
+  }
+  return e.join(" · ");
+}
+function Ae(n) {
+  const e = /* @__PURE__ */ new Map();
+  for (const t of n) e.set(t.table, (e.get(t.table) ?? 0) + 1);
+  return n.map((t) => ({
+    link: t,
+    label: (e.get(t.table) ?? 0) > 1 ? `▸ ${t.table} ${t.column}` : `▸ ${t.table}`,
+    title: `Rows in ${t.table} whose ${t.column} is this`
+  }));
+}
+function De(n, e, t) {
+  const s = [], { onHighlightStop: o, onHighlightShape: a, onHighlightRoute: l, onHighlightLocation: i } = t;
+  if (n.stop_id && o) {
+    const r = n.stop_id;
+    s.push({ label: "📍", title: "Show this stop on the map", run: () => o(r) });
+  }
+  if (n.shape_id && a) {
+    const r = n.shape_id;
+    s.push({ label: "🧭", title: "Show this shape on the map", run: () => a(r) });
+  }
+  if (n.route_id && e.hasRouteShapes && l) {
+    const r = n.route_id;
+    s.push({ label: "🚌", title: "Show this route on the map", run: () => l(r) });
+  }
+  if (n.id && e.table === "locations" && i) {
+    const r = n.id;
+    s.push({ label: "🗺️", title: "Show this zone on the map", run: () => i(r) });
+  }
+  return s;
+}
+class He {
+  constructor(e, t, s) {
+    /**
+     * The page currently on screen, so that a display change can redraw without
+     * asking the server again - on a large feed a refetch to toggle formatting
+     * would be a needless round trip over millions of rows.
+     */
+    b(this, "lastPage", null);
+    this.dom = e, this.state = t, this.callbacks = s, this.dom.el("prev-page").addEventListener("click", () => {
+      this.state.view.page > 1 && this.callbacks.onPage(this.state.view.page - 1);
+    }), this.dom.el("next-page").addEventListener(
+      "click",
+      () => this.callbacks.onPage(this.state.view.page + 1)
+    );
+  }
+  /** Draw the current page again, picking up a changed display preference. */
+  redraw() {
+    this.lastPage && this.render(this.lastPage);
+  }
+  showMessage(e) {
+    this.lastPage = null;
+    const t = this.dom.el("table-scroll");
+    t.innerHTML = "";
+    const s = document.createElement("div");
+    s.dataset.el = "empty-state", s.textContent = e, t.appendChild(s), this.dom.el("pager").style.display = "none";
+  }
+  render(e) {
+    this.lastPage = e;
+    const t = document.createElement("table"), s = document.createElement("thead"), o = document.createElement("tr");
+    this.hasActions && o.appendChild(document.createElement("th"));
+    for (const i of e.columns) {
+      const r = document.createElement("th");
+      r.textContent = i;
+      const h = Fe(this.state.columnInfoByName[i]);
+      h && (r.title = h), o.appendChild(r);
+    }
+    s.appendChild(o), t.appendChild(s);
+    const a = document.createElement("tbody");
+    for (const i of e.rows)
+      a.appendChild(this.buildRow(e.columns, i));
+    t.appendChild(a);
+    const l = this.dom.el("table-scroll");
+    l.innerHTML = "", l.appendChild(t), this.renderPager(e);
+  }
+  buildRow(e, t) {
+    const s = document.createElement("tr"), o = {};
+    if (e.forEach((a, l) => o[a] = t[l]), this.hasActions) {
+      const a = document.createElement("td");
+      a.appendChild(this.buildRowActions(o)), s.appendChild(a);
+    }
+    return e.forEach((a, l) => {
+      s.appendChild(this.buildCell(a, t[l]));
+    }), s;
+  }
+  buildCell(e, t) {
+    const s = document.createElement("td"), o = this.state.columnInfoByName[e];
+    if (o != null && o.fk_table && t) {
+      const a = document.createElement("a");
+      a.href = "#", a.className = "fk-link", a.textContent = t, a.addEventListener("click", (l) => {
+        l.preventDefault(), this.callbacks.onNavigate(o.fk_table, [
+          { column: o.fk_column, op: "eq", value: t }
+        ]);
+      }), s.appendChild(a);
+    } else
+      this.renderValue(s, t, o);
+    if (o != null && o.related.length && t) {
+      const a = document.createElement("div");
+      a.className = "related-row";
+      for (const { link: l, label: i, title: r } of Ae(o.related)) {
+        const h = I(
+          i,
+          r,
+          () => this.callbacks.onNavigate(l.table, [{ column: l.column, op: "eq", value: t }])
+        );
+        h.className = "related-btn", a.appendChild(h);
+      }
+      s.appendChild(a);
+    }
+    return s;
+  }
+  /**
+   * Draw what `renderValue` decided.
+   *
+   * Every path here writes through `textContent`, never `innerHTML`, so a feed
+   * cannot inject markup - and an `href` is only ever set from a URL that
+   * module already restricted to http, https and mailto.
+   */
+  renderValue(e, t, s) {
+    const o = Me(t, s, this.state.rawValues);
+    if (o.kind === "link" && o.href) {
+      const a = document.createElement("a");
+      a.href = o.href, a.textContent = o.text, a.className = "value-link", a.rel = "noopener noreferrer", a.target = "_blank", e.appendChild(a);
+      return;
+    }
+    if (o.kind === "color" && o.swatch) {
+      const a = document.createElement("span");
+      a.className = "value-swatch", a.style.backgroundColor = o.swatch, e.append(a, document.createTextNode(o.text));
+      return;
+    }
+    o.implied && (e.classList.add("value-implied"), e.title = o.implied), o.kind === "numeric" && e.classList.add("value-numeric"), o.malformed && (e.classList.add("value-malformed"), e.title = `Expected ${o.malformed}`), e.textContent = o.text;
+  }
+  /**
+   * Whether any row could ever carry an action.
+   *
+   * Decides the column, not the button: with no map there is nothing to put in
+   * it, and an always-empty leading column is worse than no column at all.
+   */
+  get hasActions() {
+    const { onHighlightStop: e, onHighlightShape: t, onHighlightRoute: s, onHighlightLocation: o } = this.callbacks;
+    return !!(e || t || s || o);
+  }
+  buildRowActions(e) {
+    const t = document.createElement("span"), s = { table: this.state.view.table, hasRouteShapes: this.state.routeShapes.size > 0 };
+    for (const o of De(e, s, this.callbacks)) {
+      const a = I(o.label, o.title, o.run);
+      a.className = "map-btn", t.appendChild(a);
+    }
+    return t;
+  }
+  renderPager(e) {
+    this.dom.el("pager").style.display = "flex";
+    const t = Math.max(1, Math.ceil(e.total / e.page_size));
+    this.dom.el("page-info").textContent = `Page ${e.page} / ${t}`, this.dom.el("row-count").textContent = `${e.total.toLocaleString()} rows`, this.dom.el("prev-page").disabled = e.page <= 1, this.dom.el("next-page").disabled = e.page >= t;
+  }
+}
+const Oe = { load: !1, report: !1 };
+async function ze(n, e = {}) {
+  var N, P, U;
+  const t = { ...Oe, ...e.parts, map: !!e.map }, s = e.source ?? new te(e.baseUrl);
+  X(n, t);
+  const o = j(n), a = ne();
+  t.report && pe(o);
+  const l = e.basemap ?? ((P = await ((N = s.config) == null ? void 0 : N.call(s).catch(() => null))) == null ? void 0 : P.basemap), i = await ((U = e.map) == null ? void 0 : U.create(o, a, s, l));
+  i == null || i.restoreVisibility();
+  const r = async (c) => {
+    try {
+      $.render(await s.query(c.table, c.filters, c.page, a.pageSize));
+    } catch (u) {
+      $.showMessage(`Could not load ${c.table}: ${u.message}`);
+    }
+  };
+  let h;
+  const d = new x(o, e.history ?? Le(), a, (c) => {
+    F(o, a, (u) => d.selectTable(u)), h == null || h.render(), r(c);
+  });
+  h = new we(
+    o,
+    a,
+    s,
+    (c) => d.go({ table: a.view.table, filters: c, page: 1 })
+  );
+  const g = i ? /* @__PURE__ */ (() => {
+    const c = async (u, w, C = !1) => {
+      await i.highlight(await s.geojson(u, [w]), { point: C });
+    };
+    return {
+      onHighlightStop: (u) => void c("stops", u, !0),
+      onHighlightShape: (u) => void c("shapes", u),
+      onHighlightRoute: (u) => {
+        const w = a.routeShapes.get(u);
+        w && c("shapes", w);
+      },
+      onHighlightLocation: (u) => void c("locations", u)
+    };
+  })() : {}, $ = new He(o, a, {
+    onNavigate: (c, u) => d.selectTable(c, u),
+    onPage: (c) => d.go({ ...d.current(), page: c }),
+    ...g
+  }), R = o.el("raw-values-input");
+  R.addEventListener("change", () => {
+    a.rawValues = R.checked, $.redraw();
+  });
+  const T = (c, u, w = !1) => {
+    L == null || L.close(), o.el("source-label").textContent = c.source, t.report && c.metrics && ue(o, c.metrics, u), a.tables = c.tables, a.missing = c.missing ?? [], a.mapDataLoaded = !1, a.routeShapes.clear(), F(o, a, (S) => d.selectTable(S)), i == null || i.refresh().catch((S) => console.error("Map layers failed to load:", S));
+    const C = $e(c.tables, w ? d.fromLocation() : null);
+    C && d.reset(C, c.source);
+  }, L = t.load ? new ge(
+    o,
+    s,
+    (c, u) => T(c, u),
+    () => a.tables.length > 0
+  ) : void 0;
+  try {
+    T(await s.tables(), void 0, t.load);
+  } catch (c) {
+    L ? L.open() : $.showMessage(`Could not load the feed: ${c.message}`);
+  }
+  return {
+    destroy() {
+      d.destroy(), i == null || i.destroy(), n.replaceChildren(), n.classList.remove("gtfs-viewer");
+    }
+  };
+}
+export {
+  te as R,
+  Le as a,
+  Be as b,
+  ze as m,
+  fe as p
+};