gtfs-garage-web 0.0.1

package/dist/sources/parquet.d.ts

@@ -0,0 +1,85 @@
+/**
+ * A source that queries Parquet in the browser, with no server at all.
+ *
+ * A GTFS dataset is converted to Parquet once - `gtfs-garage --export`, and in
+ * production the same conversion behind an API endpoint - and every table
+ * becomes one file. DuckDB-WASM reads those over HTTP range requests, so a page
+ * opens without downloading, unzipping or converting anything, and nothing has
+ * to hold a feed in memory on anyone's behalf.
+ *
+ * The export writes through the same `ALL_VARCHAR` views the CSVs were read
+ * with, so every column is text here exactly as it is server-side and the
+ * filters below behave identically.
+ */
+import type { FeatureCollection, Filter, GeoJsonKind, ViewerSource, PageResponse, TablesResponse, ValueCount } from "./types";
+/**
+ * A WHERE clause with its values inlined.
+ *
+ * Ported from `core/filters.py`, including the rule that matters most: an empty
+ * CSV field loads as NULL, so `= (empty)` has to mean "is empty" or choosing
+ * the `(empty)` entry in a picklist would match nothing.
+ *
+ * DuckDB-WASM's query API takes a string, so values are escaped rather than
+ * bound. Every one is a string - the columns are all VARCHAR - and doubling
+ * quotes is the whole of the escaping SQL needs for a string literal.
+ */
+export declare function buildWhere(known: string[], filters: Filter[]): string;
+export interface ParquetSourceOptions {
+    /** Where the `{table}.parquet` files live, without a trailing slash. */
+    baseUrl: string;
+    /** Shown as the feed's name in the header. */
+    name?: string;
+    /** Which tables the dataset has. Discovered by probing when not given. */
+    tables?: string[];
+}
+export declare class ParquetSource implements ViewerSource {
+    private readonly options;
+    private connection;
+    private terminate;
+    private present;
+    private startupMs;
+    private manifestMs;
+    private firstQueryMs;
+    constructor(options: ParquetSourceOptions);
+    /** Release the worker and the wasm instance. See the viewer's `destroy`. */
+    close(): Promise<void>;
+    /**
+     * The file as an absolute URL.
+     *
+     * DuckDB runs in a worker and fetches these itself, so it has no page to
+     * resolve a relative path against - `/datasets/x` reaches nothing. Callers
+     * naturally write a path, so it is resolved here.
+     */
+    private file;
+    /**
+     * Start DuckDB on first use.
+     *
+     * Imported here rather than at the top of the file so that the megabytes of
+     * wasm are fetched when a dataset is actually opened, not when the module is.
+     */
+    private connect;
+    /**
+     * The table list an exported dataset carries, if it carries one.
+     *
+     * `gtfs-garage --export` writes a manifest beside the Parquet so a reader
+     * need not guess. Without it the only fallback is trying all 32 tables GTFS
+     * defines, which for a seven-table feed measured at 123 requests before the
+     * first row appeared.
+     */
+    private fromManifest;
+    /**
+     * What the dataset cost to open *here*.
+     *
+     * The server's load report describes a download, an unzip and a conversion.
+     * None of that happens in a browser reading Parquet: the cost is starting
+     * DuckDB, fetching the manifest, and the first queries. Reporting the
+     * conversion's timings instead would describe work this reader did not do.
+     */
+    private metrics;
+    private rows;
+    tables(): Promise<TablesResponse>;
+    query(table: string, filters: Filter[], page: number, pageSize: number): Promise<PageResponse>;
+    distinct(table: string, column: string, limit?: number): Promise<ValueCount[]>;
+    geojson(_kind: GeoJsonKind, _ids?: string[]): Promise<FeatureCollection>;
+    geojsonStream(_kind: GeoJsonKind, _onMessage: unknown, _signal?: AbortSignal): Promise<void>;
+}

package/dist/sources/rest.d.ts

