@d3-maps/core 0.1.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2026 Georgii Bukharov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.css

@@ -0,0 +1,9 @@
+.d3-map {
+  height: 100%;
+  width: auto;
+  max-width: 100%;
+}
+.d3-map-zoom path {
+  vector-effect: non-scaling-stroke;
+}
+

package/dist/index.d.ts

@@ -0,0 +1,501 @@
+import { GeoPath, GeoProjection } from "d3-geo";
+import { D3ZoomEvent, D3ZoomEvent as D3ZoomEvent$1, ZoomBehavior, ZoomBehavior as ZoomBehavior$1, ZoomTransform, ZoomTransform as ZoomTransform$1 } from "d3-zoom";
+
+//#region ../../node_modules/.pnpm/@types+geojson@7946.0.16/node_modules/@types/geojson/index.d.ts
+
+/**
+ * The valid values for the "type" property of GeoJSON geometry objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+type GeoJsonGeometryTypes = Geometry["type"];
+/**
+ * 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$1 = GeoJsonProperties> = G | Feature<G, P$1> | FeatureCollection<G, P$1>;
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+type Geometry = Point$1 | MultiPoint$1 | LineString$1 | MultiLineString$1 | Polygon$1 | MultiPolygon$1 | GeometryCollection$1;
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+interface Point$1 extends GeoJsonObject {
+  type: "Point";
+  coordinates: Position;
+}
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+interface MultiPoint$1 extends GeoJsonObject {
+  type: "MultiPoint";
+  coordinates: Position[];
+}
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+interface LineString$1 extends GeoJsonObject {
+  type: "LineString";
+  coordinates: Position[];
+}
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+interface MultiLineString$1 extends GeoJsonObject {
+  type: "MultiLineString";
+  coordinates: Position[][];
+}
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+interface Polygon$1 extends GeoJsonObject {
+  type: "Polygon";
+  coordinates: Position[][];
+}
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+interface MultiPolygon$1 extends GeoJsonObject {
+  type: "MultiPolygon";
+  coordinates: Position[][][];
+}
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+interface GeometryCollection$1<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$1 = 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$1;
+}
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+interface FeatureCollection<G extends Geometry | null = Geometry, P$1 = GeoJsonProperties> extends GeoJsonObject {
+  type: "FeatureCollection";
+  features: Array<Feature<G, P$1>>;
+}
+//#endregion
+//#region src/lib/mapObject.d.ts
+type MapObject = Point$1 | Feature;
+type MapObjectFocusEventType = 'focus' | 'blur';
+type MapObjectMouseEventType = 'mouseenter' | 'mouseleave' | 'mousedown' | 'mouseup';
+type MapObjectEventType = MapObjectFocusEventType | MapObjectMouseEventType;
+type MapObjectEvent<E> = E extends MapObjectFocusEventType ? FocusEvent : MouseEvent;
+/**
+ * Supported interaction states for map objects.
+ */
+declare const mapObjectState: readonly ["default", "hover", "active"];
+type MapObjectState = typeof mapObjectState[number];
+type MapObjectStyles<TStyle> = Partial<Record<MapObjectState, TStyle>>;
+/**
+ * Maps DOM event names to interaction state updates.
+ */
+declare function getObjectStateUpdate(event: MapObjectEventType): MapObjectState;
+/**
+ * Resolves a style value for the current state (falls back to `default`).
+ */
+declare function resolveObjectStyle<TStyle>(state: MapObjectState, styles?: MapObjectStyles<TStyle>): TStyle | undefined;
+//#endregion
+//#region src/lib/feature.d.ts
+/**
+ * A GeoJSON Feature used by d3-maps.
+ *
+ * This type allows extra top-level fields to be attached in `dataTransformer` (e.g. choropleth colors).
+ */
+type MapFeature = (Feature & Record<string, unknown>) | Feature;
+/**
+ * Shared props contract for a single rendered feature.
+ */
+interface MapFeatureProps<TStyle = unknown> {
+  data: MapFeature;
+  styles?: MapObjectStyles<TStyle>;
+  fill?: string;
+  stroke?: string;
+}
+/**
+ * Resolves a stable key for a feature.
+ *
+ * Checks:
+ * 1) `feature[idKey]`
+ * 2) `feature.properties[idKey]`
+ * 3) fallback to the list index
+ */
+declare function getFeatureKey(feature: MapFeature, idKey: string | undefined, index: number): string | number;
+//#endregion
+//#region ../../node_modules/.pnpm/@types+topojson-specification@1.0.5/node_modules/@types/topojson-specification/index.d.ts
+// ---------------------------------------------------------------
+// TopoJSON Format Specification
+// ---------------------------------------------------------------
+
+// See: https://github.com/topojson/topojson-specification/
+
+// 2. TopoJSON Objects
+interface TopoJSON {
+  type: "Topology" | GeoJsonGeometryTypes | null;
+  bbox?: BBox | undefined;
+}
+// 2.1. Topology Objects
+interface Topology<T extends Objects<Properties> = Objects<Properties>> extends TopoJSON {
+  type: "Topology";
+  objects: T;
+  arcs: Arc[];
+  transform?: Transform | undefined;
+}
+// 2.1.1. Positions
+type Positions = number[];
+// at least two elements
+
+// 2.1.2. Transforms
+interface Transform {
+  scale: [number, number];
+  translate: [number, number];
+}
+// 2.1.3. Arcs
+type Arc = Positions[];
+// at least two elements
+
+// 2.1.4. Arc Indexes
+type ArcIndexes = number[];
+// 2.1.5. Objects
+type Properties = GeoJsonProperties;
+interface Objects<P$1 extends Properties = {}> {
+  [key: string]: GeometryObject<P$1>;
+}
+// 2.2. Geometry Objects
+interface GeometryObjectA<P$1 extends Properties = {}> extends TopoJSON {
+  type: GeoJsonGeometryTypes | null;
+  id?: number | string | undefined;
+  properties?: P$1 | undefined;
+}
+type GeometryObject<P$1 extends Properties = {}> = Point<P$1> | MultiPoint<P$1> | LineString<P$1> | MultiLineString<P$1> | Polygon<P$1> | MultiPolygon<P$1> | GeometryCollection<P$1> | NullObject;
+// 2.2.1. Point
+interface Point<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "Point";
+  coordinates: Positions;
+}
+// 2.2.2. MultiPoint
+interface MultiPoint<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "MultiPoint";
+  coordinates: Positions[];
+}
+// 2.2.3. LineString
+interface LineString<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "LineString";
+  arcs: ArcIndexes;
+}
+// 2.2.4. MultiLineString
+interface MultiLineString<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "MultiLineString";
+  arcs: ArcIndexes[];
+}
+// 2.2.5. Polygon
+interface Polygon<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "Polygon";
+  arcs: ArcIndexes[];
+}
+// 2.2.6. MultiPolygon
+interface MultiPolygon<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "MultiPolygon";
+  arcs: ArcIndexes[][];
+}
+// 2.2.7. Geometry Collection
+interface GeometryCollection<P$1 extends Properties = {}> extends GeometryObjectA<P$1> {
+  type: "GeometryCollection";
+  geometries: Array<GeometryObject<P$1>>;
+}
+// More
+interface NullObject extends GeometryObjectA {
+  type: null;
+}
+//#endregion
+//#region src/lib/map.d.ts
+type MapData = FeatureCollection | Topology;
+type DataTransformer = (features: MapFeature[]) => MapFeature[];
+/**
+ * Configuration for a d3-geo projection.
+ *
+ * d3-maps applies these options (if provided) before fitting the geometry to the map size.
+ */
+interface ProjectionConfig {
+  center?: [number, number];
+  rotate?: [number, number, number];
+  scale?: number;
+}
+/**
+ * Input configuration for creating a map context.
+ *
+ * In adapters, this is usually passed as component props.
+ */
+interface MapConfig {
+  width?: number;
+  height?: number;
+  aspectRatio?: number;
+  /**
+   * Projection factory from d3-geo (or a compatible implementation).
+   *
+   * Example: `geoEqualEarth`.
+   */
+  projection?: () => GeoProjection;
+  projectionConfig?: ProjectionConfig;
+  /**
+   * TopoJSON or GeoJSON input.
+   *
+   * TopoJSON is automatically converted to GeoJSON features.
+   */
+  data: MapData;
+  /**
+   * Optional feature transformer (filter/augment/normalize features).
+   */
+  dataTransformer?: DataTransformer;
+}
+/**
+ * Fully computed, framework-agnostic map context.
+ *
+ * Adapters provide this context to child layers (features, markers, custom SVG).
+ */
+interface MapContext {
+  width: number;
+  height: number;
+  projection?: GeoProjection;
+  features: MapFeature[];
+  path: GeoPath;
+  renderPath: (feature: Feature) => ReturnType<GeoPath>;
+}
+/**
+ * Creates a configured projection and fits it to the provided GeoJSON (if present).
+ */
+declare function makeProjection({
+  width,
+  height,
+  config,
+  projection,
+  geoJson
+}: {
+  width: number;
+  height: number;
+  config?: ProjectionConfig;
+  projection: () => GeoProjection;
+  geoJson?: FeatureCollection;
+}): GeoProjection;
+/**
+ * Normalizes input map data to GeoJSON features.
+ *
+ * - TopoJSON is converted via `topojson-client`.
+ * - If provided, `dataTransformer` is applied to the feature array.
+ */
+declare function makeFeatures(geoData: MapData, dataTransformer?: DataTransformer): [features: MapFeature[], geoJson: FeatureCollection];
+declare const makePathFn: (mapProjection: GeoProjection) => GeoPath;
+/**
+ * Creates a full {@link MapContext} from a {@link MapConfig}.
+ */
+declare function makeMapContext({
+  width,
+  height: passedHeight,
+  aspectRatio,
+  data,
+  dataTransformer,
+  projection: providedProjection,
+  projectionConfig
+}: MapConfig): MapContext;
+/**
+ * Type guard for TopoJSON topology inputs.
+ */
+declare function isTopology(data: MapData): data is Topology;
+//#endregion
+//#region src/lib/marker.d.ts
+type MapMarkerCoordinates = [number, number];
+/**
+ * Shared props contract for marker layers.
+ */
+interface MapMarkerProps<TStyle = unknown> {
+  coordinates?: MapMarkerCoordinates;
+  styles?: MapObjectStyles<TStyle>;
+}
+/**
+ * Computes an SVG transform (`translate(x, y)`) for the given coordinates using the active projection.
+ *
+ * Coordinates must be `[longitude, latitude]`.
+ */
+declare function getMarkerTransform(context: MapContext | undefined, coordinates: MapMarkerCoordinates, fallback?: string): string;
+//#endregion
+//#region src/lib/utils.d.ts
+declare function isString(value: unknown): value is string;
+declare function isDefined<T>(value: T | null | undefined): value is T;
+declare const isNullish: (value: unknown) => value is null | undefined;
+declare const isNumber: (value: unknown) => value is number;
+declare const isStringOrNumber: (value: unknown) => value is string | number;
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+declare function get<T>(url: string): Promise<T>;
+declare const makeTransform: (x: number, y: number, k?: number) => string;
+//#endregion
+//#region src/lib/zoom.d.ts
+type Extent = [[number, number], [number, number]];
+interface ZoomConfigOptions {
+  minZoom?: number;
+  maxZoom?: number;
+  translateExtent?: Extent;
+}
+interface ZoomConfig {
+  scaleExtent: [number, number];
+  translateExtent: Extent;
+}
+type ZoomBehaviorOwnMethodName<TElement extends Element, TDatum> = Exclude<keyof ZoomBehavior$1<TElement, TDatum>, keyof Function>;
+type ZoomBehaviorMethodName<TElement extends Element, TDatum> = Extract<{ [K in ZoomBehaviorOwnMethodName<TElement, TDatum>]: ZoomBehavior$1<TElement, TDatum>[K] extends ((...args: unknown[]) => unknown) ? K : never }[ZoomBehaviorOwnMethodName<TElement, TDatum>], string>;
+type ZoomBehaviorMethodArgs<TElement extends Element, TDatum, TMethod extends ZoomBehaviorMethodName<TElement, TDatum>> = ZoomBehavior$1<TElement, TDatum>[TMethod] extends ((...args: infer TArgs) => unknown) ? TArgs : never;
+type ZoomBehaviorSingleArg<TElement extends Element, TDatum, TMethod extends ZoomBehaviorMethodName<TElement, TDatum>> = ZoomBehaviorMethodArgs<TElement, TDatum, TMethod> extends [infer TArg] ? TArg : never;
+type ZoomModifierValue<TElement extends Element, TDatum, TMethod extends ZoomBehaviorMethodName<TElement, TDatum>> = ZoomBehaviorMethodArgs<TElement, TDatum, TMethod> | ZoomBehaviorSingleArg<TElement, TDatum, TMethod>;
+type ZoomModifiers<TElement extends Element = SVGSVGElement, TDatum = unknown> = Partial<{ [K in ZoomBehaviorMethodName<TElement, TDatum>]: ZoomModifierValue<TElement, TDatum, K> }>;
+interface ZoomProps<TElement extends Element = SVGSVGElement, TDatum = unknown> {
+  center?: [number, number];
+  zoom?: number;
+  minZoom?: number;
+  maxZoom?: number;
+  translateExtent?: Extent;
+  modifiers?: ZoomModifiers<TElement, TDatum>;
+}
+interface ZoomEvent extends D3ZoomEvent$1<SVGSVGElement, unknown> {}
+interface ZoomEvents {
+  onZoomStart?: (event: ZoomEvent) => void;
+  onZoom?: (event: ZoomEvent) => void;
+  onZoomEnd?: (event: ZoomEvent) => void;
+}
+interface ZoomBehaviorOptions<TElement extends Element = SVGSVGElement, TDatum = unknown> extends ZoomProps<TElement, TDatum>, ZoomEvents {}
+type ZoomScaleSource = number | ZoomTransform$1 | {
+  transform: ZoomTransform$1;
+};
+type ZoomTargetElement = SVGSVGElement | SVGGElement;
+declare const ZOOM_DEFAULTS: {
+  center: [number, number];
+  zoom: number;
+  minZoom: number;
+  maxZoom: number;
+  extent: Extent;
+};
+interface ApplyZoomOptions {
+  element: ZoomTargetElement | null | undefined;
+  behavior: ZoomBehavior$1<SVGSVGElement, unknown>;
+  center?: [number, number];
+  zoom?: number;
+}
+interface SetupZoomOptions extends ApplyZoomOptions {}
+declare function getDefaultTranslateExtent(context?: MapContext): Extent;
+declare function createZoomTransform(center: [number, number], zoomLevel: number): ZoomTransform$1;
+declare function createZoomConfig(options: ZoomConfigOptions): ZoomConfig;
+declare function createZoomBehavior<TElement extends Element = SVGSVGElement, TDatum = unknown>(context?: MapContext, options?: ZoomBehaviorOptions<TElement, TDatum>): ZoomBehavior$1<TElement, TDatum>;
+declare function attachZoomBehavior(element: ZoomTargetElement | null | undefined, behavior: ZoomBehavior$1<SVGSVGElement, unknown>): void;
+declare function applyZoomBehaviorTransform(element: ZoomTargetElement | null | undefined, behavior: ZoomBehavior$1<SVGSVGElement, unknown>, transform: ZoomTransform$1): void;
+declare function applyZoomTransform(options: ApplyZoomOptions): void;
+declare function setupZoom(options: SetupZoomOptions): void;
+declare function getZoomScale(source: ZoomScaleSource): number;
+declare function getInverseZoomScale(source: ZoomScaleSource, fallback?: number): number;
+//#endregion
+export { ApplyZoomOptions, type D3ZoomEvent, DataTransformer, Extent, MapConfig, MapContext, MapData, MapFeature, MapFeatureProps, MapMarkerCoordinates, MapMarkerProps, MapObject, MapObjectEvent, MapObjectEventType, MapObjectFocusEventType, MapObjectMouseEventType, MapObjectState, MapObjectStyles, ProjectionConfig, SetupZoomOptions, ZOOM_DEFAULTS, type ZoomBehavior, ZoomBehaviorMethodArgs, ZoomBehaviorMethodName, ZoomBehaviorOptions, ZoomBehaviorOwnMethodName, ZoomBehaviorSingleArg, ZoomConfig, ZoomConfigOptions, ZoomEvent, ZoomEvents, ZoomModifierValue, ZoomModifiers, ZoomProps, ZoomScaleSource, ZoomTargetElement, type ZoomTransform, applyZoomBehaviorTransform, applyZoomTransform, attachZoomBehavior, createZoomBehavior, createZoomConfig, createZoomTransform, get, getDefaultTranslateExtent, getFeatureKey, getInverseZoomScale, getMarkerTransform, getObjectStateUpdate, getZoomScale, isDefined, isFunction, isNullish, isNumber, isPlainObject, isString, isStringOrNumber, isTopology, makeFeatures, makeMapContext, makePathFn, makeProjection, makeTransform, mapObjectState, resolveObjectStyle, setupZoom };

