bangkok-train-fare 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# bangkok-train-fare
+
+TypeScript utilities for Bangkok train station lookup, route building, and fare estimation.
+
+This package is experimental. Fare rules and network data are manually maintained and may lag official updates.
+
+## Usage
+
+```bash
+npm install bangkok-train-fare
+```
+
+```ts
+import { calculateFare, searchStation } from "bangkok-train-fare";
+
+const result = calculateFare("BL01", "BL02");
+console.log(result.fare);
+
+const stations = await searchStation("Siam");
+console.log(stations);
+```
+
+## API
+
+- `calculateFare(origin, destination)`
+- `buildPath(origin, destination)`
+- `calculateGreenFare(stations)`
+- `searchStation(keyword)`
+- `searchByCode(code)`
+
+## Publishing
+
+The repository includes GitHub Actions workflows for CI, snapshot packages, and stable releases.
+
+Snapshots are published with the `snapshot` npm dist-tag by manually running the `Publish` workflow with `channel=snapshot`:
+
+```bash
+npm install bangkok-train-fare@snapshot
+```
+
+Stable releases are published by updating `package.json` version, committing it, and pushing a matching tag:
+
+```bash
+npm version patch
+git push origin main --tags
+```
+
+Publishing uses npm trusted publishing through GitHub Actions OIDC. Configure the package on npm with:
+
+- Owner: `kratuwu`
+- Repository: `bangkok-train-fare`
+- Workflow filename: `publish.yml`
+- Environment: `npm`

package/dist/fare/fareEngine.d.ts

@@ -0,0 +1,6 @@
+export { calculateGreenFare } from "./greenFareCalculator.js";
+import { buildPath } from "./pathfinder.js";
+export type FareResult = ReturnType<typeof buildPath> & {
+    fare: number;
+};
+export declare function calculateFare(origin: string, destination: string): FareResult;

package/dist/fare/fareEngine.js

@@ -0,0 +1,6 @@
+export { calculateGreenFare } from "./greenFareCalculator.js";
+import { buildPath } from "./pathfinder.js";
+export function calculateFare(origin, destination) {
+    const { pathes, cost } = buildPath(origin, destination);
+    return { fare: cost, cost, pathes };
+}

package/dist/fare/farePolicy.d.ts

@@ -0,0 +1,7 @@
+export declare function blueFare(distance: number): number;
+export declare function purpleFare(distance: number): number;
+export declare function yellowFare(distance: number): number;
+export declare function pinkFare(distance: number): number;
+export declare function transferDiscount(toLine: string): number;
+export declare function greenFare(distance: number): number;
+export declare function extendedGreenFare(distance: number): number;

package/dist/fare/farePolicy.js

@@ -0,0 +1,155 @@
+export function blueFare(distance) {
+    if (distance === 0)
+        return 16;
+    if (distance === 1)
+        return 17;
+    if (distance === 2)
+        return 20;
+    if (distance === 3)
+        return 22;
+    if (distance === 4)
+        return 25;
+    if (distance === 5)
+        return 27;
+    if (distance === 6)
+        return 30;
+    if (distance === 7)
+        return 32;
+    if (distance === 8)
+        return 35;
+    if (distance === 9)
+        return 37;
+    if (distance === 10)
+        return 40;
+    if (distance === 11)
+        return 42;
+    else
+        return 45;
+}
+export function purpleFare(distance) {
+    if (distance === 0)
+        return 14;
+    if (distance === 1)
+        return 17;
+    if (distance === 2)
+        return 20;
+    if (distance === 3)
+        return 23;
+    if (distance === 4)
+        return 25;
+    if (distance === 5)
+        return 27;
+    if (distance === 6)
+        return 30;
+    if (distance === 7)
+        return 33;
+    if (distance === 8)
+        return 36;
+    if (distance === 9)
+        return 38;
+    if (distance === 10)
+        return 40;
+    else
+        return 42;
+}
+export function yellowFare(distance) {
+    if (distance === 0)
+        return 15;
+    if (distance === 1)
+        return 19;
+    if (distance === 2)
+        return 23;
+    if (distance === 3)
+        return 27;
+    if (distance === 4)
+        return 30;
+    if (distance === 5)
+        return 33;
+    if (distance === 6)
+        return 36;
+    if (distance === 7)
+        return 39;
+    if (distance === 8)
+        return 42;
+    else
+        return 45;
+}
+export function pinkFare(distance) {
+    if (distance === 0)
+        return 15;
+    if (distance === 1)
+        return 18;
+    if (distance === 2)
+        return 23;
+    if (distance === 3)
+        return 28;
+    if (distance === 4)
+        return 30;
+    if (distance === 5)
+        return 34;
+    if (distance === 6)
+        return 37;
+    if (distance === 7)
+        return 41;
+    if (distance === 8)
+        return 44;
+    else
+        return 45;
+}
+export function transferDiscount(toLine) {
+    if (toLine === "BL")
+        return -14;
+    if (toLine === "PP")
+        return -14;
+    if (toLine === "YL")
+        return -15;
+    if (toLine === "PU")
+        return -15;
+    return 0;
+}
+export function greenFare(distance) {
+    if (distance === 0)
+        return 17;
+    if (distance === 1)
+        return 17;
+    if (distance === 2)
+        return 25;
+    if (distance === 3)
+        return 28;
+    if (distance === 4)
+        return 32;
+    if (distance === 5)
+        return 35;
+    if (distance === 6)
+        return 40;
+    if (distance === 7)
+        return 43;
+    return 47;
+}
+export function extendedGreenFare(distance) {
+    if (distance === 0)
+        return 17;
+    if (distance === 1)
+        return 17;
+    if (distance === 2)
+        return 22;
+    if (distance === 3)
+        return 24;
+    if (distance === 4)
+        return 27;
+    if (distance === 5)
+        return 29;
+    if (distance === 6)
+        return 32;
+    if (distance === 7)
+        return 34;
+    if (distance === 7)
+        return 37;
+    if (distance === 7)
+        return 39;
+    if (distance === 7)
+        return 42;
+    if (distance === 7)
+        return 44;
+    return 45;
+}