@@ -0,0 +1,35 @@
+/** `GtfsSource` backed by the local Python server. */
+import { type NdjsonMessage } from "./ndjson";
+import type { AppConfig, FeatureCollection, Filter, GeoJsonKind, GtfsSource, LoadProgress, PageResponse, TablesResponse, ValueCount } from "./types";
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare class RestSource implements GtfsSource {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    config(): Promise<AppConfig>;
+    tables(): Promise<TablesResponse>;
+    query(table: string, filters: Filter[], page: number, pageSize: number): Promise<PageResponse>;
+    distinct(table: string, column: string, limit?: number): Promise<ValueCount[]>;
+    geojson(kind: GeoJsonKind, ids?: string[]): Promise<FeatureCollection>;
+    loadProgress(): Promise<LoadProgress>;
+    /**
+     * 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.
+     */
+    geojsonStream(kind: GeoJsonKind, onMessage: (message: NdjsonMessage) => void, signal?: AbortSignal): Promise<void>;
+    /**
+     * Load a feed: an uploaded zip, a chosen folder's files, a local path, or a
+     * URL for the server to download.
+     */
+    load(input: {
+        path?: string;
+        url?: string;
+        file?: File;
+        files?: File[];
+        name?: string;
+    }): Promise<TablesResponse>;
+}

package/dist/sources/types.d.ts

