@johnmorrisdotca/uchusen-rockets 0.18.0 → 0.19.1

package/dist/launches/index.d.ts

@@ -0,0 +1,318 @@
+export { LAUNCH_LOG_SOURCE } from "./source.ts";
+export { LAUNCH_VEHICLE_LINKS } from "./links.ts";
+export type { VehicleLink, VehicleMatch } from "./links.ts";
+/**
+ * How a launch ended. `success` is GCAT's S, `failure` its F. `partial` is a launch GCAT scored between the two, such as an orbit that is usable but not the one aimed at (`score` says how well it went, from 1 to 99).
+ *
+ * @example
+ * ```ts
+ * import { launchesByOutcome, type LaunchOutcome } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const outcome: LaunchOutcome = "partial";
+ * console.log(launchesByOutcome(outcome).length > 0);
+ * ```
+ */
+export type LaunchOutcome = "success" | "partial" | "failure";
+/**
+ * The kind of orbit a launch aimed at, as GCAT's launch profile code names it. A launch carries it only when it reached an orbit.
+ *
+ * @example
+ * ```ts
+ * import { ORBIT_KINDS, type OrbitKind } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const kind: OrbitKind = "GTO";
+ * console.log(ORBIT_KINDS[kind]);
+ * ```
+ */
+export type OrbitKind = "LEO" | "SSO" | "ISS" | "LSS" | "MEO" | "MTO" | "MOL" | "HEO" | "GTO" | "STO" | "GEO" | "DSO" | "EEO";
+/**
+ * What each orbit kind means, in GCAT's words shortened.
+ *
+ * @example
+ * ```ts
+ * import { ORBIT_KINDS } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(Object.keys(ORBIT_KINDS).length);
+ * ```
+ */
+export declare const ORBIT_KINDS: Readonly<Record<OrbitKind, string>>;
+/**
+ * The orbit a launch reached. `kind` is what it aimed at; the numbers are the insertion orbit's, and each is there only where GCAT has it (about one launch in five has a perigee and an inclination).
+ *
+ * @example
+ * ```ts
+ * import { launchByTag, type LaunchOrbit } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const orbit: LaunchOrbit | null | undefined = launchByTag("1969-059")?.orbit;
+ * console.log(orbit?.kind, orbit?.perigeeKm, orbit?.apogeeKm);
+ * ```
+ */
+export interface LaunchOrbit {
+    readonly kind: OrbitKind;
+    /** Height of the insertion orbit's apogee above the surface, in km. For a launch on an escape trajectory (207 of them) it is 150000, GCAT's round figure for "leaves Earth", not a measurement. */
+    readonly apogeeKm?: number;
+    /** Height of its perigee, in km. It is negative (13 launches, Starship's flights among them) where the path GCAT gives dips below the surface, so the flight did not complete an orbit at that figure; it is not a height. */
+    readonly perigeeKm?: number;
+    /** Its inclination, in degrees. */
+    readonly inclinationDeg?: number;
+}
+/**
+ * One launch attempt.
+ *
+ * @example
+ * ```ts
+ * import { launchByTag, type Launch } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const launch: Launch | undefined = launchByTag("2018-017");
+ * console.log(launch?.utc, launch?.vehicle, launch?.payloads);
+ * ```
+ */
+export interface Launch {
+    /** GCAT's launch tag: the international (COSPAR) designation of a launch that reached orbit ("1957 ALP", "2018-017"), or one GCAT made up for a failure ("1957-F01"). Unique. */
+    readonly tag: string;
+    /** The UTC date, `YYYY-MM-DD`. */
+    readonly date: string;
+    /** The UTC time, `HH:MM` or `HH:MM:SS`, or null where GCAT has none. */
+    readonly time: string | null;
+    /** The date and time in UTC as an ISO 8601 string, or just the date where there is no time. */
+    readonly utc: string;
+    /** The launch in milliseconds since 1970, in UTC (midnight where there is no time). */
+    readonly ms: number;
+    /** True where GCAT marks the date or time as uncertain. */
+    readonly approximate: boolean;
+    /** The vehicle's type name in GCAT, as `LAUNCH_VEHICLE_LINKS` and `launchesByVehicle` take it. */
+    readonly vehicle: string;
+    /** The vehicle's variant (an upper stage, a series), or null. */
+    readonly variant: string | null;
+    /** GCAT's name for the family the vehicle belongs to ("R-7", "Falcon9"), or null. */
+    readonly family: string | null;
+    /** The id of this package's rocket the vehicle is, or is a member of the family of, or null. See `LAUNCH_VEHICLE_LINKS`. */
+    readonly rocket: string | null;
+    /** The variant of that rocket that this vehicle is, where one is, or null. */
+    readonly rocketVariant: string | null;
+    /** The launch site: GCAT's code and its name ("NIIP-5", "Baikonur"). */
+    readonly site: {
+        readonly code: string;
+        readonly name: string;
+    };
+    /** The pad, as GCAT writes it ("LC1", "LC39A"), or null. */
+    readonly pad: string | null;
+    /** The organization that launched: GCAT's code and short name ("SPX", "SpaceX"). */
+    readonly agency: {
+        readonly code: string;
+        readonly name: string;
+    };
+    /** The country of that organization, as GCAT gives it ("SU", "USSR"), or null. */
+    readonly country: {
+        readonly code: string;
+        readonly name: string;
+    } | null;
+    /** GCAT's name for the flight or mission ("Apollo 11", "Tesla Roadster"), or null. */
+    readonly flight: string | null;
+    /** The names of the payloads, at most the first eight. */
+    readonly payloads: readonly string[];
+    /** How many payloads the launch carried in all; more than `payloads.length` for a launch of a constellation. */
+    readonly payloadCount: number;
+    readonly outcome: LaunchOutcome;
+    /** For a `partial` launch, GCAT's score from 1 (a tiny part of the job done) to 99 (nearly all of it); 75 and over is within GCAT's pass mark. Null otherwise. */
+    readonly score: number | null;
+    /** The orbit reached, or null for a launch that failed to reach one. */
+    readonly orbit: LaunchOrbit | null;
+}
+/**
+ * Every launch in the log, oldest first, each as a plain object. The first call parses the log; the rest return the same array. The array and every launch in it are frozen, because every caller shares them: copy a launch to change it.
+ *
+ * @returns Every orbital launch attempt in the log.
+ * @example
+ * ```ts
+ * import { launches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const all = launches();
+ * console.log(all[0]?.date, all.length > 7000);
+ * ```
+ */
+export declare function launches(): readonly Launch[];
+/**
+ * One launch by its GCAT tag.
+ *
+ * @param tag A launch tag, such as "1957 ALP" or "2018-017".
+ * @returns The launch, or undefined where the log has none with that tag.
+ * @example
+ * ```ts
+ * import { launchByTag } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchByTag("1957 ALP")?.site.name); // "Baikonur"
+ * ```
+ */
+export declare function launchByTag(tag: string): Launch | undefined;
+/**
+ * What to keep. Every field given must hold, so each one narrows the others. Names and codes match without regard to case.
+ *
+ * @example
+ * ```ts
+ * import { findLaunches, type LaunchFilter } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const filter: LaunchFilter = { rocket: "falcon-9", year: 2020, outcome: "success" };
+ * console.log(findLaunches(filter).length > 10);
+ * ```
+ */
+export interface LaunchFilter {
+    /** A vehicle's type name in GCAT ("Falcon 9", "Soyuz-U"). */
+    vehicle?: string;
+    /** GCAT's name for a vehicle's family ("R-7"). */
+    family?: string;
+    /** The id of one of this package's rockets: every vehicle linked to it counts. */
+    rocket?: string;
+    /** A launch site's code or name ("NIIP-5", "Baikonur"): a name that several codes share holds for all of them. */
+    site?: string;
+    /** An organization's code or short name ("SPX", "SpaceX"). */
+    agency?: string;
+    /** A country's code or name ("SU", "USSR", "China"). */
+    country?: string;
+    /** A UTC year. */
+    year?: number;
+    /** The first day to keep, `YYYY-MM-DD`. */
+    from?: string;
+    /** The last day to keep, `YYYY-MM-DD`. */
+    to?: string;
+    outcome?: LaunchOutcome;
+}
+/**
+ * The launches that meet every field of a filter, oldest first.
+ *
+ * @param filter What to keep; none keeps all.
+ * @returns The matching launches.
+ * @example
+ * ```ts
+ * import { findLaunches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const shuttle = findLaunches({ rocket: "space-shuttle", outcome: "failure" });
+ * console.log(shuttle.length); // 0
+ * ```
+ */
+export declare function findLaunches(filter?: LaunchFilter): readonly Launch[];
+/**
+ * Every launch of one vehicle, by GCAT's type name.
+ *
+ * @param vehicle A vehicle's type name, such as "Falcon 9" or "Soyuz-U".
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByVehicle } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByVehicle("Saturn V").length); // 13
+ * ```
+ */
+export declare function launchesByVehicle(vehicle: string): readonly Launch[];
+/**
+ * Every launch from one site, by GCAT's code or its name.
+ *
+ * @param site A launch site, such as "Baikonur" or "KSC".
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesBySite } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesBySite("Baikonur")[0]?.date); // "1957-10-04"
+ * ```
+ */
+export declare function launchesBySite(site: string): readonly Launch[];
+/**
+ * Every launch of one UTC year.
+ *
+ * @param year A year, such as 1969.
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByYear } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByYear(1957).length); // 3
+ * ```
+ */
+export declare function launchesByYear(year: number): readonly Launch[];
+/**
+ * Every launch that ended one way.
+ *
+ * @param outcome `success`, `partial` or `failure`.
+ * @returns Those launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByOutcome } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByOutcome("failure")[0]?.tag); // "1957-F01"
+ * ```
+ */
+export declare function launchesByOutcome(outcome: LaunchOutcome): readonly Launch[];
+/**
+ * What a count can be grouped by.
+ *
+ * @example
+ * ```ts
+ * import { countLaunches, type LaunchGroup } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const by: LaunchGroup = "year";
+ * console.log(countLaunches(by, { rocket: "electron" })[0]);
+ * ```
+ */
+export type LaunchGroup = "vehicle" | "family" | "rocket" | "site" | "agency" | "country" | "year" | "outcome" | "orbit";
+/**
+ * One group of a count.
+ *
+ * @example
+ * ```ts
+ * import { countLaunches, type LaunchCount } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const top: LaunchCount | undefined = countLaunches("vehicle")[0];
+ * console.log(top?.key, top?.count);
+ * ```
+ */
+export interface LaunchCount {
+    /** The group: a vehicle name, a site name, a year, an outcome and so on. */
+    key: string;
+    count: number;
+}
+/**
+ * Counts launches by a group, most first (oldest first for years). A launch with no value for the group, such as one with no linked rocket, is left out.
+ *
+ * @param by What to group by.
+ * @param filter What to count; none counts all.
+ * @returns The groups with their counts.
+ * @example
+ * ```ts
+ * import { countLaunches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(countLaunches("outcome").map((one) => one.key)); // ["success","failure","partial"]
+ * ```
+ */
+export declare function countLaunches(by: LaunchGroup, filter?: LaunchFilter): readonly LaunchCount[];
+/**
+ * How many launches there were, and how many of them ended each way.
+ *
+ * @example
+ * ```ts
+ * import { type LaunchTotals, launchTotals } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const totals: LaunchTotals = launchTotals({ year: 2020 });
+ * console.log(totals.total === totals.success + totals.partial + totals.failure); // true
+ * ```
+ */
+export interface LaunchTotals {
+    total: number;
+    success: number;
+    partial: number;
+    failure: number;
+}
+/**
+ * The totals of the launches that meet a filter.
+ *
+ * @param filter What to count; none counts all.
+ * @returns The total and the count of each outcome.
+ * @example
+ * ```ts
+ * import { launchTotals } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const falcon = launchTotals({ rocket: "falcon-9" });
+ * console.log(falcon.total > 500);
+ * ```
+ */
+export declare function launchTotals(filter?: LaunchFilter): LaunchTotals;

