@orbat-mapper/tactical-map-sheet 0.1.0

package/dist/create-tactical-map-sheet-DAKVJ3Bx.d.mts

@@ -0,0 +1,425 @@
+import { ControlMeasure, PatternId, TextAmplifiers } from "@orbat-mapper/control-measures";
+
+//#region ../../node_modules/.pnpm/@types+geojson@7946.0.16/node_modules/@types/geojson/index.d.ts
+/**
+ * The value values for the "type" property of GeoJSON Objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+type GeoJsonTypes = GeoJSON["type"];
+/**
+ * Bounding box
+ * https://tools.ietf.org/html/rfc7946#section-5
+ */
+type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ *
+ * Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to
+ * marginal benefits and the large impact of breaking change.
+ *
+ * See previous discussions on the type narrowing:
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024}
+ *
+ * One can use a
+ * {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate}
+ * to determine if a position is a 2D or 3D position.
+ *
+ * @example
+ * import type { Position } from 'geojson';
+ *
+ * type StrictPosition = [x: number, y: number] | [x: number, y: number, z: number]
+ *
+ * function isStrictPosition(position: Position): position is StrictPosition {
+ *   return position.length === 2 || position.length === 3
+ * };
+ *
+ * let position: Position = [-116.91, 45.54];
+ *
+ * let x: number;
+ * let y: number;
+ * let z: number | undefined;
+ *
+ * if (isStrictPosition(position)) {
+ *   // `tsc` would throw an error if we tried to destructure a fourth parameter
+ * 	 [x, y, z] = position;
+ * } else {
+ * 	 throw new TypeError("Position is not a 2D or 3D point");
+ * }
+ */
+type Position = number[];
+/**
+ * The base GeoJSON object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ * The GeoJSON specification also allows foreign members
+ * (https://tools.ietf.org/html/rfc7946#section-6.1)
+ * Developers should use "&" type in TypeScript or extend the interface
+ * to add these foreign members.
+ */
+interface GeoJsonObject {
+  // Don't include foreign members directly into this type def.
+  // in order to preserve type safety.
+  // [key: string]: any;
+  /**
+   * Specifies the type of GeoJSON object.
+   */
+  type: GeoJsonTypes;
+  /**
+   * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
+   * The value of the bbox member is an array of length 2*n where n is the number of dimensions
+   * represented in the contained geometries, with all axes of the most southwesterly point
+   * followed by all axes of the more northeasterly point.
+   * The axes order of a bbox follows the axes order of geometries.
+   * https://tools.ietf.org/html/rfc7946#section-5
+   */
+  bbox?: BBox | undefined;
+}
+/**
+ * Union of GeoJSON objects.
+ */
+type GeoJSON<G extends Geometry | null = Geometry, P = GeoJsonProperties> = G | Feature<G, P> | FeatureCollection<G, P>;
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+interface Point extends GeoJsonObject {
+  type: "Point";
+  coordinates: Position;
+}
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+interface MultiPoint extends GeoJsonObject {
+  type: "MultiPoint";
+  coordinates: Position[];
+}
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+interface LineString extends GeoJsonObject {
+  type: "LineString";
+  coordinates: Position[];
+}
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+interface MultiLineString extends GeoJsonObject {
+  type: "MultiLineString";
+  coordinates: Position[][];
+}
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+interface Polygon extends GeoJsonObject {
+  type: "Polygon";
+  coordinates: Position[][];
+}
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+interface MultiPolygon extends GeoJsonObject {
+  type: "MultiPolygon";
+  coordinates: Position[][][];
+}
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+  type: "GeometryCollection";
+  geometries: G[];
+}
+type GeoJsonProperties = {
+  [name: string]: any;
+} | null;
+/**
+ * A feature object which contains a geometry and associated properties.
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+  type: "Feature";
+  /**
+   * The feature's geometry
+   */
+  geometry: G;
+  /**
+   * A value that uniquely identifies this feature in a
+   * https://tools.ietf.org/html/rfc7946#section-3.2.
+   */
+  id?: string | number | undefined;
+  /**
+   * Properties associated with this feature.
+   */
+  properties: P;
+}
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+  type: "FeatureCollection";
+  features: Array<Feature<G, P>>;
+}
+//#endregion
+//#region src/projection/types.d.ts
+type GeographicPosition = readonly number[];
+interface UtmCrs {
+  readonly kind: "utm";
+  readonly zone: number;
+  readonly hemisphere: "north" | "south";
+}
+interface UpsCrs {
+  readonly kind: "ups";
+  readonly hemisphere: "north" | "south";
+}
+type GridCrs = UtmCrs | UpsCrs;
+//#endregion
+//#region src/scene.d.ts
+interface SceneRectangle {
+  readonly xMm: number;
+  readonly yMm: number;
+  readonly widthMm: number;
+  readonly heightMm: number;
+}
+interface PhysicalPageSize {
+  readonly widthMm: number;
+  readonly heightMm: number;
+}
+interface MapSheetPatternIdentity {
+  readonly id: string;
+  readonly pattern: PatternId;
+  readonly color: string;
+  readonly tileWidthMm: number;
+  readonly tileHeightMm: number;
+  readonly phaseXMm: number;
+  readonly phaseYMm: number;
+}
+//#endregion
+//#region src/mgrs-grid.d.ts
+declare const SUPPORTED_INTERVALS: readonly [100, 1000, 10000, 100000];
+interface MgrsGridOptions {
+  readonly intervalMeters?: (typeof SUPPORTED_INTERVALS)[number];
+  readonly precision?: 0 | 1 | 2 | 3;
+  readonly color?: string;
+  readonly lineWidthCssPixels?: number;
+  readonly labelSizeCssPixels?: number;
+}
+interface ResolvedMgrsGridMetadata {
+  readonly kind: "mgrs";
+  readonly intervalMeters: number;
+  readonly precision: number;
+}
+//#endregion
+//#region src/marginalia.d.ts
+interface MapSheetMetadata {
+  readonly title?: string;
+  readonly subtitle?: string;
+  readonly classification?: string;
+  readonly preparedBy?: string;
+}
+interface MapSheetMarginaliaOptions {
+  readonly color?: string;
+  readonly showScale?: boolean;
+  readonly showScaleBar?: boolean;
+  readonly showGridAndNorth?: boolean;
+  readonly showRegistrationMarks?: boolean;
+  readonly showCalibrationMarks?: boolean;
+  readonly showFootprint?: boolean;
+}
+//#endregion
+//#region src/vector-symbol.d.ts
+type MapSheetSymbolSize = {
+  readonly value: number;
+  readonly unit: "pixels";
+} | {
+  readonly value: number;
+  readonly unit: "meters";
+  readonly minPixels?: number;
+  readonly maxPixels?: number;
+};
+interface VectorSymbolAnchor {
+  readonly x: number;
+  readonly y: number;
+}
+interface ControlledVectorSymbol {
+  readonly resourceId: string;
+  readonly svg: string;
+  readonly octagonSize: number;
+  readonly width: number;
+  readonly height: number;
+  readonly anchor: VectorSymbolAnchor;
+  readonly octagonAnchor: VectorSymbolAnchor;
+  readonly valid?: boolean;
+  readonly validation?: unknown;
+}
+interface MapSheetPointSymbol {
+  readonly id: string;
+  readonly kind: "point-symbol";
+  readonly sidc: string;
+  readonly position: Position;
+  readonly rotation: number;
+  readonly size: MapSheetSymbolSize;
+  readonly textAmplifiers?: TextAmplifiers;
+  readonly graphicModifiers?: {
+    readonly direction?: number;
+  };
+  readonly style?: {
+    readonly opacity?: number;
+    readonly colors?: {
+      readonly fill?: string;
+      readonly frame?: string;
+      readonly icon?: string;
+      readonly info?: string;
+      readonly outline?: string;
+    };
+    readonly monoColor?: string;
+    readonly outlineWidth?: number;
+    readonly fill?: boolean;
+    readonly frame?: boolean;
+    readonly icon?: boolean;
+  };
+  readonly rendererOptions?: {
+    readonly milsymbol?: Record<string, unknown>;
+  };
+}
+interface MapSheetCustomSymbol {
+  readonly id: string;
+  readonly kind: "custom-symbol";
+  readonly position: Position;
+  readonly rotation: number;
+  readonly size: MapSheetSymbolSize;
+  readonly opacity?: number;
+  readonly vector: ControlledVectorSymbol;
+}
+interface MapSheetPointSymbolCapability {
+  render(symbol: MapSheetPointSymbol): ControlledVectorSymbol;
+}
+//#endregion
+//#region src/render-layers.d.ts
+interface MapSheetPortrayalDefaults {
+  readonly symbolColor?: string;
+  readonly strokeWidthCssPixels?: number;
+  readonly strokeDashCssPixels?: readonly number[];
+  readonly lineCap?: "butt" | "round" | "square";
+  readonly lineJoin?: "bevel" | "round" | "miter";
+  readonly labelHeightCssPixels?: number;
+  readonly labelSizeClampCssPixels?: {
+    readonly min: number;
+    readonly max: number;
+  };
+}
+type MapSheetAuthoredGraphic = ControlMeasure | MapSheetPointSymbol | MapSheetCustomSymbol;
+interface AuthoredMapSheetGraphic {
+  readonly graphic: MapSheetAuthoredGraphic;
+}
+interface TacticalMapSheetLayer {
+  readonly id: string;
+  readonly graphics: readonly AuthoredMapSheetGraphic[];
+  readonly portrayal?: MapSheetPortrayalDefaults;
+}
+interface IdentifiedGraphicWarning {
+  readonly layerId: string;
+  readonly graphicId: string;
+}
+interface GraphicClippedWarning extends IdentifiedGraphicWarning {
+  readonly code: "graphic-clipped";
+}
+interface GraphicOutsideFrameWarning extends IdentifiedGraphicWarning {
+  readonly code: "graphic-outside-frame";
+}
+interface GraphicHiddenWarning extends IdentifiedGraphicWarning {
+  readonly code: "graphic-hidden";
+}
+interface PointSymbolFallbackWarning extends IdentifiedGraphicWarning {
+  readonly code: "point-symbol-fallback";
+}
+type GraphicVisibilityWarning = GraphicClippedWarning | GraphicOutsideFrameWarning | GraphicHiddenWarning;
+type GraphicRenderWarning = GraphicVisibilityWarning | PointSymbolFallbackWarning;
+//#endregion
+//#region src/create-tactical-map-sheet.d.ts
+interface MapSheetPageInput extends PhysicalPageSize {
+  readonly marginMm?: number;
+  readonly background?: string | "transparent";
+  readonly orientation?: "portrait" | "landscape";
+}
+interface TacticalMapSheetRequest {
+  readonly page: MapSheetPageInput;
+  readonly mapFrame?: SceneRectangle;
+  readonly center: GeographicPosition;
+  readonly scaleDenominator: number;
+  readonly projection?: "auto" | UtmCrs | UpsCrs;
+  readonly grid?: MgrsGridOptions | false;
+  readonly layers?: readonly TacticalMapSheetLayer[];
+  readonly pointSymbols?: MapSheetPointSymbolCapability;
+  readonly marginalia?: MapSheetMarginaliaOptions | false;
+  readonly metadata?: MapSheetMetadata;
+}
+type UtmProjection = UtmCrs;
+type UpsProjection = UpsCrs;
+interface CrossZoneFootprintWarning {
+  readonly code: "cross-zone-footprint";
+  readonly selectedZone: number;
+  readonly intersectedZones: readonly number[];
+}
+interface CrossProjectionFootprintWarning {
+  readonly code: "cross-projection-footprint";
+  readonly selectedProjection: "utm" | "ups";
+  readonly intersectedProjections: readonly ["ups", "utm"];
+}
+interface ScaleDeviationWarning {
+  readonly code: "scale-deviation";
+  readonly maximumRelativeDeviation: number;
+}
+type MapSheetProjectionWarning = CrossZoneFootprintWarning | CrossProjectionFootprintWarning | ScaleDeviationWarning;
+type TacticalMapSheetWarning = MapSheetProjectionWarning | GraphicRenderWarning;
+interface MapSheetFontIdentity {
+  readonly family: "Open Sans";
+  readonly style: "Regular" | "Italic" | "Light";
+  readonly version: string;
+  readonly sha256: string;
+  readonly license: string;
+  readonly provenance: string;
+}
+interface TacticalMapSheetResources {
+  readonly fonts: readonly MapSheetFontIdentity[];
+  readonly patterns: readonly MapSheetPatternIdentity[];
+}
+interface ResolvedMapSheetMetadata {
+  readonly center: Position;
+  readonly scaleDenominator: number;
+  readonly page: PhysicalPageSize;
+  readonly mapFrame: SceneRectangle;
+  readonly projection: GridCrs & {
+    readonly epsg: number;
+    readonly centerPointScale: number;
+    readonly centerConvergenceDegrees: number;
+    readonly maximumFrameScaleDeviation: number;
+  };
+  readonly grid?: ResolvedMgrsGridMetadata;
+  readonly document?: MapSheetMetadata;
+}
+interface TacticalMapSheetResult {
+  readonly svg: string;
+  readonly footprint: Polygon;
+  readonly warnings: readonly TacticalMapSheetWarning[];
+  readonly metadata: ResolvedMapSheetMetadata;
+  readonly resources: TacticalMapSheetResources;
+}
+declare function createTacticalMapSheet(request: TacticalMapSheetRequest): TacticalMapSheetResult;
+//#endregion
+export { MgrsGridOptions as A, MapSheetCustomSymbol as C, VectorSymbolAnchor as D, MapSheetSymbolSize as E, MapSheetPatternIdentity as M, Polygon as N, MapSheetMarginaliaOptions as O, ControlledVectorSymbol as S, MapSheetPointSymbolCapability as T, GraphicOutsideFrameWarning as _, ResolvedMapSheetMetadata as a, PointSymbolFallbackWarning as b, TacticalMapSheetResources as c, UpsProjection as d, UtmProjection as f, GraphicHiddenWarning as g, GraphicClippedWarning as h, MapSheetPageInput as i, ResolvedMgrsGridMetadata as j, MapSheetMetadata as k, TacticalMapSheetResult as l, AuthoredMapSheetGraphic as m, CrossZoneFootprintWarning as n, ScaleDeviationWarning as o, createTacticalMapSheet as p, MapSheetFontIdentity as r, TacticalMapSheetRequest as s, CrossProjectionFootprintWarning as t, TacticalMapSheetWarning as u, GraphicRenderWarning as v, MapSheetPointSymbol as w, TacticalMapSheetLayer as x, MapSheetPortrayalDefaults as y };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { A as MgrsGridOptions, C as MapSheetCustomSymbol, D as VectorSymbolAnchor, E as MapSheetSymbolSize, M as MapSheetPatternIdentity, O as MapSheetMarginaliaOptions, S as ControlledVectorSymbol, T as MapSheetPointSymbolCapability, _ as GraphicOutsideFrameWarning, a as ResolvedMapSheetMetadata, b as PointSymbolFallbackWarning, c as TacticalMapSheetResources, d as UpsProjection, f as UtmProjection, g as GraphicHiddenWarning, h as GraphicClippedWarning, i as MapSheetPageInput, j as ResolvedMgrsGridMetadata, k as MapSheetMetadata, l as TacticalMapSheetResult, m as AuthoredMapSheetGraphic, n as CrossZoneFootprintWarning, o as ScaleDeviationWarning, p as createTacticalMapSheet, r as MapSheetFontIdentity, s as TacticalMapSheetRequest, t as CrossProjectionFootprintWarning, u as TacticalMapSheetWarning, v as GraphicRenderWarning, w as MapSheetPointSymbol, x as TacticalMapSheetLayer, y as MapSheetPortrayalDefaults } from "./create-tactical-map-sheet-DAKVJ3Bx.mjs";
+export { type AuthoredMapSheetGraphic, type ControlledVectorSymbol, type CrossProjectionFootprintWarning, type CrossZoneFootprintWarning, type GraphicClippedWarning, type GraphicHiddenWarning, type GraphicOutsideFrameWarning, type GraphicRenderWarning, type MapSheetCustomSymbol, type MapSheetFontIdentity, type MapSheetMarginaliaOptions, type MapSheetMetadata, type MapSheetPageInput, type MapSheetPatternIdentity, type MapSheetPointSymbol, type MapSheetPointSymbolCapability, type MapSheetPortrayalDefaults, type MapSheetSymbolSize, type MgrsGridOptions, type PointSymbolFallbackWarning, type ResolvedMapSheetMetadata, type ResolvedMgrsGridMetadata, type ScaleDeviationWarning, type TacticalMapSheetLayer, type TacticalMapSheetRequest, type TacticalMapSheetResources, type TacticalMapSheetResult, type TacticalMapSheetWarning, type UpsProjection, type UtmProjection, type VectorSymbolAnchor, createTacticalMapSheet };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { t as createTacticalMapSheet } from "./create-tactical-map-sheet-6DtvTi2G.mjs";
+export { createTacticalMapSheet };

package/dist/pdf.d.mts

@@ -0,0 +1,13 @@
+import { N as Polygon, a as ResolvedMapSheetMetadata, c as TacticalMapSheetResources, s as TacticalMapSheetRequest, u as TacticalMapSheetWarning } from "./create-tactical-map-sheet-DAKVJ3Bx.mjs";
+
+//#region src/pdf.d.ts
+interface TacticalMapSheetPdfResult {
+  readonly pdf: Uint8Array;
+  readonly footprint: Polygon;
+  readonly warnings: readonly TacticalMapSheetWarning[];
+  readonly metadata: ResolvedMapSheetMetadata;
+  readonly resources: TacticalMapSheetResources;
+}
+declare function renderMapSheetPdf(request: TacticalMapSheetRequest): TacticalMapSheetPdfResult;
+//#endregion
+export { TacticalMapSheetPdfResult, renderMapSheetPdf };