@@ -0,0 +1,252 @@
+/**
+ * The data contract the UI depends on.
+ *
+ * These types mirror the pydantic models in src/gtfs_garage/server/models.py,
+ * which FastAPI publishes as OpenAPI. Any implementation of `GtfsSource` can
+ * drive the UI: `RestSource` talks to the local Python server, and a future
+ * DuckDB-WASM implementation could read Parquet over HTTP range requests
+ * without the UI knowing the difference.
+ */
+import type { NdjsonMessage } from "./ndjson";
+export interface RelatedLink {
+    table: string;
+    column: string;
+}
+/**
+ * What GTFS says an empty value means for a field.
+ *
+ * `code` is one of the field's own enum codes - "0 or empty - Regularly
+ * scheduled pickup" - and is null only where the implied meaning has no code,
+ * as for `fare_attributes.transfers`, whose empty value means unlimited
+ * transfers.
+ */
+export interface ImpliedValue {
+    code: string | null;
+    label: string;
+}
+/**
+ * Whether a feed-scope condition holds in the feed now loaded. `evidence` is
+ * what the check counted to decide - "3 agencies" - so the answer can be read
+ * back rather than trusted.
+ */
+export interface ConditionOutcome {
+    holds: boolean;
+    evidence: string;
+}
+export interface ColumnInfo {
+    name: string;
+    /** Set only when the referenced table and column exist in this feed. */
+    fk_table: string | null;
+    fk_column: string | null;
+    /** GTFS defines a small fixed value set, so offer a picklist. */
+    enum_like: boolean;
+    /** Always present; empty unless this column is its table's primary id. */
+    related: RelatedLink[];
+    /**
+     * What GTFS says the field holds - ID, ENUM, COLOR, LATITUDE, DATE and so on.
+     * Null for a column the schema does not describe, such as a producer's own
+     * extension column, which renders as text.
+     */
+    type: string | null;
+    /** For an enumeration, its codes and their labels; null otherwise. */
+    values: Record<string, string> | null;
+    /** "always", "conditional", or null where GTFS makes the field optional. */
+    required: string | null;
+    /**
+     * For a conditionally required field, the condition in words - "Required if
+     * route_long_name is empty." Null otherwise.
+     */
+    condition: string | null;
+    /**
+     * What decides the condition: "row" where the row settles it, "feed" where
+     * the feed as a whole does, "row_context" where it varies row by row and the
+     * row does not carry what decides it. Null unless the field is conditional.
+     */
+    condition_scope: string | null;
+    /**
+     * The answer for this feed, for a "feed" scope. Null for any other scope, and
+     * null when the check could not run.
+     */
+    condition_outcome: ConditionOutcome | null;
+    /** What an empty value implies, where GTFS defines it. Null otherwise. */
+    when_empty: ImpliedValue | null;
+    /**
+     * What a value of this field's type must look like, from the schema's
+     * `fieldTypes`. The rule is declared there rather than here so there is one
+     * copy of it; all four are null for a type GTFS states no format for.
+     */
+    pattern: string | null;
+    minimum: number | null;
+    maximum: number | null;
+    /** GTFS's own definition of the type, for when a value does not match it. */
+    type_description: string | null;
+}
+/**
+ * Why GTFS says this feed should not contain this file. The counterpart to
+ * `MissingFile`: that one is absent and needed, this one present and not wanted.
+ */
+export interface FileCondition {
+    condition: string;
+    outcome: ConditionOutcome;
+}
+export interface TableInfo {
+    name: string;
+    row_count: number;
+    columns: ColumnInfo[];
+    /** Set only where GTFS forbids this file and the condition holds here. */
+    forbidden: FileCondition | null;
+}
+/** What one .txt file cost to open. */
+export interface FileMetrics {
+    name: string;
+    table: string;
+    /** Uncompressed size on disk. */
+    bytes: number;
+    /** Only for zip sources; a chosen folder has no compressed form. */
+    compressed_bytes: number | null;
+    /** Declaring the DuckDB view. Views are lazy, so this is near zero. */
+    register_ms: number;
+    /** Rewriting this table as Parquet; null when opened with --no-parquet. */
+    convert_ms: number | null;
+    /** What the table occupies once converted, usually far below `bytes`. */
+    parquet_bytes: number | null;
+    /** The COUNT(*) that actually scans the file - the real read cost. */
+    count_ms: number | null;
+    row_count: number | null;
+    columns: number;
+}
+/** Server-side sizes and timings for the feed currently loaded. */
+export interface LoadMetrics {
+    /**
+     * Phases this source actually performed, in order.
+     *
+     * A source that is not a server load describes its own work rather than
+     * leaving the fields below to be filled with zeroes: a browser reading
+     * Parquet never downloaded or unzipped anything, and saying it took 0 ms to
+     * do so would be a claim about work that did not happen.
+     */
+    phases?: {
+        label: string;
+        ms: number;
+        note?: string;
+    }[];
+    /**
+     * The fields below describe a server load, and are absent for a source that
+     * did not perform one. A browser reading Parquet never downloaded, unzipped
+     * or converted anything, and a zero here would claim the work took no time
+     * rather than that it never happened - which is what `phases` exists for.
+     */
+    kind?: "path" | "upload" | "folder" | "download";
+    /** Downloading or receiving the upload; null for a local path. */
+    acquire_ms?: number | null;
+    acquire_bytes?: number | null;
+    /** Unzipping; null when the source was already-extracted files. */
+    extract_ms?: number | null;
+    register_ms?: number;
+    /** Converting to Parquet; null when opened with --no-parquet. */
+    convert_ms?: number | null;
+    count_ms?: number;
+    /** The phases above added together. */
+    total_ms: number;
+    /** The zip's size, or the sum of the .txt files in a folder. */
+    total_bytes: number;
+    /** What the feed occupies to query once converted; null when it was not. */
+    stored_bytes: number | null;
+    files: FileMetrics[];
+}
+/** Where a running load has got to, polled while the load is in flight. */
+export interface LoadProgress {
+    phase: "start" | "download" | "upload" | "extract" | "convert" | "summarise" | "done";
+    done: number;
+    /** 0 when the total is not knowable, e.g. a download with no Content-Length. */
+    total: number;
+    detail: string;
+    running: boolean;
+}
+/**
+ * A file the feed does not have and needs - required, or conditionally required
+ * with the condition holding here. Files it merely could have are not listed.
+ */
+export interface MissingFile {
+    name: string;
+    presence: string;
+    condition: string | null;
+    condition_outcome: ConditionOutcome | null;
+}
+export interface TablesResponse {
+    source: string;
+    tables: TableInfo[];
+    missing: MissingFile[];
+    /**
+     * What the feed cost to open. Absent for a source with no load to report -
+     * a browser reading Parquet did not download, unzip or convert anything.
+     */
+    metrics?: LoadMetrics;
+}
+/** Row values are strings or null: every column is read as text. */
+export type Row = (string | null)[];
+export interface PageResponse {
+    columns: string[];
+    rows: Row[];
+    total: number;
+    page: number;
+    page_size: number;
+}
+/** `value: null` means the field is empty in the feed. */
+export interface ValueCount {
+    value: string | null;
+    count: number;
+}
+export type FilterOperator = "eq" | "ne" | "contains" | "in" | "is_empty" | "is_not_empty";
+export interface Filter {
+    column: string;
+    op: FilterOperator;
+    value?: string;
+}
+export interface AppConfig {
+    /** Preset name, raster tile template, or vector style URL. */
+    basemap: string;
+    version: string;
+}
+export type GeoJsonKind = "stops" | "shapes" | "routes" | "locations";
+export interface FeatureCollection {
+    type: "FeatureCollection";
+    features: GeoFeature[];
+}
+export interface GeoFeature {
+    type: "Feature";
+    geometry: {
+        type: string;
+        coordinates: unknown;
+    } | null;
+    properties: Record<string, string>;
+}
+/**
+ * What a whole viewer needs, which is more than a table needs.
+ *
+ * `GtfsSource` answers the table. The map additionally streams, because a large
+ * feed's shapes arrive over seconds and are drawn as they land rather than all
+ * at the end - so a host supplying its own source implements this, not just
+ * `GtfsSource`. `config` is optional: it exists on the REST source, where the
+ * basemap is a server setting, and a host that passes `basemap` needs neither.
+ */
+export interface ViewerSource extends GtfsSource {
+    geojsonStream(kind: GeoJsonKind, onMessage: (message: NdjsonMessage) => void, signal?: AbortSignal): Promise<void>;
+    config?(): Promise<AppConfig>;
+    /**
+     * Release whatever the source is holding.
+     *
+     * A REST source holds nothing; one querying Parquet holds a WebAssembly
+     * instance and a worker, and browsers allow only a handful. Whoever created
+     * the source calls this - so `mountDataset` closes the source its provider
+     * handed it, while `mount` leaves a caller-supplied one alone, because the
+     * caller may be reusing it.
+     */
+    close?(): Promise<void>;
+}
+export interface GtfsSource {
+    tables(): Promise<TablesResponse>;
+    query(table: string, filters: Filter[], page: number, pageSize: number): Promise<PageResponse>;
+    distinct(table: string, column: string, limit?: number): Promise<ValueCount[]>;
+    geojson(kind: GeoJsonKind, ids?: string[]): Promise<FeatureCollection>;
+}

