@elite-dangerous-almanac/core 0.1.0-beta.1

package/dist/ships/module-capabilities.d.ts

@@ -0,0 +1,205 @@
+import { OutfittingModuleStats } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * Data-free capability guards for sparse outfitting-module records.
+ *
+ * {@link OutfittingModule} represents every outfitting family, so its performance
+ * fields are optional. These guards narrow only the stat group a calculation needs;
+ * they do not infer identity from a symbol or require an unrelated family label.
+ * Each exported stat interface contains only its required numeric fields, so consumers
+ * can also accept the smallest useful calculation input without fabricating module
+ * identity. A successful guard narrows a catalogue record to the intersection of that
+ * record and the stat interface.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   hasFrameShiftDriveJumpStats,
+ *   hasWeaponDamageStats,
+ *   type FrameShiftDriveJumpStats,
+ * } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+ * import { weaponMetrics } from '@elite-dangerous-almanac/core/ships/weapons';
+ *
+ * declare const journalItem: string;
+ *
+ * const module = getModuleBySymbol(journalItem);
+ * if (hasFrameShiftDriveJumpStats(module)) module.maxFuel; // required, in tonnes
+ * if (hasWeaponDamageStats(module)) weaponMetrics(module);
+ *
+ * const customDrive: FrameShiftDriveJumpStats = {
+ *   optMass: 1050,
+ *   maxFuel: 5,
+ *   fuelMul: 0.012,
+ *   fuelPower: 2.45,
+ * }; // no identity fields required
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/** Complete frame-shift-drive constants required by jump and fuel calculations. */
+interface FrameShiftDriveJumpStats {
+    /** Optimised mass, in tonnes. Positive for every catalogued drive. */
+    readonly optMass: number;
+    /** Maximum fuel consumed by one jump, in tonnes. Positive. */
+    readonly maxFuel: number;
+    /** Rating-dependent linear fuel constant. Positive. */
+    readonly fuelMul: number;
+    /** Size-dependent fuel exponent. Positive. */
+    readonly fuelPower: number;
+}
+/** Complete power-plant output and heat-efficiency capability. */
+interface PowerGenerationStats {
+    /** Power generated, in megawatts. Non-negative. */
+    readonly powerCapacity: number;
+    /** Dimensionless heat-efficiency factor; positive, and lower runs cooler. */
+    readonly heatEfficiency: number;
+}
+/** All three power-distributor capacitor capacities and recharge rates. */
+interface PowerDistributorStats {
+    /** WEP capacitor capacity, in megajoules. Non-negative. */
+    readonly weaponsCapacity: number;
+    /** WEP recharge rate, in megajoules per second. Non-negative. */
+    readonly weaponsRecharge: number;
+    /** ENG capacitor capacity, in megajoules. Non-negative. */
+    readonly enginesCapacity: number;
+    /** ENG recharge rate, in megajoules per second. Non-negative. */
+    readonly enginesRecharge: number;
+    /** SYS capacitor capacity, in megajoules. Non-negative. */
+    readonly systemsCapacity: number;
+    /** SYS recharge rate, in megajoules per second. Non-negative. */
+    readonly systemsRecharge: number;
+}
+/** A complete three-point performance curve over hull mass. */
+interface MassCurveStats {
+    /** Optimised hull mass, in tonnes. Positive. */
+    readonly optMass: number;
+    /** Minimum curve mass, in tonnes. Positive. */
+    readonly minMass: number;
+    /** Maximum curve mass, in tonnes. Positive. */
+    readonly maxMass: number;
+    /** Dimensionless performance multiplier at `optMass`. Positive. */
+    readonly optMultiplier: number;
+    /** Dimensionless minimum performance multiplier, reached at `maxMass`. Positive. */
+    readonly minMultiplier: number;
+    /** Dimensionless maximum performance multiplier, reached at `minMass`. Positive. */
+    readonly maxMultiplier: number;
+}
+/** Both shield regeneration rates exposed by a generator. */
+interface ShieldRegenerationStats {
+    /** Normal regeneration rate, in megajoules per second. Non-negative. */
+    readonly shieldRegenRate: number;
+    /** Broken-shield regeneration rate, in megajoules per second. Non-negative. */
+    readonly shieldBrokenRegenRate: number;
+}
+/** The concrete damage capability shared by hardpoint weapons and tools. */
+interface WeaponDamageStats {
+    /** Damage per round, or per second for continuous-fire weapons. Non-negative. */
+    readonly damage: number;
+}
+/**
+ * Test for complete frame-shift-drive jump constants.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether all fields in {@link FrameShiftDriveJumpStats} are numeric.
+ * @example
+ * ```ts
+ * import type { OutfittingModuleStats } from '@elite-dangerous-almanac/core/ships/modules';
+ * import { singleJumpRange } from '@elite-dangerous-almanac/core/ships/jump-range';
+ * import { hasFrameShiftDriveJumpStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ *
+ * declare const record: OutfittingModuleStats | null;
+ *
+ * if (hasFrameShiftDriveJumpStats(record)) singleJumpRange(500, record.maxFuel, record);
+ * ```
+ */
+declare function hasFrameShiftDriveJumpStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & FrameShiftDriveJumpStats;
+/**
+ * Test for complete power-generation stats.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether both fields in {@link PowerGenerationStats} are numeric.
+ * @example
+ * ```ts
+ * import type { OutfittingModule } from '@elite-dangerous-almanac/core/ships/modules';
+ * declare const record: OutfittingModule | null;
+ *
+ * import { hasPowerGenerationStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ *
+ * if (hasPowerGenerationStats(record)) record.powerCapacity; // MW
+ * ```
+ */
+declare function hasPowerGenerationStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & PowerGenerationStats;
+/**
+ * Test for all three power-distributor capacitor stat pairs.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether every field in {@link PowerDistributorStats} is numeric.
+ * @example
+ * ```ts
+ * import type { OutfittingModule } from '@elite-dangerous-almanac/core/ships/modules';
+ * declare const record: OutfittingModule | null;
+ *
+ * import { hasPowerDistributorStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ *
+ * if (hasPowerDistributorStats(record)) record.weaponsRecharge; // MJ/s
+ * ```
+ */
+declare function hasPowerDistributorStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & PowerDistributorStats;
+/**
+ * Test for a complete three-point hull-mass performance curve.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether every field in {@link MassCurveStats} is numeric. Both thrusters
+ * and shield generators satisfy this capability.
+ * @example
+ * ```ts
+ * import type { OutfittingModule } from '@elite-dangerous-almanac/core/ships/modules';
+ * declare const record: OutfittingModule | null;
+ *
+ * import { hasMassCurveStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ *
+ * if (hasMassCurveStats(record)) record.optMultiplier; // dimensionless
+ * ```
+ */
+declare function hasMassCurveStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & MassCurveStats;
+/**
+ * Test for both shield regeneration rates.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether both fields in {@link ShieldRegenerationStats} are numeric.
+ * @example
+ * ```ts
+ * import type { OutfittingModule } from '@elite-dangerous-almanac/core/ships/modules';
+ * declare const record: OutfittingModule | null;
+ *
+ * import { hasShieldRegenerationStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ *
+ * if (hasShieldRegenerationStats(record)) record.shieldRegenRate; // MJ/s
+ * ```
+ */
+declare function hasShieldRegenerationStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & ShieldRegenerationStats;
+/**
+ * Test for a concrete weapon/tool damage figure.
+ *
+ * @param module - A catalogue result or custom sparse record, including `null`.
+ * @returns Whether `damage` is numeric, narrowing to {@link WeaponDamageStats}.
+ * Other firing fields stay optional because continuous-fire and ammunition-free
+ * weapons legitimately omit different stats.
+ * @example
+ * ```ts
+ * import type { OutfittingModule } from '@elite-dangerous-almanac/core/ships/modules';
+ * declare const record: OutfittingModule | null;
+ *
+ * import { hasWeaponDamageStats } from '@elite-dangerous-almanac/core/ships/module-capabilities';
+ * import { weaponMetrics } from '@elite-dangerous-almanac/core/ships/weapons';
+ *
+ * if (hasWeaponDamageStats(record)) weaponMetrics(record);
+ * ```
+ */
+declare function hasWeaponDamageStats<T extends OutfittingModuleStats>(module: T | null | undefined): module is T & WeaponDamageStats;
+
+export { type FrameShiftDriveJumpStats, type MassCurveStats, type PowerDistributorStats, type PowerGenerationStats, type ShieldRegenerationStats, type WeaponDamageStats, hasFrameShiftDriveJumpStats, hasMassCurveStats, hasPowerDistributorStats, hasPowerGenerationStats, hasShieldRegenerationStats, hasWeaponDamageStats };