package/dist/fare/graph.d.ts

@@ -0,0 +1,12 @@
+export declare const GRAPH: Record<string, string[]>;
+type LineName = "blue" | "green" | "orange" | "pink" | "purple" | "yellow";
+declare function normalize(code: string): string;
+declare function isBlue(code: string): boolean;
+declare function isPurple(code: string): boolean;
+declare function isPink(code: string): boolean;
+declare function isOrange(code: string): boolean;
+declare function isYellow(code: string): boolean;
+declare function isGreen(code: string): boolean;
+export declare function getLine(code: string): LineName;
+export declare function isExtendedGreen(code: string): boolean;
+export { isBlue, isPurple, isPink, isYellow, isOrange, isGreen, normalize };

package/dist/fare/graph.js

@@ -0,0 +1,172 @@
+import network from "./network.json" with { type: "json" };
+export const GRAPH = {};
+const LINE_NAMES = new Set([
+    "blue",
+    "green",
+    "orange",
+    "pink",
+    "purple",
+    "yellow",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isLineName(value) {
+    return typeof value === "string" && LINE_NAMES.has(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isStationRange(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.prefix === "string" &&
+        typeof value.start === "number" &&
+        typeof value.end === "number" &&
+        (value.padCode === undefined || typeof value.padCode === "boolean") &&
+        (value.cyclic === undefined || typeof value.cyclic === "boolean"));
+}
+function isNetworkLine(value) {
+    if (!isRecord(value))
+        return false;
+    return (isLineName(value.name) &&
+        (value.prefixes === undefined || isStringArray(value.prefixes)) &&
+        (value.stations === undefined || isStringArray(value.stations)) &&
+        Array.isArray(value.ranges) &&
+        value.ranges.every(isStationRange));
+}
+function isEdge(value) {
+    return (Array.isArray(value) &&
+        value.length === 2 &&
+        typeof value[0] === "string" &&
+        typeof value[1] === "string");
+}
+function isAliases(value) {
+    return (isRecord(value) &&
+        Object.values(value).every((item) => typeof item === "string"));
+}
+function parseNetworkData(value) {
+    if (!isRecord(value)) {
+        throw new Error("Invalid train fare network data");
+    }
+    const { aliases, edges, lines } = value;
+    if (!Array.isArray(lines) ||
+        !lines.every(isNetworkLine) ||
+        !Array.isArray(edges) ||
+        !edges.every(isEdge) ||
+        !isAliases(aliases)) {
+        throw new Error("Invalid train fare network data");
+    }
+    return { aliases, edges, lines };
+}
+const networkData = parseNetworkData(network);
+const stationLines = {};
+const prefixLines = {};
+function stationCode(prefix, index, padCode = true) {
+    const codeNumber = padCode ? String(index).padStart(2, "0") : String(index);
+    return `${prefix}${codeNumber}`;
+}
+function ensureStation(code) {
+    GRAPH[code] ??= [];
+}
+function assignStationLine(code, line) {
+    stationLines[code] = line;
+}
+function assignPrefixLine(prefix, line) {
+    prefixLines[prefix] = line;
+}
+function connect(a, b) {
+    ensureStation(a);
+    ensureStation(b);
+    if (!GRAPH[a].includes(b))
+        GRAPH[a].push(b);
+    if (!GRAPH[b].includes(a))
+        GRAPH[b].push(a);
+}
+function createStations({ prefix, start, end, padCode = true }) {
+    for (let i = start; i <= end; i++) {
+        ensureStation(stationCode(prefix, i, padCode));
+    }
+}
+function connectStations({ prefix, start, end, padCode = true, cyclic = false, }) {
+    for (let i = start; i < end; i++) {
+        connect(stationCode(prefix, i, padCode), stationCode(prefix, i + 1, padCode));
+    }
+    if (cyclic) {
+        connect(stationCode(prefix, end, padCode), stationCode(prefix, start, padCode));
+    }
+}
+function createLine(range) {
+    createStations(range);
+    connectStations(range);
+}
+function registerLine(line) {
+    for (const prefix of line.prefixes ?? []) {
+        assignPrefixLine(prefix, line.name);
+    }
+    for (const station of line.stations ?? []) {
+        ensureStation(station);
+        assignStationLine(station, line.name);
+    }
+    for (const range of line.ranges) {
+        assignPrefixLine(range.prefix, line.name);
+        createLine(range);
+        for (let i = range.start; i <= range.end; i++) {
+            assignStationLine(stationCode(range.prefix, i, range.padCode), line.name);
+        }
+    }
+}
+for (const line of networkData.lines) {
+    registerLine(line);
+}
+for (const [from, to] of networkData.edges) {
+    connect(from, to);
+}
+function normalize(code) {
+    return networkData.aliases[code] ?? code;
+}
+function matchesLine(code, line) {
+    if (stationLines[code] === line)
+        return true;
+    return Object.entries(prefixLines).some(([prefix, prefixLine]) => prefixLine === line && code.startsWith(prefix));
+}
+function isBlue(code) {
+    return matchesLine(code, "blue");
+}
+function isPurple(code) {
+    return matchesLine(code, "purple");
+}
+function isPink(code) {
+    return matchesLine(code, "pink");
+}
+function isOrange(code) {
+    return matchesLine(code, "orange");
+}
+function isYellow(code) {
+    return matchesLine(code, "yellow");
+}
+function isGreen(code) {
+    return matchesLine(code, "green");
+}
+export function getLine(code) {
+    const line = stationLines[code];
+    if (line)
+        return line;
+    const prefixLine = Object.entries(prefixLines).find(([prefix]) => code.startsWith(prefix))?.[1];
+    if (prefixLine)
+        return prefixLine;
+    throw new Error("Unknown station code");
+}
+export function isExtendedGreen(code) {
+    if (code === "CEN" || code === "W1")
+        return false;
+    const stationNumber = Number.parseInt(code.slice(1), 10);
+    if (Number.isNaN(stationNumber))
+        return false;
+    if (code.startsWith("N") || code.startsWith("S"))
+        return stationNumber >= 9;
+    if (code.startsWith("E"))
+        return stationNumber >= 10;
+    return false;
+}
+export { isBlue, isPurple, isPink, isYellow, isOrange, isGreen, normalize };

package/dist/fare/greenFareCalculator.d.ts

@@ -0,0 +1 @@
+export declare function calculateGreenFare(stations: string[]): number;

package/dist/fare/greenFareCalculator.js

@@ -0,0 +1,15 @@
+import { extendedGreenFare, greenFare } from "./farePolicy.js";
+import { isExtendedGreen } from "./graph.js";
+export function calculateGreenFare(stations) {
+    if (stations.length <= 1)
+        return greenFare(0);
+    const totalStops = stations.length - 1;
+    const extStart = stations.findIndex(isExtendedGreen);
+    if (extStart < 0)
+        return greenFare(totalStops);
+    if (extStart === 0)
+        return extendedGreenFare(totalStops);
+    const baseStops = extStart - 1;
+    const extStops = stations.length - extStart;
+    return Math.min(greenFare(baseStops) + extendedGreenFare(extStops), 65);
+}

package/dist/fare/index.d.ts

@@ -0,0 +1,4 @@
+export { calculateFare, calculateGreenFare, type FareResult, } from "./fareEngine.js";
+export { buildPath, type BuiltPathResult, type BuiltPathStep, } from "./pathfinder.js";
+export { blueFare, extendedGreenFare, greenFare, pinkFare, purpleFare, transferDiscount, yellowFare, } from "./farePolicy.js";
+export { GRAPH, getLine, isBlue, isExtendedGreen, isGreen, isOrange, isPink, isPurple, isYellow, normalize, } from "./graph.js";

package/dist/fare/index.js

@@ -0,0 +1,4 @@
+export { calculateFare, calculateGreenFare, } from "./fareEngine.js";
+export { buildPath, } from "./pathfinder.js";
+export { blueFare, extendedGreenFare, greenFare, pinkFare, purpleFare, transferDiscount, yellowFare, } from "./farePolicy.js";
+export { GRAPH, getLine, isBlue, isExtendedGreen, isGreen, isOrange, isPink, isPurple, isYellow, normalize, } from "./graph.js";

package/dist/fare/network.json

@@ -0,0 +1,68 @@
+{
+    "lines": [
+        {
+            "name": "blue",
+            "ranges": [
+                { "prefix": "BL", "start": 1, "end": 32, "cyclic": true },
+                { "prefix": "BL", "start": 33, "end": 38 }
+            ]
+        },
+        {
+            "name": "purple",
+            "ranges": [{ "prefix": "PP", "start": 1, "end": 16 }]
+        },
+        {
+            "name": "yellow",
+            "ranges": [{ "prefix": "YL", "start": 1, "end": 23 }]
+        },
+        {
+            "name": "pink",
+            "ranges": [
+                { "prefix": "MT", "start": 1, "end": 2 },
+                { "prefix": "PK", "start": 1, "end": 30 }
+            ]
+        },
+        {
+            "name": "orange",
+            "prefixes": ["OL"],
+            "ranges": []
+        },
+        {
+            "name": "green",
+            "stations": ["CEN", "W1"],
+            "ranges": [
+                { "prefix": "N", "start": 1, "end": 5, "padCode": false },
+                { "prefix": "N", "start": 7, "end": 24, "padCode": false },
+                { "prefix": "E", "start": 1, "end": 23, "padCode": false },
+                { "prefix": "S", "start": 1, "end": 12, "padCode": false }
+            ]
+        }
+    ],
+    "edges": [
+        ["BL01", "BL33"],
+        ["BL10", "PP16"],
+        ["YL01", "BL15"],
+        ["PK10", "MT01"],
+        ["PP11", "PK01"],
+        ["N5", "N7"],
+        ["N1", "CEN"],
+        ["CEN", "E1"],
+        ["W1", "CEN"],
+        ["CEN", "S1"],
+        ["E4", "BL22"],
+        ["S2", "BL26"],
+        ["E15", "YL23"]
+    ],
+    "aliases": {
+        "BL10": "TAOPOON",
+        "PP16": "TAOPOON",
+        "BL15": "LARDPRAO",
+        "YL01": "LARDPRAO",
+        "BL22": "ASOK",
+        "E4": "ASOK",
+        "BL26": "SALDAENG",
+        "S2": "SALDAENG",
+        "E15": "SAMRONG",
+        "YL23": "SAMRONG"
+    }
+}

package/dist/fare/pathfinder.d.ts

@@ -0,0 +1,21 @@
+type PathSegment = {
+    type: "segment";
+    line: string;
+    from: string;
+    to: string;
+    stops: number;
+    stations: string[];
+};
+type PathChange = {
+    type: "change";
+    from: string;
+    to: string;
+    toLine: string;
+};
+export type BuiltPathStep = PathSegment | PathChange;
+export type BuiltPathResult = {
+    pathes: BuiltPathStep[];
+    cost: number;
+};
+export declare function buildPath(origin: string, dest: string): BuiltPathResult;
+export {};

package/dist/fare/pathfinder.js

@@ -0,0 +1,149 @@
+import { getLine, GRAPH } from "./graph.js";
+import { blueFare, pinkFare, purpleFare, yellowFare, transferDiscount, } from "./farePolicy.js";
+import { calculateGreenFare } from "./greenFareCalculator.js";
+function getLineFareByStops(line, stops) {
+    if (line === "blue")
+        return blueFare(stops);
+    if (line === "pink")
+        return pinkFare(stops);
+    if (line === "purple")
+        return purpleFare(stops);
+    if (line === "yellow")
+        return yellowFare(stops);
+    return 0;
+}
+function getLineFare(line, stations) {
+    if (line === "green")
+        return calculateGreenFare(stations);
+    return getLineFareByStops(line, stations.length - 1);
+}
+function getFarePolicyLineCode(line) {
+    if (line === "blue")
+        return "BL";
+    if (line === "purple")
+        return "PP";
+    if (line === "yellow")
+        return "YL";
+    if (line === "pink")
+        return "PU";
+    if (line === "orange")
+        return "OL";
+    return line;
+}
+function getTransferDiscount(line) {
+    return transferDiscount(getFarePolicyLineCode(line));
+}
+function cheapestPath(start, end) {
+    const startLine = getLine(start);
+    if (start === end) {
+        return {
+            stations: [start],
+            cost: getLineFare(startLine, [start]),
+        };
+    }
+    const queue = [
+        {
+            station: start,
+            line: startLine,
+            stationsOnLine: [start],
+            completedCost: 0,
+            totalCost: getLineFare(startLine, [start]),
+            path: [start],
+        },
+    ];
+    const visited = new Map();
+    while (queue.length > 0) {
+        queue.sort((a, b) => a.totalCost - b.totalCost);
+        const state = queue.shift();
+        const stateKey = `${state.station}:${state.line}`;
+        if (visited.has(stateKey) && visited.get(stateKey) <= state.totalCost) {
+            continue;
+        }
+        visited.set(stateKey, state.totalCost);
+        if (state.station === end) {
+            return {
+                stations: state.path,
+                cost: state.totalCost,
+            };
+        }
+        for (const neighbor of GRAPH[state.station] || []) {
+            const neighborLine = getLine(neighbor);
+            let completedCost = state.completedCost;
+            let stationsOnLine = state.stationsOnLine;
+            let totalCost = state.totalCost;
+            if (neighborLine === state.line) {
+                stationsOnLine = [...state.stationsOnLine, neighbor];
+                totalCost = completedCost + getLineFare(state.line, stationsOnLine);
+            }
+            else {
+                completedCost =
+                    state.completedCost +
+                        getLineFare(state.line, state.stationsOnLine) +
+                        getTransferDiscount(neighborLine);
+                stationsOnLine = [neighbor];
+                totalCost = completedCost + getLineFare(neighborLine, stationsOnLine);
+            }
+            const neighborStateKey = `${neighbor}:${neighborLine}`;
+            if (!visited.has(neighborStateKey) ||
+                totalCost < visited.get(neighborStateKey)) {
+                queue.push({
+                    station: neighbor,
+                    line: neighborLine,
+                    stationsOnLine,
+                    completedCost,
+                    totalCost,
+                    path: [...state.path, neighbor],
+                });
+            }
+        }
+    }
+    throw new Error("Path not found");
+}
+export function buildPath(origin, dest) {
+    const { stations: pathes, cost } = cheapestPath(origin, dest);
+    const result = [];
+    let start = pathes[0];
+    let line = getLine(start);
+    let stops = 0;
+    let stations = [pathes[0]];
+    for (let i = 1; i < pathes.length; i++) {
+        const station = pathes[i];
+        const stationLine = getLine(station);
+        if (stationLine === line) {
+            stops++;
+            stations.push(station);
+        }
+        else {
+            result.push({
+                type: "segment",
+                line,
+                from: start,
+                to: pathes[i - 1],
+                stops,
+                stations: [...stations],
+            });
+            result.push({
+                type: "change",
+                from: pathes[i - 1],
+                to: station,
+                toLine: stationLine,
+            });
+            start = station;
+            line = stationLine;
+            stops = 0;
+            stations = [station];
+        }
+    }
+    result.push({
+        type: "segment",
+        line,
+        from: start,
+        to: pathes[pathes.length - 1],
+        stops,
+        stations: [...stations],
+    });
+    return {
+        pathes: result,
+        cost,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { calculateFare, calculateGreenFare, type FareResult, } from "./fare/fareEngine.js";
+export { buildPath, type BuiltPathResult, type BuiltPathStep, } from "./fare/pathfinder.js";
+export { searchByCode, searchStation } from "./station/service.js";
+export type { Station } from "./station/model.js";