package/dist/state.d.ts

@@ -0,0 +1,35 @@
+import type { ColumnInfo, Filter, MissingFile, TableInfo } from "./sources/types";
+/** One browsable view: a table, its filters and which page of it. */
+export interface View {
+    table: string;
+    filters: Filter[];
+    page: number;
+}
+export interface AppState {
+    tables: TableInfo[];
+    /** Files GTFS says this feed needs and it does not have. */
+    missing: MissingFile[];
+    columnInfoByName: Record<string, ColumnInfo>;
+    view: View;
+    pageSize: number;
+    /**
+     * Which shape draws each route, so a row's route can be highlighted.
+     *
+     * Just the two ids, not the geometry: holding the whole routes collection to
+     * answer one lookup cost hundreds of megabytes on a large feed, and the
+     * shape is a cheap fetch when it is actually wanted.
+     */
+    routeShapes: Map<string, string>;
+    mapDataLoaded: boolean;
+    /**
+     * Show the characters the feed contains instead of formatted values.
+     *
+     * A display preference, not part of the view: it is deliberately kept out of
+     * `View` so that toggling it does not push a history entry, and out of the
+     * URL so that Back still means the previous table rather than the previous
+     * rendering.
+     */
+    rawValues: boolean;
+}
+export declare function createState(): AppState;
+export declare function tableInfo(state: AppState, name: string): TableInfo | undefined;

package/dist/ui/feed-loader.d.ts

@@ -0,0 +1,35 @@
+/** The overlay for opening a feed: drop a zip, pick a file, or give a path or URL. */
+import type { Dom } from "../dom";
+import type { RestSource } from "../sources/rest";
+import type { TablesResponse } from "../sources/types";
+export declare class FeedLoader {
+    private readonly dom;
+    private readonly source;
+    private readonly onLoaded;
+    /** Whether there is a loaded feed to return to when cancelling. */
+    private readonly canCancel;
+    private busy;
+    constructor(dom: Dom, source: RestSource, onLoaded: (tables: TablesResponse, clientMs: number) => void, 
+    /** Whether there is a loaded feed to return to when cancelling. */
+    canCancel: () => boolean);
+    open(): void;
+    close(): void;
+    /**
+     * 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.
+     */
+    private loadFolder;
+    /** A path or URL is sent to a different parameter, so the server knows which. */
+    private submitTyped;
+    private syncSubmitState;
+    /**
+     * 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.
+     */
+    private pollProgress;
+    private load;
+}