package/dist/ships/module-capabilities.js

@@ -0,0 +1 @@
+export{hasFrameShiftDriveJumpStats,hasMassCurveStats,hasPowerDistributorStats,hasPowerGenerationStats,hasShieldRegenerationStats,hasWeaponDamageStats}from"../chunk-JTQVWIGL.js";//# sourceMappingURL=module-capabilities.js.map

package/dist/ships/module-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/modules-all.d.ts

@@ -0,0 +1,43 @@
+import { OutfittingModule } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * The **complete** outfitting catalogue: standard, internal, hardpoint and utility
+ * modules in one array.
+ *
+ * @remarks
+ * **This module pulls in every module catalogue** — it exists for consumers that
+ * really do want to search all 1199 modules (a "resolve any module id" lookup, say).
+ * If you only need one category, import that catalogue's module
+ * (`./modules-core`, `./modules-internal`, `./modules-hardpoint`,
+ * `./modules-utility`) and nothing else gets bundled.
+ *
+ * Identity primarily from EDCD FDevIDs (`outfitting.csv`), with supplemental module
+ * identities documented in the source record; stats from EDCD/coriolis-data and EDSY,
+ * joined on `symbol`. See [`data/ships/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/ships/SOURCES.md).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Every outfitting module — the concatenation of `CORE_MODULES`,
+ * `INTERNAL_MODULES`, `HARDPOINT_MODULES` and `UTILITY_MODULES`, in that order
+ * (each in Frontier's registry order).
+ *
+ * @remarks
+ * Filter on {@link OutfittingModule.category} to narrow it down after the fact —
+ * though importing the single catalogue you need is cheaper, since it keeps the
+ * others out of your bundle entirely.
+ *
+ * @example
+ * ```ts
+ * import { ALL_MODULES } from '@elite-dangerous-almanac/core/ships/modules-all';
+ *
+ * ALL_MODULES.length;                                          // -> 1199
+ * ALL_MODULES.filter((m) => m.category === 'utility').length;  // -> 35
+ * ```
+ */
+declare const ALL_MODULES: readonly OutfittingModule[];
+
+export { ALL_MODULES };

package/dist/ships/modules-all.js

@@ -0,0 +1 @@
+export{ALL_MODULES}from"../chunk-CWAX3BSH.js";                                                                                                                                                                              //# sourceMappingURL=modules-all.js.map

package/dist/ships/modules-all.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/modules-core.d.ts

@@ -0,0 +1,40 @@
+import { OutfittingModule } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * The **core internal** modules — the `core` outfitting category: the eight slots
+ * every hull must fill (armour, power plant, thrusters, frame shift drive, life
+ * support, power distributor, sensors, fuel tank).
+ *
+ * The armour variants here are the one ship-specific module, so this is also where
+ * `getBulkheadsForShip` from `./modules` finds a hull's bulkheads. The other categories
+ * live in `./modules-internal`, `./modules-hardpoint` and `./modules-utility`, so
+ * importing this module never bundles them.
+ *
+ * Identity from EDCD FDevIDs (`outfitting.csv`), stats from EDCD/coriolis-data,
+ * joined on `symbol`; see [`data/ships/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/ships/SOURCES.md).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * All 521 core internal modules, in Frontier's registry order.
+ *
+ * @remarks
+ * Every record has `category: 'core'`, added from the file it was read from
+ * rather than repeated on every record. To keep the other three categories out of
+ * your bundle, search this array directly — `CORE_MODULES.find((m) =>
+ * m.symbol.toLowerCase() === wanted)`, lower-cased because a journal's symbols are —
+ * rather than with the lookups in `./modules`, which default to all 1199 modules.
+ *
+ * @example
+ * ```ts
+ * import { CORE_MODULES } from '@elite-dangerous-almanac/core/ships/modules-core';
+ *
+ * CORE_MODULES.length; // -> 521
+ * ```
+ */
+declare const CORE_MODULES: readonly OutfittingModule[];
+
+export { CORE_MODULES };