package/dist/index.iife.js

@@ -0,0 +1 @@
+(function(e,t,n,r,i){function a(e){return typeof e==`string`}function o(e){return e!==`undefined`}let s=e=>e==null,c=e=>Number.isFinite(e),l=e=>a(e)||c(e);function u(e){return typeof e==`function`}function d(e){if(Object.prototype.toString.call(e)!==`[object Object]`)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}async function f(e){return(await fetch(e)).json()}let p=(e,t,n)=>`translate(${e}, ${t}) scale(${n??1})`;function m(e,t=`id`,n){let r=e[t];if(l(r))return r;let i=e.properties?.[t];return l(i)?i:n}function h({width:e,height:t,config:n,projection:r,geoJson:i}){let a=r();if(n?.center){let[e,t]=n.center;c(e)&&c(t)&&a.center([e,t])}if(n?.rotate){let[e,t,r]=n.rotate;c(e)&&c(t)&&a.rotate([e,t,c(r)?r:0])}return n&&c(n.scale)&&a.scale(n.scale),i?a.fitSize([e,t],i):a.translate([e/2,t/2]),a}function g(e,t){let r;if(y(e)){let t=Object.keys(e.objects)[0];if(t){let i=e.objects[t],a=(0,n.feature)(e,i);r=a.type===`FeatureCollection`?a:{type:`FeatureCollection`,features:[a]}}else r={type:`FeatureCollection`,features:[]}}else r=e;return[t?t(r.features):r.features,r]}let _=e=>(0,t.geoPath)().projection(e);function v({width:e=600,height:n,aspectRatio:r=16/9,data:i,dataTransformer:a,projection:o=t.geoEqualEarth,projectionConfig:s}){let[c,l]=g(i,a),u=n||e/r,d=h({width:e,height:u,projection:o,config:s,geoJson:l}),f=_(d);return{width:e,height:u,projection:d,features:c,path:f,renderPath:e=>f(e)}}function y(e){return e?.type===`Topology`}let b=[`default`,`hover`,`active`];function x(e){switch(e){case`focus`:case`mouseenter`:case`mouseup`:return`hover`;case`blur`:case`mouseleave`:return`default`;case`mousedown`:return`active`;default:return`default`}}function S(e,t){return t?.[e]??t?.default}function C(e,t,n=`translate(0, 0)`){let r=e?.projection;if(!r)return n;let i=r(t);return i?p(...i):n}let w={center:[0,0],zoom:1,minZoom:1,maxZoom:8,extent:[[0,0],[0,0]]};function T(e){return[[0,0],[e?.width??0,e?.height??0]]}function E(e,t){return i.zoomIdentity.translate(...e).scale(t)}function D(e){return{scaleExtent:[e.minZoom??w.minZoom,e.maxZoom??w.maxZoom],translateExtent:e.translateExtent??w.extent}}function O(e,t={}){let n=(0,i.zoom)(),r=D({minZoom:t.minZoom,maxZoom:t.maxZoom,translateExtent:t.translateExtent??T(e)});return n.scaleExtent(r.scaleExtent).translateExtent(r.translateExtent),t.onZoomStart&&n.on(`start`,t.onZoomStart),t.onZoom&&n.on(`zoom`,t.onZoom),t.onZoomEnd&&n.on(`end`,t.onZoomEnd),I(n,t.modifiers),n}function k(e,t){let n=L(e);n&&(0,r.select)(n).call(t)}function A(e,t,n){let i=L(e);i&&(0,r.select)(i).call(t.transform,n)}function j(e){let t=e.center??w.center,n=e.zoom??w.zoom;A(e.element,e.behavior,E(t,n))}function M(e){k(e.element,e.behavior),j(e)}function N(e){return c(e)?e:F(e)?e.k:e?.transform?.k??1}function P(e,t=1){let n=N(e);return!c(n)||n===0?t:1/n}function F(e){return!!(e&&c(e.k)&&c(e.x)&&c(e.y))}function I(e,t){if(t)for(let[n,r]of Object.entries(t)){if(!n||r===void 0)continue;let t=e[n];if(typeof t!=`function`)continue;let i=Array.isArray(r)?r:[r];t.apply(e,i)}}function L(e){return e?e instanceof SVGSVGElement?e:e.closest(`svg`):null}e.ZOOM_DEFAULTS=w,e.applyZoomBehaviorTransform=A,e.applyZoomTransform=j,e.attachZoomBehavior=k,e.createZoomBehavior=O,e.createZoomConfig=D,e.createZoomTransform=E,e.get=f,e.getDefaultTranslateExtent=T,e.getFeatureKey=m,e.getInverseZoomScale=P,e.getMarkerTransform=C,e.getObjectStateUpdate=x,e.getZoomScale=N,e.isDefined=o,e.isFunction=u,e.isNullish=s,e.isNumber=c,e.isPlainObject=d,e.isString=a,e.isStringOrNumber=l,e.isTopology=y,e.makeFeatures=g,e.makeMapContext=v,e.makePathFn=_,e.makeProjection=h,e.makeTransform=p,e.mapObjectState=b,e.resolveObjectStyle=S,e.setupZoom=M})(this.D3Maps=this.D3Maps||{},d3,topojson,d3,d3);