package/dist/ui/feed-metrics.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The load report: what opening the current feed cost, per phase and per file.
+ *
+ * The numbers come from the server, with one exception - the round trip the
+ * browser waited for, which only the browser can see. Formatting and ordering
+ * live in exported functions so they can be tested without a document, the
+ * same arrangement as `Navigator.parseUrl`.
+ */
+import type { Dom } from "../dom";
+import type { LoadMetrics } from "../sources/types";
+export declare function formatBytes(bytes: number): string;
+export declare function formatMs(ms: number): string;
+/** The one-line summary shown in the header. */
+export declare function summaryLine(metrics: LoadMetrics, clientMs?: number): string;
+/** The phases that actually happened, in the order they happened. */
+export declare function phaseRows(metrics: LoadMetrics): Array<[string, string]>;
+export interface FileRow {
+    name: string;
+    bytes: string;
+    /** Share of the feed's uncompressed size, as a whole percentage. */
+    share: number;
+    compressed: string;
+    /** Size as Parquet; an em dash when the feed was not converted. */
+    stored: string;
+    /**
+     * What this file cost: converting it, or counting it when the feed was left
+     * as CSV. One number rather than two, because the two the report used to show
+     * were measured against different storage - the header read happens on the
+     * CSV before conversion and the row count on the Parquet after it - so
+     * reading them side by side told you nothing.
+     */
+    costMs: string;
+    rows: string;
+    columns: number;
+}
+/**
+ * Largest file first: the point of the report is to name the file that
+ * dominated the load, and on a real feed that is almost always stop_times.txt.
+ */
+export declare function fileRows(metrics: LoadMetrics): FileRow[];
+/**
+ * Fills the header summary and the panel it expands into. The panel starts
+ * closed: a load report should be there when wanted, not in the way.
+ */
+export declare function renderMetrics(dom: Dom, metrics: LoadMetrics, clientMs?: number): void;
+/** Wires the summary button to the panel it opens. Called once, at startup. */
+export declare function initMetricsPanel(dom: Dom): void;

package/dist/ui/filters.d.ts

@@ -0,0 +1,18 @@
+/** The filter bar: active filter chips, and the form that adds a new one. */
+import type { Dom } from "../dom";
+import type { Filter, GtfsSource } from "../sources/types";
+import type { AppState } from "../state";
+export declare class FilterBar {
+    private readonly dom;
+    private readonly state;
+    private readonly source;
+    private readonly onChange;
+    constructor(dom: Dom, state: AppState, source: GtfsSource, onChange: (filters: Filter[]) => void);
+    render(): void;
+    /**
+     * Enumerated columns get a picklist of the values actually present, with
+     * counts, so nobody has to guess what a feed uses.
+     */
+    private updateValueInput;
+    private apply;
+}

package/dist/ui/history.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Where a viewer's back stack lives.
+ *
+ * The application owns its page, so its stack is the browser's own history and
+ * the URL describes the current view - that is what makes a view reloadable and
+ * shareable. A viewer embedded in someone else's page must not do that: writing
+ * to `history` from a component fights the host's router, and the host may well
+ * want the view in its URL under a different scheme, or not at all.
+ *
+ * So the browser is one implementation of this port rather than an assumption
+ * baked into `Navigator`. `memoryHistory` is the other, and is what an embedded
+ * viewer uses: the same back behaviour, kept to itself.
+ */
+import type { View } from "../state";
+export interface HistoryEntry {
+    view: View;
+    /** How deep into the stack this entry is, so Back knows when to stop. */
+    depth: number;
+    /** Which feed the view describes; entries from an older feed are ignored. */
+    feed: string;
+}
+export interface HistoryPort {
+    push(entry: HistoryEntry): void;
+    replace(entry: HistoryEntry): void;
+    back(): void;
+    /**
+     * Called when the user navigates back or forward. Returns a disposer: an
+     * embedded viewer is unmounted and remounted by its host, and a listener left
+     * on `window` would drive a viewer that no longer exists.
+     */
+    onPop(handler: (entry: HistoryEntry | null) => void): () => void;
+    /** The view this viewer should open on, if the location names one. */
+    initialView(): View | null;
+}
+/** `?table=stops&page=2&filters=[…]` - the shape a shared link has. */
+export declare function urlFor(view: View): string;
+/** Pure counterpart of reading `location.search`, so it is testable. */
+export declare function parseUrl(search: string): View | null;
+/** The back stack of an application that owns its page. */
+export declare function browserHistory(): HistoryPort;
+/**
+ * A back stack the viewer keeps to itself, for an embedded one.
+ *
+ * Nothing here touches the URL or `window`, which is the point: the host stays
+ * in charge of its own address bar, and can still mirror the view there by
+ * listening for view changes if it wants to.
+ */
+export declare function memoryHistory(initial?: View | null): HistoryPort;

