gtfs-garage-web 0.0.1

package/dist/ui/table.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The row grid: the part that makes IDs navigable.
+ *
+ * A foreign-key column renders as a link to the referenced table, filtered to
+ * the matching row. A table's own id column additionally offers "related"
+ * buttons for the reverse direction (a route to its trips, say). The server
+ * only reports links whose target exists in the loaded feed, so nothing here
+ * leads to a file the feed does not contain.
+ */
+import { type Dom } from "../dom";
+import type { Filter, PageResponse, RelatedLink } from "../sources/types";
+import type { AppState } from "../state";
+export interface RelatedButton {
+    link: RelatedLink;
+    label: string;
+    title: string;
+}
+/**
+ * How to label the reverse links under an id.
+ *
+ * A table can point at the same id from more than one column - `transfers` and
+ * `pathways` each reference a stop as both `from_stop_id` and `to_stop_id` - so
+ * labelling by table name alone renders two buttons that look identical and go
+ * to different places. The column is added only where a table appears more than
+ * once, which keeps the common label short, and the tooltip always names it.
+ */
+export declare function describeRelated(related: RelatedLink[]): RelatedButton[];
+/**
+ * Showing a row on the map.
+ *
+ * Every one is optional, and absent means the viewer has no map: a host that
+ * mounts without the map part gets no map buttons rather than buttons that do
+ * nothing. Granular rather than one flag because they already differ - a route
+ * is only highlightable once its shapes are known.
+ */
+export interface HighlightCallbacks {
+    onHighlightStop: (stopId: string) => void;
+    onHighlightShape: (shapeId: string) => void;
+    onHighlightRoute: (routeId: string) => void;
+    onHighlightLocation: (locationId: string) => void;
+}
+export interface TableCallbacks extends Partial<HighlightCallbacks> {
+    onNavigate: (table: string, filters: Filter[]) => void;
+    onPage: (page: number) => void;
+}
+export interface RowAction {
+    label: string;
+    title: string;
+    run: () => void;
+}
+/**
+ * Which map buttons a row should carry.
+ *
+ * Pure, so the rules are testable without a document - the same split the rest
+ * of this package uses, where `values.ts` decides and `table.ts` draws. A row
+ * offers an action only when it has the id for it *and* something can act on
+ * it.
+ */
+export declare function rowActions(values: Record<string, string | null>, context: {
+    table: string;
+    hasRouteShapes: boolean;
+}, callbacks: Partial<HighlightCallbacks>): RowAction[];
+export declare class TableView {
+    private readonly dom;
+    private readonly state;
+    private readonly callbacks;
+    /**
+     * 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.
+     */
+    private lastPage;
+    constructor(dom: Dom, state: AppState, callbacks: TableCallbacks);
+    /** Draw the current page again, picking up a changed display preference. */
+    redraw(): void;
+    showMessage(text: string): void;
+    render(page: PageResponse): void;
+    private buildRow;
+    private buildCell;
+    /**
+     * 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.
+     */
+    private renderValue;
+    /**
+     * 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.
+     */
+    private get hasActions();
+    private buildRowActions;
+    private renderPager;
+}

package/dist/ui/values.d.ts

@@ -0,0 +1,61 @@
+/**
+ * How to draw one cell's value, given what GTFS says the field holds.
+ *
+ * This decides; `table.ts` draws. Keeping the decision pure is what makes the
+ * cases that matter testable at all, since vitest runs without a document and
+ * the cases that matter are the malformed ones.
+ *
+ * Two rules govern everything here:
+ *
+ * 1. **A value that does not conform is shown as the string the feed contains.**
+ *    Never blanked, never corrected, never allowed to throw. This is the
+ *    project's existing principle - a feed with a malformed number still opens,
+ *    because type errors are what an inspection tool exists to reveal - applied
+ *    to rendering rather than to loading.
+ *
+ * 2. **A feed is untrusted input.** Only `http:`, `https:` and `mailto:` ever
+ *    become a link; anything else is text. Before this module, no feed value
+ *    was ever used as an `href`, so links are a new attack surface and
+ *    `javascript:` in a URL field must not survive it.
+ */
+import type { ColumnInfo } from "../sources/types";
+export interface Rendered {
+    /** What to show. Always a string; never empty unless the value was. */
+    text: string;
+    kind: "plain" | "numeric" | "link" | "color";
+    /** Only ever an http, https or mailto URL. */
+    href?: string;
+    /** Only ever `#RRGGBB`, from six hex digits. */
+    swatch?: string;
+    /** What was expected, when the value does not conform. Shown on hover. */
+    malformed?: string;
+    /**
+     * Set when the feed left this field empty and GTFS says what that means. The
+     * text is the implied value, not something the producer wrote, so it must be
+     * drawn in a way that cannot be mistaken for one.
+     */
+    implied?: string;
+}
+/**
+ * The only entry point, and the one place that can fail safely.
+ *
+ * Every formatter above is total, so the catch should never fire. It is here so
+ * that it cannot matter if a formatter added later is not - one malformed cell
+ * in a sixty-million-row feed must not blank a page.
+ *
+ * `raw` turns all of it off and returns the characters the file contains.
+ * Formatting is a reading aid, and a reading aid is the wrong thing when the
+ * question is what a producer actually wrote: `Aug 22, 2026` is easier to read
+ * than `20260822`, but only the second answers "is this field padded?". An
+ * inspection tool has to be able to stop interpreting.
+ */
+export declare function renderValue(value: string | null, column: ColumnInfo | undefined, raw?: boolean): Rendered;
+/**
+ * What to say about a column in its header tooltip.
+ *
+ * The schema knows more about a column than its name shows: what GTFS says it
+ * holds, whether it must be filled in, and - for a conditionally required
+ * field - the condition in words. "Conditionally required" on its own is not
+ * something a reader can act on; the condition is.
+ */
+export declare function describeColumn(column: ColumnInfo | undefined): string;

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "gtfs-garage-web",
+  "version": "0.0.1",
+  "description": "Browse a GTFS feed: a mountable viewer with a table, filters and a map.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build:lib": "vite build --config vite.lib.config.ts && yarn types",
+    "types": "tsc -p tsconfig.lib.json"
+  },
+  "devDependencies": {
+    "@duckdb/duckdb-wasm": "1.32.0",
+    "@types/node": "^22.20.2",
+    "@types/react": "^18.3.11",
+    "@types/react-dom": "^18.3.1",
+    "maplibre-gl": "^5.7.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.5",
+    "vitest": "^4.1.11"
+  },
+  "resolutions": {
+    "vite": "^6.0.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MobilityData/gtfs-garage.git",
+    "directory": "web"
+  },
+  "homepage": "https://github.com/MobilityData/gtfs-garage",
+  "keywords": [
+    "gtfs",
+    "transit",
+    "viewer",
+    "maplibre"
+  ],
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/mount.d.ts",
+  "module": "./dist/mount.js",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/mount.d.ts",
+      "import": "./dist/mount.js"
+    },
+    "./dataset": {
+      "types": "./dist/mount-dataset.d.ts",
+      "import": "./dist/dataset.js"
+    },
+    "./map": {
+      "types": "./dist/map-part.d.ts",
+      "import": "./dist/map.js"
+    },
+    "./parquet": {
+      "types": "./dist/sources/parquet.d.ts",
+      "import": "./dist/parquet.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./style.css": "./dist/gtfs-garage-web.css",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@duckdb/duckdb-wasm": "^1.32.0",
+    "maplibre-gl": "^5.0.0",
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "@duckdb/duckdb-wasm": {
+      "optional": true
+    },
+    "maplibre-gl": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  }
+}