package/dist/index.js

@@ -0,0 +1,256 @@
+import { geoEqualEarth, geoPath } from "d3-geo";
+import { feature } from "topojson-client";
+import { select } from "d3-selection";
+import { zoom, zoomIdentity } from "d3-zoom";
+
+//#region src/lib/utils.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isDefined(value) {
+	return value !== "undefined";
+}
+const isNullish = (value) => value == null;
+const isNumber = (value) => Number.isFinite(value);
+const isStringOrNumber = (value) => isString(value) || isNumber(value);
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isPlainObject(value) {
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+}
+async function get(url) {
+	return (await fetch(url)).json();
+}
+const makeTransform = (x, y, k) => `translate(${x}, ${y}) scale(${k ?? 1})`;
+
+//#endregion
+//#region src/lib/feature.ts
+/**
+* Resolves a stable key for a feature.
+*
+* Checks:
+* 1) `feature[idKey]`
+* 2) `feature.properties[idKey]`
+* 3) fallback to the list index
+*/
+function getFeatureKey(feature$1, idKey = "id", index) {
+	const directValue = feature$1[idKey];
+	if (isStringOrNumber(directValue)) return directValue;
+	const propertyValue = feature$1.properties?.[idKey];
+	if (isStringOrNumber(propertyValue)) return propertyValue;
+	return index;
+}
+
+//#endregion
+//#region src/lib/map.ts
+/**
+* Creates a configured projection and fits it to the provided GeoJSON (if present).
+*/
+function makeProjection({ width, height, config, projection, geoJson }) {
+	const mapProjection = projection();
+	if (config?.center) {
+		const [cx, cy] = config.center;
+		if (isNumber(cx) && isNumber(cy)) mapProjection.center([cx, cy]);
+	}
+	if (config?.rotate) {
+		const [rx, ry, rz] = config.rotate;
+		if (isNumber(rx) && isNumber(ry)) mapProjection.rotate([
+			rx,
+			ry,
+			isNumber(rz) ? rz : 0
+		]);
+	}
+	if (config && isNumber(config.scale)) mapProjection.scale(config.scale);
+	if (geoJson) mapProjection.fitSize([width, height], geoJson);
+	else mapProjection.translate([width / 2, height / 2]);
+	return mapProjection;
+}
+/**
+* Normalizes input map data to GeoJSON features.
+*
+* - TopoJSON is converted via `topojson-client`.
+* - If provided, `dataTransformer` is applied to the feature array.
+*/
+function makeFeatures(geoData, dataTransformer) {
+	let geoJson;
+	if (isTopology(geoData)) {
+		const objectKey = Object.keys(geoData.objects)[0];
+		if (objectKey) {
+			const topoObject = geoData.objects[objectKey];
+			const normalizedGeoJson = feature(geoData, topoObject);
+			geoJson = normalizedGeoJson.type === "FeatureCollection" ? normalizedGeoJson : {
+				type: "FeatureCollection",
+				features: [normalizedGeoJson]
+			};
+		} else geoJson = {
+			type: "FeatureCollection",
+			features: []
+		};
+	} else geoJson = geoData;
+	return [dataTransformer ? dataTransformer(geoJson.features) : geoJson.features, geoJson];
+}
+const makePathFn = (mapProjection) => geoPath().projection(mapProjection);
+/**
+* Creates a full {@link MapContext} from a {@link MapConfig}.
+*/
+function makeMapContext({ width = 600, height: passedHeight, aspectRatio = 16 / 9, data, dataTransformer, projection: providedProjection = geoEqualEarth, projectionConfig }) {
+	const [features, geoJson] = makeFeatures(data, dataTransformer);
+	const height = passedHeight || width / aspectRatio;
+	const projection = makeProjection({
+		width,
+		height,
+		projection: providedProjection,
+		config: projectionConfig,
+		geoJson
+	});
+	const pathFn = makePathFn(projection);
+	return {
+		width,
+		height,
+		projection,
+		features,
+		path: pathFn,
+		renderPath: (feature$1) => pathFn(feature$1)
+	};
+}
+/**
+* Type guard for TopoJSON topology inputs.
+*/
+function isTopology(data) {
+	return data?.type === "Topology";
+}
+
+//#endregion
+//#region src/lib/mapObject.ts
+/**
+* Supported interaction states for map objects.
+*/
+const mapObjectState = [
+	"default",
+	"hover",
+	"active"
+];
+/**
+* Maps DOM event names to interaction state updates.
+*/
+function getObjectStateUpdate(event) {
+	switch (event) {
+		case "focus":
+		case "mouseenter":
+		case "mouseup": return "hover";
+		case "blur":
+		case "mouseleave": return "default";
+		case "mousedown": return "active";
+		default: return "default";
+	}
+}
+/**
+* Resolves a style value for the current state (falls back to `default`).
+*/
+function resolveObjectStyle(state, styles) {
+	return styles?.[state] ?? styles?.default;
+}
+
+//#endregion
+//#region src/lib/marker.ts
+/**
+* Computes an SVG transform (`translate(x, y)`) for the given coordinates using the active projection.
+*
+* Coordinates must be `[longitude, latitude]`.
+*/
+function getMarkerTransform(context, coordinates, fallback = "translate(0, 0)") {
+	const projection = context?.projection;
+	if (!projection) return fallback;
+	const projected = projection(coordinates);
+	if (!projected) return fallback;
+	return makeTransform(...projected);
+}
+
+//#endregion
+//#region src/lib/zoom.ts
+const ZOOM_DEFAULTS = {
+	center: [0, 0],
+	zoom: 1,
+	minZoom: 1,
+	maxZoom: 8,
+	extent: [[0, 0], [0, 0]]
+};
+function getDefaultTranslateExtent(context) {
+	return [[0, 0], [context?.width ?? 0, context?.height ?? 0]];
+}
+function createZoomTransform(center, zoomLevel) {
+	return zoomIdentity.translate(...center).scale(zoomLevel);
+}
+function createZoomConfig(options) {
+	return {
+		scaleExtent: [options.minZoom ?? ZOOM_DEFAULTS.minZoom, options.maxZoom ?? ZOOM_DEFAULTS.maxZoom],
+		translateExtent: options.translateExtent ?? ZOOM_DEFAULTS.extent
+	};
+}
+function createZoomBehavior(context, options = {}) {
+	const behavior = zoom();
+	const config = createZoomConfig({
+		minZoom: options.minZoom,
+		maxZoom: options.maxZoom,
+		translateExtent: options.translateExtent ?? getDefaultTranslateExtent(context)
+	});
+	behavior.scaleExtent(config.scaleExtent).translateExtent(config.translateExtent);
+	if (options.onZoomStart) behavior.on("start", options.onZoomStart);
+	if (options.onZoom) behavior.on("zoom", options.onZoom);
+	if (options.onZoomEnd) behavior.on("end", options.onZoomEnd);
+	applyZoomModifiers(behavior, options.modifiers);
+	return behavior;
+}
+function attachZoomBehavior(element, behavior) {
+	const svgElement = getSvgElement(element);
+	if (!svgElement) return;
+	select(svgElement).call(behavior);
+}
+function applyZoomBehaviorTransform(element, behavior, transform) {
+	const svgElement = getSvgElement(element);
+	if (!svgElement) return;
+	select(svgElement).call(behavior.transform, transform);
+}
+function applyZoomTransform(options) {
+	const center = options.center ?? ZOOM_DEFAULTS.center;
+	const zoom$1 = options.zoom ?? ZOOM_DEFAULTS.zoom;
+	applyZoomBehaviorTransform(options.element, options.behavior, createZoomTransform(center, zoom$1));
+}
+function setupZoom(options) {
+	attachZoomBehavior(options.element, options.behavior);
+	applyZoomTransform(options);
+}
+function getZoomScale(source) {
+	if (isNumber(source)) return source;
+	if (isZoomTransform(source)) return source.k;
+	return source?.transform?.k ?? 1;
+}
+function getInverseZoomScale(source, fallback = 1) {
+	const scale = getZoomScale(source);
+	if (!isNumber(scale) || scale === 0) return fallback;
+	return 1 / scale;
+}
+function isZoomTransform(value) {
+	return Boolean(value && isNumber(value.k) && isNumber(value.x) && isNumber(value.y));
+}
+function applyZoomModifiers(behavior, modifiers) {
+	if (!modifiers) return;
+	for (const [methodName, methodArgs] of Object.entries(modifiers)) {
+		if (!methodName || methodArgs === void 0) continue;
+		const modifier = behavior[methodName];
+		if (typeof modifier !== "function") continue;
+		const normalizedArgs = Array.isArray(methodArgs) ? methodArgs : [methodArgs];
+		modifier.apply(behavior, normalizedArgs);
+	}
+}
+function getSvgElement(element) {
+	if (!element) return null;
+	if (element instanceof SVGSVGElement) return element;
+	return element.closest("svg");
+}
+
+//#endregion
+export { ZOOM_DEFAULTS, applyZoomBehaviorTransform, applyZoomTransform, attachZoomBehavior, createZoomBehavior, createZoomConfig, createZoomTransform, get, getDefaultTranslateExtent, getFeatureKey, getInverseZoomScale, getMarkerTransform, getObjectStateUpdate, getZoomScale, isDefined, isFunction, isNullish, isNumber, isPlainObject, isString, isStringOrNumber, isTopology, makeFeatures, makeMapContext, makePathFn, makeProjection, makeTransform, mapObjectState, resolveObjectStyle, setupZoom };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@d3-maps/core",
+  "version": "0.1.0",
+  "type": "module",
+  "private": false,
+  "description": "Framework-agnostic core utilities for building reactive D3 maps",
+  "author": "Georgii Bukharov <souljorje@gmail.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/souljorje/d3-maps.git",
+    "directory": "packages/core"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "browser": "./dist/index.iife.js"
+    },
+    "./*.css": {
+      "import": "./dist/*.css",
+      "browser": "./dist/*.css"
+    }
+  },
+  "style": "dist/index.css",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "browser": "dist/index.iife.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/*"
+  ],
+  "dependencies": {
+    "d3-geo": "^3.1.1",
+    "d3-selection": "^3.0.0",
+    "d3-zoom": "^3.0.0",
+    "topojson-client": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/d3-geo": "^3.1.0",
+    "@types/d3-selection": "^3.0.11",
+    "@types/d3-zoom": "^3.0.8",
+    "@types/geojson": "^7946.0.16",
+    "@types/topojson-client": "^3.1.5",
+    "@types/topojson-specification": "^1.0.5",
+    "typescript": "^5.9.3",
+    "tsdown": "0.19.0",
+    "vitest": "^4.0.15"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "pnpm run typecheck && tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}