package/dist/ships/modules-core.js

@@ -0,0 +1 @@
+export{CORE_MODULES}from"../chunk-K3AMV27L.js";                                                          //# sourceMappingURL=modules-core.js.map

package/dist/ships/modules-core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/modules-hardpoint.d.ts

@@ -0,0 +1,42 @@
+import { OutfittingModule } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * The **hardpoint** modules — the `hardpoint` outfitting category: the weapons and
+ * tools mounted on a hardpoint (lasers, multi-cannons, missile and mine launchers,
+ * mining lasers, the various Thargoid/Guardian hardpoints, …).
+ *
+ * These are the modules that carry a {@link OutfittingModule.mount}
+ * (Fixed / Gimballed / Turreted) and, for launchers, a
+ * {@link OutfittingModule.guidance}. The other categories live in
+ * `./modules-core`, `./modules-internal` and `./modules-utility`, so importing
+ * this module never bundles them.
+ *
+ * Identity from EDCD FDevIDs (`outfitting.csv`), stats from EDCD/coriolis-data,
+ * joined on `symbol`; see [`data/ships/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/ships/SOURCES.md).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * All 159 hardpoint modules, in Frontier's registry order.
+ *
+ * @remarks
+ * Every record has `category: 'hardpoint'`, added from the file it was read from
+ * rather than repeated on every record. To keep the other three categories out of
+ * your bundle, search this array directly — `HARDPOINT_MODULES.find((m) =>
+ * m.symbol.toLowerCase() === wanted)`, lower-cased because a journal's symbols are —
+ * rather than with the lookups in `./modules`, which default to all 1199 modules.
+ *
+ * @example
+ * ```ts
+ * import { HARDPOINT_MODULES } from '@elite-dangerous-almanac/core/ships/modules-hardpoint';
+ *
+ * HARDPOINT_MODULES.length; // -> 159
+ * HARDPOINT_MODULES.filter((m) => m.mount === 'Turreted').length; // turreted variants
+ * ```
+ */
+declare const HARDPOINT_MODULES: readonly OutfittingModule[];
+
+export { HARDPOINT_MODULES };

package/dist/ships/modules-hardpoint.js

@@ -0,0 +1 @@
+export{HARDPOINT_MODULES}from"../chunk-A6XPYSVR.js";                                                          //# sourceMappingURL=modules-hardpoint.js.map

package/dist/ships/modules-hardpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/modules-internal.d.ts

@@ -0,0 +1,40 @@
+import { OutfittingModule } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * The **optional internal** modules — the `internal` outfitting category:
+ * everything that fills an optional internal slot (cargo racks, shield generators,
+ * fuel scoops, refineries, passenger cabins, limpet and planetary controllers,
+ * hull/module reinforcement, …).
+ *
+ * The other categories live in `./modules-core`, `./modules-hardpoint` and
+ * `./modules-utility`, so importing this module never bundles them.
+ *
+ * Identity primarily from EDCD FDevIDs (`outfitting.csv`), with six bundle-granted
+ * Vessel Hangar variants from a public CAPI capture; stats from EDCD/coriolis-data and
+ * EDSY, joined on `symbol`. See [`data/ships/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/ships/SOURCES.md).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * All 484 optional internal modules, in registry order.
+ *
+ * @remarks
+ * Every record has `category: 'internal'`, added from the file it was read from
+ * rather than repeated on every record. To keep the other three categories out of
+ * your bundle, search this array directly — `INTERNAL_MODULES.find((m) =>
+ * m.symbol.toLowerCase() === wanted)`, lower-cased because a journal's symbols are —
+ * rather than with the lookups in `./modules`, which default to all 1199 modules.
+ *
+ * @example
+ * ```ts
+ * import { INTERNAL_MODULES } from '@elite-dangerous-almanac/core/ships/modules-internal';
+ *
+ * INTERNAL_MODULES.length; // -> 484
+ * ```
+ */
+declare const INTERNAL_MODULES: readonly OutfittingModule[];
+
+export { INTERNAL_MODULES };