package/dist/ui/load-progress.d.ts

@@ -0,0 +1,7 @@
+/** Turns a load-progress reading into the line shown while a feed opens. */
+import type { LoadProgress } from "../sources/types";
+/**
+ * `description` is what the user asked for, used until the server reports a
+ * phase - a load has to travel to the server before it can describe itself.
+ */
+export declare function progressLine(progress: LoadProgress | null, description: string): string;

package/dist/ui/navigation.d.ts

@@ -0,0 +1,60 @@
+/**
+ * View navigation.
+ *
+ * Every view change - table switch, filter change, page turn - goes through
+ * `apply`, so the in-app Back button and whatever the host uses for back are
+ * the same mechanism. Where the back stack lives is `HistoryPort`'s business:
+ * the browser's own history for the application, a private stack for a viewer
+ * embedded in someone else's page.
+ */
+import type { Dom } from "../dom";
+import type { Filter, TableInfo } from "../sources/types";
+import { type AppState, type View } from "../state";
+import { parseUrl, urlFor, type HistoryPort } from "./history";
+export type ViewListener = (view: View) => void;
+/**
+ * Where to land when a feed opens: what the feed says about itself, then who
+ * runs it, then what it runs.
+ */
+export declare const PREFERRED_TABLES: string[];
+/**
+ * Choose the first view of a feed.
+ *
+ * `restoreFrom` is only passed on page load, so a reloaded or shared URL comes
+ * back to the same place. Opening a different feed deliberately ignores it: its
+ * filters describe the previous feed's data and would either match nothing or,
+ * worse, silently hide rows in a table that happens to share a name.
+ */
+export declare function initialView(tables: TableInfo[], restoreFrom?: View | null): View | null;
+export declare class Navigator {
+    private readonly dom;
+    private readonly history;
+    private readonly state;
+    private readonly onChange;
+    private depth;
+    private feed;
+    /** Undoes the history subscription taken in the constructor. */
+    private readonly stopListening;
+    constructor(dom: Dom, history: HistoryPort, state: AppState, onChange: ViewListener);
+    /** Stop responding to the host's history. See `mount`'s `destroy`. */
+    destroy(): void;
+    private entryFor;
+    /** Re-exported so callers need not know where the URL shape is defined. */
+    static urlFor: typeof urlFor;
+    static parseUrl: typeof parseUrl;
+    /** The view named by the current location, for an app that owns its page. */
+    fromLocation(): View | null;
+    current(): 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(view: View, feed: string): void;
+    go(view: View): void;
+    /** Step back one view. Public so an embedding host can offer its own control. */
+    back(): void;
+    selectTable(table: string, filters?: Filter[]): void;
+    private apply;
+}

package/dist/ui/sidebar.d.ts

@@ -0,0 +1,21 @@
+import type { Dom } from "../dom";
+import type { AppState } from "../state";
+import type { MissingFile, TableInfo } from "../sources/types";
+/**
+ * Why a file the feed lacks is wanted.
+ *
+ * A required file needs no explanation. A conditionally required one does: the
+ * condition, and what makes it apply to this feed, because "calendar.txt is
+ * missing" is not actionable while "required unless calendar_dates.txt defines
+ * every service date - calendar_dates is absent" is.
+ */
+export declare function describeMissing(file: MissingFile): string;
+/**
+ * Why GTFS says this feed should not have this file.
+ *
+ * The other direction from `describeMissing`. Empty for the ordinary case, so
+ * a caller can use the result as the test of whether to say anything.
+ */
+export declare function describeForbidden(table: TableInfo): string;
+/** The list of the feed's files, with row counts, and any it is missing. */
+export declare function renderSidebar(dom: Dom, state: AppState, onSelect: (table: string) => void): void;