package/dist/launches/index.js

@@ -0,0 +1,249 @@
+// The launch log: every orbital launch attempt since 1957, from GCAT (Jonathan McDowell, CC BY 4.0), with lookups and counts. Pure: no DOM, no clock, no dependency. The data is one packed string in ./data.ts, parsed on first use.
+import { PACKED_LAUNCHES } from "./data.js";
+import { LAUNCH_VEHICLE_LINKS } from "./links.js";
+export { LAUNCH_LOG_SOURCE } from "./source.js";
+export { LAUNCH_VEHICLE_LINKS } from "./links.js";
+/**
+ * What each orbit kind means, in GCAT's words shortened.
+ *
+ * @example
+ * ```ts
+ * import { ORBIT_KINDS } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(Object.keys(ORBIT_KINDS).length);
+ * ```
+ */
+export const ORBIT_KINDS = {
+    LEO: "Low Earth orbit (other than sun-synchronous, space station and ISS)",
+    SSO: "Sun-synchronous orbit",
+    ISS: "The International Space Station",
+    LSS: "A low-orbit space station other than the ISS",
+    MEO: "Medium Earth orbit",
+    MTO: "Medium Earth orbit transfer, the payload circularizes it",
+    MOL: "Molniya orbit",
+    HEO: "Highly elliptical orbit (other than Molniya)",
+    GTO: "Geosynchronous transfer orbit",
+    STO: "Supersynchronous transfer orbit, apogee over 45,000 km",
+    GEO: "Direct insertion to geosynchronous orbit",
+    DSO: "Deep space orbit: Earth orbit with an apogee beyond 150,000 km",
+    EEO: "Earth escape orbit",
+};
+const OUTCOMES = { s: "success", p: "partial", f: "failure" };
+const LINKS = new Map(LAUNCH_VEHICLE_LINKS.map((link) => [link.vehicle, link]));
+let parsed;
+function parse() {
+    const packed = JSON.parse(PACKED_LAUNCHES);
+    const countries = new Map(packed.countries);
+    const rows = packed.rows.map((row) => {
+        const [tag, date, time, v, variant, s, pad, a, outcome, score, o, apogee, perigee, inclination, flight, approximate, count, payloads] = row;
+        const vehicle = packed.vehicles[v];
+        const agency = packed.agencies[a];
+        const link = LINKS.get(vehicle[0]);
+        const orbitNumbers = { ...(apogee > 0 ? { apogeeKm: apogee } : {}), ...(perigee === null ? {} : { perigeeKm: perigee }), ...(inclination === null ? {} : { inclinationDeg: inclination }) };
+        return {
+            tag,
+            date,
+            time: time === "" ? null : time,
+            utc: time === "" ? date : `${date}T${time.length === 5 ? `${time}:00` : time}Z`,
+            ms: Date.parse(`${date}T${time === "" ? "00:00:00" : time.length === 5 ? `${time}:00` : time}Z`),
+            approximate: approximate === 1,
+            vehicle: vehicle[0],
+            variant,
+            family: vehicle[1] === "" ? null : vehicle[1],
+            rocket: link?.rocket ?? null,
+            rocketVariant: link?.variant ?? null,
+            site: { code: packed.sites[s][0], name: packed.sites[s][1] },
+            pad,
+            agency: { code: agency[0], name: agency[1] },
+            country: agency[2] === "" ? null : { code: agency[2], name: countries.get(agency[2]) ?? agency[2] },
+            flight,
+            payloads,
+            payloadCount: count,
+            outcome: OUTCOMES[outcome],
+            score: score === 0 ? null : score,
+            orbit: o < 0 ? null : Object.freeze({ kind: packed.orbits[o], ...orbitNumbers }),
+        };
+    });
+    return Object.freeze(rows.map(freezeLaunch));
+}
+/** Freezes a launch and the objects inside it: every caller reads the same rows, so one that wrote to a row would change them for all. */
+function freezeLaunch(launch) {
+    Object.freeze(launch.site);
+    Object.freeze(launch.agency);
+    if (launch.country)
+        Object.freeze(launch.country);
+    Object.freeze(launch.payloads);
+    return Object.freeze(launch);
+}
+/**
+ * Every launch in the log, oldest first, each as a plain object. The first call parses the log; the rest return the same array. The array and every launch in it are frozen, because every caller shares them: copy a launch to change it.
+ *
+ * @returns Every orbital launch attempt in the log.
+ * @example
+ * ```ts
+ * import { launches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const all = launches();
+ * console.log(all[0]?.date, all.length > 7000);
+ * ```
+ */
+export function launches() {
+    parsed ??= parse();
+    return parsed;
+}
+/**
+ * One launch by its GCAT tag.
+ *
+ * @param tag A launch tag, such as "1957 ALP" or "2018-017".
+ * @returns The launch, or undefined where the log has none with that tag.
+ * @example
+ * ```ts
+ * import { launchByTag } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchByTag("1957 ALP")?.site.name); // "Baikonur"
+ * ```
+ */
+export function launchByTag(tag) {
+    return launches().find((launch) => launch.tag === tag);
+}
+const same = (a, b) => b !== undefined && b !== null && a.toLowerCase() === b.toLowerCase();
+/**
+ * The launches that meet every field of a filter, oldest first.
+ *
+ * @param filter What to keep; none keeps all.
+ * @returns The matching launches.
+ * @example
+ * ```ts
+ * import { findLaunches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const shuttle = findLaunches({ rocket: "space-shuttle", outcome: "failure" });
+ * console.log(shuttle.length); // 0
+ * ```
+ */
+export function findLaunches(filter = {}) {
+    return launches().filter((launch) => (filter.vehicle === undefined || same(filter.vehicle, launch.vehicle)) &&
+        (filter.family === undefined || same(filter.family, launch.family)) &&
+        (filter.rocket === undefined || launch.rocket === filter.rocket) &&
+        (filter.site === undefined || same(filter.site, launch.site.code) || same(filter.site, launch.site.name)) &&
+        (filter.agency === undefined || same(filter.agency, launch.agency.code) || same(filter.agency, launch.agency.name)) &&
+        (filter.country === undefined || same(filter.country, launch.country?.code) || same(filter.country, launch.country?.name)) &&
+        (filter.year === undefined || launch.date.startsWith(`${String(filter.year).padStart(4, "0")}-`)) &&
+        (filter.from === undefined || launch.date >= filter.from) &&
+        (filter.to === undefined || launch.date <= filter.to) &&
+        (filter.outcome === undefined || launch.outcome === filter.outcome));
+}
+/**
+ * Every launch of one vehicle, by GCAT's type name.
+ *
+ * @param vehicle A vehicle's type name, such as "Falcon 9" or "Soyuz-U".
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByVehicle } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByVehicle("Saturn V").length); // 13
+ * ```
+ */
+export function launchesByVehicle(vehicle) {
+    return findLaunches({ vehicle });
+}
+/**
+ * Every launch from one site, by GCAT's code or its name.
+ *
+ * @param site A launch site, such as "Baikonur" or "KSC".
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesBySite } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesBySite("Baikonur")[0]?.date); // "1957-10-04"
+ * ```
+ */
+export function launchesBySite(site) {
+    return findLaunches({ site });
+}
+/**
+ * Every launch of one UTC year.
+ *
+ * @param year A year, such as 1969.
+ * @returns Its launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByYear } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByYear(1957).length); // 3
+ * ```
+ */
+export function launchesByYear(year) {
+    return findLaunches({ year });
+}
+/**
+ * Every launch that ended one way.
+ *
+ * @param outcome `success`, `partial` or `failure`.
+ * @returns Those launches, oldest first.
+ * @example
+ * ```ts
+ * import { launchesByOutcome } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(launchesByOutcome("failure")[0]?.tag); // "1957-F01"
+ * ```
+ */
+export function launchesByOutcome(outcome) {
+    return findLaunches({ outcome });
+}
+const KEYS = {
+    vehicle: (launch) => launch.vehicle,
+    family: (launch) => launch.family,
+    rocket: (launch) => launch.rocket,
+    site: (launch) => launch.site.name,
+    agency: (launch) => launch.agency.name,
+    country: (launch) => launch.country?.name ?? null,
+    year: (launch) => launch.date.slice(0, 4),
+    outcome: (launch) => launch.outcome,
+    orbit: (launch) => launch.orbit?.kind ?? null,
+};
+/**
+ * Counts launches by a group, most first (oldest first for years). A launch with no value for the group, such as one with no linked rocket, is left out.
+ *
+ * @param by What to group by.
+ * @param filter What to count; none counts all.
+ * @returns The groups with their counts.
+ * @example
+ * ```ts
+ * import { countLaunches } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(countLaunches("outcome").map((one) => one.key)); // ["success","failure","partial"]
+ * ```
+ */
+export function countLaunches(by, filter = {}) {
+    const counts = new Map();
+    for (const launch of findLaunches(filter)) {
+        const key = KEYS[by](launch);
+        if (key !== null)
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const list = [...counts].map(([key, count]) => ({ key, count }));
+    return by === "year" ? list.sort((a, b) => a.key.localeCompare(b.key)) : list.sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+/**
+ * The totals of the launches that meet a filter.
+ *
+ * @param filter What to count; none counts all.
+ * @returns The total and the count of each outcome.
+ * @example
+ * ```ts
+ * import { launchTotals } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const falcon = launchTotals({ rocket: "falcon-9" });
+ * console.log(falcon.total > 500);
+ * ```
+ */
+export function launchTotals(filter = {}) {
+    const totals = { total: 0, success: 0, partial: 0, failure: 0 };
+    for (const launch of findLaunches(filter)) {
+        totals.total++;
+        totals[launch.outcome]++;
+    }
+    return totals;
+}

package/dist/launches/links.d.ts

@@ -0,0 +1,43 @@
+/**
+ * How a GCAT vehicle relates to the rocket this package draws: `same` when it is the vehicle drawn, `family` when it is another member of the same named family (Soyuz-U beside the drawn Soyuz-2).
+ *
+ * @example
+ * ```ts
+ * import { LAUNCH_VEHICLE_LINKS, type VehicleMatch } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const match: VehicleMatch | undefined = LAUNCH_VEHICLE_LINKS[0]?.match;
+ * console.log(match);
+ * ```
+ */
+export type VehicleMatch = "same" | "family";
+/**
+ * One row of the table that links a GCAT launch vehicle to this package's rocket: GCAT's vehicle name as the log spells it, the rocket id, the variant id where one variant is the vehicle, and how close the two are.
+ *
+ * @example
+ * ```ts
+ * import { LAUNCH_VEHICLE_LINKS, type VehicleLink } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * const falcon: VehicleLink | undefined = LAUNCH_VEHICLE_LINKS.find((link) => link.vehicle === "Falcon 9");
+ * console.log(falcon?.rocket);
+ * ```
+ */
+export interface VehicleLink {
+    /** The vehicle's type name in GCAT, exactly as `Launch.vehicle` spells it. */
+    vehicle: string;
+    /** The id of the rocket in `ROCKETS`. */
+    rocket: string;
+    /** The id of the variant in `ROCKETS[rocket].variants`, only where one variant is this vehicle. */
+    variant?: string;
+    match: VehicleMatch;
+}
+/**
+ * The table that links the log's vehicle names to this package's rocket ids. A test holds that every row names a vehicle that flew, a rocket that is in `ROCKETS` and a variant that belongs to it.
+ *
+ * @example
+ * ```ts
+ * import { LAUNCH_VEHICLE_LINKS } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(LAUNCH_VEHICLE_LINKS.filter((link) => link.rocket === "soyuz").map((link) => link.vehicle));
+ * ```
+ */
+export declare const LAUNCH_VEHICLE_LINKS: readonly VehicleLink[];

package/dist/launches/links.js

@@ -0,0 +1,40 @@
+// Which of GCAT's launch vehicles are rockets this package draws. GCAT names a vehicle by its type ("Soyuz-2-1A"); the package names it by a rocket id ("soyuz") and a variant id ("soyuz-2").
+// Only a vehicle that is the one drawn, or a plain member of the family of the one drawn, is listed. Any other vehicle in the log has no link and its `rocket` is null.
+const same = (vehicle, rocket, variant) => ({ vehicle, rocket, ...(variant === undefined ? {} : { variant }), match: "same" });
+const family = (vehicle, rocket) => ({ vehicle, rocket, match: "family" });
+/**
+ * The table that links the log's vehicle names to this package's rocket ids. A test holds that every row names a vehicle that flew, a rocket that is in `ROCKETS` and a variant that belongs to it.
+ *
+ * @example
+ * ```ts
+ * import { LAUNCH_VEHICLE_LINKS } from "@johnmorrisdotca/uchusen-rockets/launches";
+ *
+ * console.log(LAUNCH_VEHICLE_LINKS.filter((link) => link.rocket === "soyuz").map((link) => link.vehicle));
+ * ```
+ */
+export const LAUNCH_VEHICLE_LINKS = [
+    same("Falcon 9", "falcon-9"),
+    same("Falcon Heavy", "falcon-heavy", "falcon-heavy"),
+    same("Falcon 1", "falcon-1", "falcon-1"),
+    same("Saturn V", "saturn-v", "saturn-v"),
+    same("Space Shuttle", "space-shuttle", "stack"),
+    same("SLS Block 1", "sls", "block-1"),
+    same("New Glenn 7x2", "new-glenn", "7x2"),
+    same("Electron", "electron", "electron"),
+    same("Jupiter C", "jupiter-c", "jupiter-c"),
+    same("Starship V2", "starship", "v2"),
+    same("Starship V3", "starship", "v3"),
+    family("Starship V1.0", "starship"),
+    same("Soyuz-2-1A", "soyuz", "soyuz-2"),
+    same("Soyuz-2-1B", "soyuz", "soyuz-2"),
+    family("Soyuz-2-1V", "soyuz"),
+    family("Soyuz-ST-A", "soyuz"),
+    family("Soyuz-ST-B", "soyuz"),
+    family("Soyuz-FG", "soyuz"),
+    family("Soyuz-U", "soyuz"),
+    family("Soyuz-U2", "soyuz"),
+    family("Soyuz-U-PVB", "soyuz"),
+    family("Soyuz 11A511", "soyuz"),
+    family("Soyuz 11A511L", "soyuz"),
+    family("Soyuz 11A511M", "soyuz"),
+];

package/dist/launches/source.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Where the log comes from: GCAT, its author, its licence and the exact credit to print where the log is used, with the release it was packed from and the day its files were last updated.
+ *
+ * @example
+ * ```ts
+ * import { LAUNCH_LOG_SOURCE } from "@johnmorrisdotca/uchusen-rockets/launches/source";
+ *
+ * console.log(LAUNCH_LOG_SOURCE.credit);
+ * ```
+ */
+export declare const LAUNCH_LOG_SOURCE: {
+    readonly title: "GCAT: General Catalog of Artificial Space Objects";
+    readonly author: "Jonathan C. McDowell";
+    readonly url: "https://planet4589.org/space/gcat";
+    readonly licence: "CC BY 4.0";
+    readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+    readonly credit: "Data from GCAT (J. McDowell, planet4589.org/space/gcat)";
+    readonly release: "1.8.9";
+    readonly updated: "2026-11-09";
+};