package/dist/ships/modules-internal.js

@@ -0,0 +1 @@
+export{INTERNAL_MODULES}from"../chunk-Y2MUIE5W.js";                                                          //# sourceMappingURL=modules-internal.js.map

package/dist/ships/modules-internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/modules-utility.d.ts

@@ -0,0 +1,40 @@
+import { OutfittingModule } from './modules.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * The **utility-mount** modules — the `utility` outfitting category: the small
+ * utility-slot fittings (chaff and heat-sink launchers, point defence, shield
+ * boosters, kill warrant / manifest / wake scanners, the xeno and Shutdown Field
+ * scanners, …).
+ *
+ * The smallest catalogue. The other categories live in `./modules-core`,
+ * `./modules-internal` and `./modules-hardpoint`, so importing this module never
+ * bundles them.
+ *
+ * Identity from EDCD FDevIDs (`outfitting.csv`), stats from EDCD/coriolis-data,
+ * joined on `symbol`; see [`data/ships/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/ships/SOURCES.md).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * All 35 utility-mount modules, in Frontier's registry order.
+ *
+ * @remarks
+ * Every record has `category: 'utility'`, added from the file it was read from
+ * rather than repeated on every record. To keep the other three categories out of
+ * your bundle, search this array directly — `UTILITY_MODULES.find((m) =>
+ * m.symbol.toLowerCase() === wanted)`, lower-cased because a journal's symbols are —
+ * rather than with the lookups in `./modules`, which default to all 1199 modules.
+ *
+ * @example
+ * ```ts
+ * import { UTILITY_MODULES } from '@elite-dangerous-almanac/core/ships/modules-utility';
+ *
+ * UTILITY_MODULES.length; // -> 35
+ * ```
+ */
+declare const UTILITY_MODULES: readonly OutfittingModule[];
+
+export { UTILITY_MODULES };

package/dist/ships/modules-utility.js

@@ -0,0 +1 @@
+export{UTILITY_MODULES}from"../chunk-A3NM7SAJ.js";                                                          //# sourceMappingURL=modules-utility.js.map

package/dist/ships/modules-utility.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}