@atlas-composer/projection-loader 1.0.0

package/README.md

@@ -0,0 +1,409 @@
+# @atlas-composer/projection-loader
+
+> Zero-dependency standalone loader for composite map projections with plugin architecture
+
+A lightweight, framework-agnostic library for loading composite map projections exported from [Atlas composer](https://github.com/ShallowRed/atlas-composer). Features a plugin architecture that lets you register only the projections you need, achieving **94% smaller bundle sizes** compared to including all D3 projections.
+
+## Features
+
+- 🎯 **Zero Dependencies** - Bring your own projections (D3, Proj4, or custom)
+- 📦 **Tree-Shakeable** - Only bundle what you use (~6KB vs 100KB)
+- 🔌 **Plugin Architecture** - Register projections on-demand
+- 🌐 **Framework Agnostic** - Works with D3, Observable Plot, React, Vue, Svelte
+- 📘 **Full TypeScript Support** - Complete type definitions included
+- ⚡ **Fast** - Optimized stream multiplexing for efficient rendering
+
+## Installation
+
+```bash
+npm install @atlas-composer/projection-loader d3-geo d3-geo-projection
+# or
+pnpm add @atlas-composer/projection-loader d3-geo d3-geo-projection
+# or
+yarn add @atlas-composer/projection-loader d3-geo d3-geo-projection
+```
+
+## Quick Start
+
+```typescript
+import { loadCompositeProjection, registerProjection } from '@atlas-composer/projection-loader'
+import * as d3 from 'd3-geo'
+
+// 2. Load your exported configuration
+import config from './france-composite.json'
+
+// 1. Register projections (only what you need!)
+registerProjection('mercator', () => d3.geoMercator())
+registerProjection('conic-conformal', () => d3.geoConicConformal())
+
+const projection = loadCompositeProjection(config, {
+  width: 800,
+  height: 600
+})
+
+// 3. Use with D3
+const path = d3.geoPath(projection)
+
+svg.selectAll('path')
+  .data(features)
+  .join('path')
+  .attr('d', path)
+  .attr('fill', 'lightgray')
+  .attr('stroke', 'white')
+```
+
+## Usage with Helpers (Convenience)
+
+For quick prototyping, use the optional helpers module:
+
+```typescript
+import { registerProjections } from '@atlas-composer/projection-loader'
+import { d3ProjectionFactories } from '@atlas-composer/projection-loader/helpers'
+
+// Register all standard D3 projections at once
+registerProjections(d3ProjectionFactories)
+
+// Now load your configuration
+const projection = loadCompositeProjection(config, { width: 800, height: 600 })
+```
+
+## Tree-Shaking (Production)
+
+For optimal bundle sizes, import only what you need:
+
+```typescript
+import { loadCompositeProjection, registerProjections } from '@atlas-composer/projection-loader'
+import { geoConicConformal, geoMercator } from 'd3-geo'
+
+// Only these two projections will be in your bundle
+registerProjections({
+  'mercator': () => geoMercator(),
+  'conic-conformal': () => geoConicConformal()
+})
+
+const projection = loadCompositeProjection(config, { width: 800, height: 600 })
+```
+
+**Result**: ~6KB instead of ~100KB (94% reduction) 🎉
+
+## Observable Plot Integration
+
+```typescript
+import { loadCompositeProjection, registerProjection } from '@atlas-composer/projection-loader'
+import * as Plot from '@observablehq/plot'
+import * as d3 from 'd3-geo'
+
+// Register projections
+registerProjection('mercator', () => d3.geoMercator())
+registerProjection('conic-conformal', () => d3.geoConicConformal())
+
+// Create projection factory for Plot
+function createProjection({ width, height }) {
+  return loadCompositeProjection(config, { width, height })
+}
+
+// Use with Plot
+Plot.plot({
+  width: 975,
+  height: 610,
+  projection: createProjection,
+  marks: [
+    Plot.geo(countries, { fill: 'lightgray', stroke: 'white' })
+  ]
+})
+```
+
+## Framework Examples
+
+### React
+
+```tsx
+import { loadCompositeProjection, registerProjections } from '@atlas-composer/projection-loader'
+import * as d3 from 'd3-geo'
+import { useEffect, useRef } from 'react'
+
+function MapComponent({ config }) {
+  const svgRef = useRef<SVGSVGElement>(null)
+
+  useEffect(() => {
+    // Register projections once
+    registerProjections({
+      'mercator': () => d3.geoMercator(),
+      'conic-conformal': () => d3.geoConicConformal()
+    })
+
+    // Create projection
+    const projection = loadCompositeProjection(config, {
+      width: 800,
+      height: 600
+    })
+
+    // Render map
+    const path = d3.geoPath(projection)
+    const svg = d3.select(svgRef.current)
+
+    svg.selectAll('path')
+      .data(features)
+      .join('path')
+      .attr('d', path)
+      .attr('fill', 'lightgray')
+  }, [config])
+
+  return <svg ref={svgRef} width={800} height={600} />
+}
+```
+
+### Vue 3
+
+```vue
+<script setup lang="ts">
+import { loadCompositeProjection, registerProjections } from '@atlas-composer/projection-loader'
+import * as d3 from 'd3-geo'
+import { onMounted, ref } from 'vue'
+
+const props = defineProps<{ config: any }>()
+const svgRef = ref<SVGSVGElement>()
+
+onMounted(() => {
+  registerProjections({
+    'mercator': () => d3.geoMercator(),
+    'conic-conformal': () => d3.geoConicConformal()
+  })
+
+  const projection = loadCompositeProjection(props.config, {
+    width: 800,
+    height: 600
+  })
+
+  const path = d3.geoPath(projection)
+  const svg = d3.select(svgRef.value)
+
+  svg.selectAll('path')
+    .data(features)
+    .join('path')
+    .attr('d', path)
+    .attr('fill', 'lightgray')
+})
+</script>
+
+<template>
+  <svg
+    ref="svgRef"
+    width="800"
+    height="600"
+  />
+</template>
+```
+
+### Svelte
+
+```svelte
+<script lang="ts">
+import * as d3 from 'd3-geo'
+import { onMount } from 'svelte'
+import { loadCompositeProjection, registerProjections } from '@atlas-composer/projection-loader'
+
+export let config: any
+
+let svgElement: SVGSVGElement
+
+onMount(() => {
+  registerProjections({
+    'mercator': () => d3.geoMercator(),
+    'conic-conformal': () => d3.geoConicConformal()
+  })
+
+  const projection = loadCompositeProjection(config, {
+    width: 800,
+    height: 600
+  })
+
+  const path = d3.geoPath(projection)
+  const svg = d3.select(svgElement)
+
+  svg.selectAll('path')
+    .data(features)
+    .join('path')
+    .attr('d', path)
+    .attr('fill', 'lightgray')
+})
+</script>
+
+<svg bind:this={svgElement} width="800" height="600" />
+```
+
+## Custom Projections
+
+You can register any projection factory, including custom implementations:
+
+```typescript
+import { registerProjection } from '@atlas-composer/projection-loader'
+
+// Custom projection
+registerProjection('my-custom', () => {
+  // Return a D3-compatible projection
+  return {
+    // Implement projection interface
+    (coordinates) => [x, y],
+    scale: (s?) => s ? (scale = s, this) : scale,
+    translate: (t?) => t ? (translate = t, this) : translate,
+    // ... other D3 projection methods
+  }
+})
+
+// Proj4 wrapper
+import proj4 from 'proj4'
+
+registerProjection('lambert93', () => {
+  const projection = proj4('EPSG:2154')
+  return {
+    (coords) => projection.forward(coords),
+    scale: () => 1,
+    translate: () => [0, 0]
+  }
+})
+```
+
+## API Reference
+
+### Core Functions
+
+#### `registerProjection(id: string, factory: ProjectionFactory): void`
+
+Register a projection factory with a given ID.
+
+```typescript
+registerProjection('mercator', () => d3.geoMercator())
+```
+
+#### `registerProjections(factories: Record<string, ProjectionFactory>): void`
+
+Register multiple projections at once.
+
+```typescript
+registerProjections({
+  mercator: () => d3.geoMercator(),
+  albers: () => d3.geoAlbers()
+})
+```
+
+#### `loadCompositeProjection(config: ExportedConfig, options: LoaderOptions): ProjectionLike`
+
+Load a composite projection from an exported configuration.
+
+```typescript
+const projection = loadCompositeProjection(config, {
+  width: 800,
+  height: 600,
+  enableClipping: true, // optional, default: true
+  debug: false // optional, default: false
+})
+```
+
+#### `loadFromJSON(jsonString: string, options: LoaderOptions): ProjectionLike`
+
+Load a composite projection from a JSON string.
+
+```typescript
+const jsonString = fs.readFileSync('config.json', 'utf-8')
+const projection = loadFromJSON(jsonString, { width: 800, height: 600 })
+```
+
+### Utility Functions
+
+#### `getRegisteredProjections(): string[]`
+
+Get list of registered projection IDs.
+
+#### `isProjectionRegistered(id: string): boolean`
+
+Check if a projection is registered.
+
+#### `unregisterProjection(id: string): boolean`
+
+Remove a projection from the registry.
+
+#### `clearProjections(): void`
+
+Clear all registered projections.
+
+#### `validateConfig(config: any): boolean`
+
+Validate a configuration object. Throws descriptive errors if invalid.
+
+## Configuration Format
+
+Exported configurations follow this structure:
+
+```typescript
+interface ExportedConfig {
+  version: '1.0'
+  metadata: {
+    atlasId: string
+    atlasName: string
+  }
+  pattern: 'single-focus' | 'equal-members'
+  referenceScale: number
+  territories: Territory[]
+}
+
+interface Territory {
+  code: string
+  name: string
+  role: 'primary' | 'secondary' | 'member'
+  projectionId: string
+  projectionFamily: string
+  parameters: {
+    center?: [number, number]
+    rotate?: [number, number, number]
+    parallels?: [number, number]
+    scale: number
+    baseScale: number
+    scaleMultiplier: number
+  }
+  layout: {
+    translateOffset: [number, number]
+    clipExtent: [[number, number], [number, number]] | null
+  }
+  bounds: [[number, number], [number, number]]
+}
+```
+
+## Bundle Size
+
+| Approach | Bundle Size | Savings |
+|----------|-------------|---------|
+| All D3 projections | ~100KB | - |
+| With projection-loader | ~6KB | **94%** 🎉 |
+
+## TypeScript Support
+
+Full TypeScript definitions are included. No need for `@types/*` packages.
+
+```typescript
+import type {
+  ExportedConfig,
+  LoaderOptions,
+  ProjectionFactory,
+  ProjectionLike,
+  Territory
+} from '@atlas-composer/projection-loader'
+```
+
+## Browser Support
+
+Works in all modern browsers that support ES2020+. For older browsers, transpile with your build tool.
+
+## Contributing
+
+Contributions are welcome! This package is part of the [Atlas composer](https://github.com/ShallowRed/atlas-composer) monorepo.
+
+## License
+
+MIT © 2025 Lucas Poulain
+
+## Related
+
+- [Atlas composer](https://github.com/ShallowRed/atlas-composer) - Create custom composite projections
+- [D3.js](https://d3js.org/) - Data visualization library
+- [Observable Plot](https://observablehq.com/plot/) - High-level plotting library

package/dist/d3-projection-helpers.d.ts

@@ -0,0 +1,91 @@
+import { ProjectionFactory } from './index.js';
+
+/**
+ * D3 Projection Helpers
+ *
+ * Optional companion file that provides ready-to-use D3 projection factory mappings.
+ * This file has dependencies on d3-geo and d3-geo-projection, but the main loader does not.
+ *
+ * Users can import this to quickly register all standard D3 projections, or they can
+ * selectively import only the projections they need for tree-shaking.
+ *
+ * @example
+ * ```typescript
+ * // Register all projections at once
+ * import { registerProjections } from './standalone-projection-loader'
+ * import { d3ProjectionFactories } from './d3-projection-helpers'
+ *
+ * registerProjections(d3ProjectionFactories)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Tree-shakeable: import only what you need
+ * import { registerProjection } from './standalone-projection-loader'
+ * import { mercator, albers } from './d3-projection-helpers'
+ *
+ * registerProjection('mercator', mercator)
+ * registerProjection('albers', albers)
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+declare const azimuthalEqualArea: ProjectionFactory;
+declare const azimuthalEquidistant: ProjectionFactory;
+declare const gnomonic: ProjectionFactory;
+declare const orthographic: ProjectionFactory;
+declare const stereographic: ProjectionFactory;
+declare const conicConformal: ProjectionFactory;
+declare const conicEqualArea: ProjectionFactory;
+declare const conicEquidistant: ProjectionFactory;
+declare const albers: ProjectionFactory;
+declare const mercator: ProjectionFactory;
+declare const transverseMercator: ProjectionFactory;
+declare const equirectangular: ProjectionFactory;
+declare const naturalEarth1: ProjectionFactory;
+declare const equalEarth: ProjectionFactory;
+/**
+ * Object containing all standard D3 projection factories
+ * Keyed by the projection ID used in Atlas Composer configurations
+ */
+declare const d3ProjectionFactories: Record<string, ProjectionFactory>;
+/**
+ * Convenience function to register all D3 projections at once
+ *
+ * @example
+ * ```typescript
+ * import { registerProjections } from './standalone-projection-loader'
+ * import { registerAllD3Projections } from './d3-projection-helpers'
+ *
+ * registerAllD3Projections(registerProjections)
+ * ```
+ *
+ * @param registerFn - The registerProjections function from the loader
+ */
+declare function registerAllD3Projections(registerFn: (factories: Record<string, ProjectionFactory>) => void): void;
+/**
+ * Get list of available D3 projection IDs
+ */
+declare function getAvailableD3Projections(): string[];
+declare const _default: {
+    d3ProjectionFactories: Record<string, ProjectionFactory>;
+    registerAllD3Projections: typeof registerAllD3Projections;
+    getAvailableD3Projections: typeof getAvailableD3Projections;
+    azimuthalEqualArea: ProjectionFactory;
+    azimuthalEquidistant: ProjectionFactory;
+    gnomonic: ProjectionFactory;
+    orthographic: ProjectionFactory;
+    stereographic: ProjectionFactory;
+    conicConformal: ProjectionFactory;
+    conicEqualArea: ProjectionFactory;
+    conicEquidistant: ProjectionFactory;
+    albers: ProjectionFactory;
+    mercator: ProjectionFactory;
+    transverseMercator: ProjectionFactory;
+    equirectangular: ProjectionFactory;
+    naturalEarth1: ProjectionFactory;
+    equalEarth: ProjectionFactory;
+};
+
+export { albers, azimuthalEqualArea, azimuthalEquidistant, conicConformal, conicEqualArea, conicEquidistant, d3ProjectionFactories, _default as default, equalEarth, equirectangular, getAvailableD3Projections, gnomonic, mercator, naturalEarth1, orthographic, registerAllD3Projections, stereographic, transverseMercator };

package/dist/d3-projection-helpers.js

@@ -0,0 +1,68 @@
+import * as d3Geo from 'd3-geo';
+import * as d3GeoProjection from 'd3-geo-projection';
+
+// src/d3-projection-helpers.ts
+var azimuthalEqualArea = () => d3Geo.geoAzimuthalEqualArea();
+var azimuthalEquidistant = () => d3Geo.geoAzimuthalEquidistant();
+var gnomonic = () => d3Geo.geoGnomonic();
+var orthographic = () => d3Geo.geoOrthographic();
+var stereographic = () => d3Geo.geoStereographic();
+var conicConformal = () => d3Geo.geoConicConformal();
+var conicEqualArea = () => d3Geo.geoConicEqualArea();
+var conicEquidistant = () => d3Geo.geoConicEquidistant();
+var albers = () => d3Geo.geoAlbers();
+var mercator = () => d3Geo.geoMercator();
+var transverseMercator = () => d3Geo.geoTransverseMercator();
+var equirectangular = () => d3Geo.geoEquirectangular();
+var naturalEarth1 = () => d3GeoProjection.geoNaturalEarth1();
+var equalEarth = () => d3Geo.geoEqualEarth();
+var d3ProjectionFactories = {
+  // Azimuthal
+  "azimuthal-equal-area": azimuthalEqualArea,
+  "azimuthal-equidistant": azimuthalEquidistant,
+  "gnomonic": gnomonic,
+  "orthographic": orthographic,
+  "stereographic": stereographic,
+  // Conic
+  "conic-conformal": conicConformal,
+  "conic-equal-area": conicEqualArea,
+  "conic-equidistant": conicEquidistant,
+  "albers": albers,
+  // Cylindrical
+  "mercator": mercator,
+  "transverse-mercator": transverseMercator,
+  "equirectangular": equirectangular,
+  "natural-earth-1": naturalEarth1,
+  // Other
+  "equal-earth": equalEarth
+};
+function registerAllD3Projections(registerFn) {
+  registerFn(d3ProjectionFactories);
+}
+function getAvailableD3Projections() {
+  return Object.keys(d3ProjectionFactories);
+}
+var d3_projection_helpers_default = {
+  d3ProjectionFactories,
+  registerAllD3Projections,
+  getAvailableD3Projections,
+  // Individual projections for tree-shaking
+  azimuthalEqualArea,
+  azimuthalEquidistant,
+  gnomonic,
+  orthographic,
+  stereographic,
+  conicConformal,
+  conicEqualArea,
+  conicEquidistant,
+  albers,
+  mercator,
+  transverseMercator,
+  equirectangular,
+  naturalEarth1,
+  equalEarth
+};
+
+export { albers, azimuthalEqualArea, azimuthalEquidistant, conicConformal, conicEqualArea, conicEquidistant, d3ProjectionFactories, d3_projection_helpers_default as default, equalEarth, equirectangular, getAvailableD3Projections, gnomonic, mercator, naturalEarth1, orthographic, registerAllD3Projections, stereographic, transverseMercator };
+//# sourceMappingURL=d3-projection-helpers.js.map
+//# sourceMappingURL=d3-projection-helpers.js.map

package/dist/d3-projection-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/d3-projection-helpers.ts"],"names":[],"mappings":";;;;AAoCO,IAAM,kBAAA,GAAwC,MAAY,KAAA,CAAA,qBAAA;AAC1D,IAAM,oBAAA,GAA0C,MAAY,KAAA,CAAA,uBAAA;AAC5D,IAAM,QAAA,GAA8B,MAAY,KAAA,CAAA,WAAA;AAChD,IAAM,YAAA,GAAkC,MAAY,KAAA,CAAA,eAAA;AACpD,IAAM,aAAA,GAAmC,MAAY,KAAA,CAAA,gBAAA;AAGrD,IAAM,cAAA,GAAoC,MAAY,KAAA,CAAA,iBAAA;AACtD,IAAM,cAAA,GAAoC,MAAY,KAAA,CAAA,iBAAA;AACtD,IAAM,gBAAA,GAAsC,MAAY,KAAA,CAAA,mBAAA;AACxD,IAAM,MAAA,GAA4B,MAAY,KAAA,CAAA,SAAA;AAG9C,IAAM,QAAA,GAA8B,MAAY,KAAA,CAAA,WAAA;AAChD,IAAM,kBAAA,GAAwC,MAAY,KAAA,CAAA,qBAAA;AAC1D,IAAM,eAAA,GAAqC,MAAY,KAAA,CAAA,kBAAA;AACvD,IAAM,aAAA,GAAmC,MAA+B,eAAA,CAAA,gBAAA;AAGxE,IAAM,UAAA,GAAgC,MAAY,KAAA,CAAA,aAAA;AAMlD,IAAM,qBAAA,GAA2D;AAAA;AAAA,EAEtE,sBAAA,EAAwB,kBAAA;AAAA,EACxB,uBAAA,EAAyB,oBAAA;AAAA,EACzB,UAAA,EAAY,QAAA;AAAA,EACZ,cAAA,EAAgB,YAAA;AAAA,EAChB,eAAA,EAAiB,aAAA;AAAA;AAAA,EAGjB,iBAAA,EAAmB,cAAA;AAAA,EACnB,kBAAA,EAAoB,cAAA;AAAA,EACpB,mBAAA,EAAqB,gBAAA;AAAA,EACrB,QAAA,EAAU,MAAA;AAAA;AAAA,EAGV,UAAA,EAAY,QAAA;AAAA,EACZ,qBAAA,EAAuB,kBAAA;AAAA,EACvB,iBAAA,EAAmB,eAAA;AAAA,EACnB,iBAAA,EAAmB,aAAA;AAAA;AAAA,EAGnB,aAAA,EAAe;AACjB;AAeO,SAAS,yBACd,UAAA,EACM;AACN,EAAA,UAAA,CAAW,qBAAqB,CAAA;AAClC;AAKO,SAAS,yBAAA,GAAsC;AACpD,EAAA,OAAO,MAAA,CAAO,KAAK,qBAAqB,CAAA;AAC1C;AAGA,IAAO,6BAAA,GAAQ;AAAA,EACb,qBAAA;AAAA,EACA,wBAAA;AAAA,EACA,yBAAA;AAAA;AAAA,EAGA,kBAAA;AAAA,EACA,oBAAA;AAAA,EACA,QAAA;AAAA,EACA,YAAA;AAAA,EACA,aAAA;AAAA,EACA,cAAA;AAAA,EACA,cAAA;AAAA,EACA,gBAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA;AAAA,EACA,kBAAA;AAAA,EACA,eAAA;AAAA,EACA,aAAA;AAAA,EACA;AACF","file":"d3-projection-helpers.js","sourcesContent":["/**\n * D3 Projection Helpers\n *\n * Optional companion file that provides ready-to-use D3 projection factory mappings.\n * This file has dependencies on d3-geo and d3-geo-projection, but the main loader does not.\n *\n * Users can import this to quickly register all standard D3 projections, or they can\n * selectively import only the projections they need for tree-shaking.\n *\n * @example\n * ```typescript\n * // Register all projections at once\n * import { registerProjections } from './standalone-projection-loader'\n * import { d3ProjectionFactories } from './d3-projection-helpers'\n *\n * registerProjections(d3ProjectionFactories)\n * ```\n *\n * @example\n * ```typescript\n * // Tree-shakeable: import only what you need\n * import { registerProjection } from './standalone-projection-loader'\n * import { mercator, albers } from './d3-projection-helpers'\n *\n * registerProjection('mercator', mercator)\n * registerProjection('albers', albers)\n * ```\n *\n * @packageDocumentation\n */\n\nimport type { ProjectionFactory } from './standalone-projection-loader'\nimport * as d3Geo from 'd3-geo'\nimport * as d3GeoProjection from 'd3-geo-projection'\n\n// Azimuthal projections\nexport const azimuthalEqualArea: ProjectionFactory = () => d3Geo.geoAzimuthalEqualArea()\nexport const azimuthalEquidistant: ProjectionFactory = () => d3Geo.geoAzimuthalEquidistant()\nexport const gnomonic: ProjectionFactory = () => d3Geo.geoGnomonic()\nexport const orthographic: ProjectionFactory = () => d3Geo.geoOrthographic()\nexport const stereographic: ProjectionFactory = () => d3Geo.geoStereographic()\n\n// Conic projections\nexport const conicConformal: ProjectionFactory = () => d3Geo.geoConicConformal()\nexport const conicEqualArea: ProjectionFactory = () => d3Geo.geoConicEqualArea()\nexport const conicEquidistant: ProjectionFactory = () => d3Geo.geoConicEquidistant()\nexport const albers: ProjectionFactory = () => d3Geo.geoAlbers()\n\n// Cylindrical projections\nexport const mercator: ProjectionFactory = () => d3Geo.geoMercator()\nexport const transverseMercator: ProjectionFactory = () => d3Geo.geoTransverseMercator()\nexport const equirectangular: ProjectionFactory = () => d3Geo.geoEquirectangular()\nexport const naturalEarth1: ProjectionFactory = () => (d3GeoProjection as any).geoNaturalEarth1()\n\n// Other projections\nexport const equalEarth: ProjectionFactory = () => d3Geo.geoEqualEarth()\n\n/**\n * Object containing all standard D3 projection factories\n * Keyed by the projection ID used in Atlas Composer configurations\n */\nexport const d3ProjectionFactories: Record<string, ProjectionFactory> = {\n  // Azimuthal\n  'azimuthal-equal-area': azimuthalEqualArea,\n  'azimuthal-equidistant': azimuthalEquidistant,\n  'gnomonic': gnomonic,\n  'orthographic': orthographic,\n  'stereographic': stereographic,\n\n  // Conic\n  'conic-conformal': conicConformal,\n  'conic-equal-area': conicEqualArea,\n  'conic-equidistant': conicEquidistant,\n  'albers': albers,\n\n  // Cylindrical\n  'mercator': mercator,\n  'transverse-mercator': transverseMercator,\n  'equirectangular': equirectangular,\n  'natural-earth-1': naturalEarth1,\n\n  // Other\n  'equal-earth': equalEarth,\n}\n\n/**\n * Convenience function to register all D3 projections at once\n *\n * @example\n * ```typescript\n * import { registerProjections } from './standalone-projection-loader'\n * import { registerAllD3Projections } from './d3-projection-helpers'\n *\n * registerAllD3Projections(registerProjections)\n * ```\n *\n * @param registerFn - The registerProjections function from the loader\n */\nexport function registerAllD3Projections(\n  registerFn: (factories: Record<string, ProjectionFactory>) => void,\n): void {\n  registerFn(d3ProjectionFactories)\n}\n\n/**\n * Get list of available D3 projection IDs\n */\nexport function getAvailableD3Projections(): string[] {\n  return Object.keys(d3ProjectionFactories)\n}\n\n// Default export\nexport default {\n  d3ProjectionFactories,\n  registerAllD3Projections,\n  getAvailableD3Projections,\n\n  // Individual projections for tree-shaking\n  azimuthalEqualArea,\n  azimuthalEquidistant,\n  gnomonic,\n  orthographic,\n  stereographic,\n  conicConformal,\n  conicEqualArea,\n  conicEquidistant,\n  albers,\n  mercator,\n  transverseMercator,\n  equirectangular,\n  naturalEarth1,\n  equalEarth,\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,248 @@
+/**
+ * Standalone Composite Projection Loader (Zero Dependencies)
+ *
+ * A pure JavaScript/TypeScript module that consumes exported composite projection
+ * configurations and creates D3-compatible projections using a plugin architecture.
+ *
+ * This package has ZERO dependencies. Users must register projection factories
+ * before loading configurations.
+ *
+ * @example
+ * ```typescript
+ * // Register projections first
+ * import * as d3 from 'd3-geo'
+ * import { registerProjection, loadCompositeProjection } from './standalone-projection-loader'
+ *
+ * registerProjection('mercator', () => d3.geoMercator())
+ * registerProjection('albers', () => d3.geoAlbers())
+ *
+ * // Then load your configuration
+ * const projection = loadCompositeProjection(config, { width: 800, height: 600 })
+ * ```
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generic projection-like interface that matches D3 projections
+ * without requiring d3-geo as a dependency
+ *
+ * Note: D3 projections use getter/setter pattern where calling without
+ * arguments returns the current value, and with arguments sets and returns this.
+ */
+interface ProjectionLike {
+    (coordinates: [number, number]): [number, number] | null;
+    center?: {
+        (): [number, number];
+        (center: [number, number]): ProjectionLike;
+    };
+    rotate?: {
+        (): [number, number, number];
+        (angles: [number, number, number]): ProjectionLike;
+    };
+    parallels?: {
+        (): [number, number];
+        (parallels: [number, number]): ProjectionLike;
+    };
+    scale?: {
+        (): number;
+        (scale: number): ProjectionLike;
+    };
+    translate?: {
+        (): [number, number];
+        (translate: [number, number]): ProjectionLike;
+    };
+    clipExtent?: {
+        (): [[number, number], [number, number]] | null;
+        (extent: [[number, number], [number, number]] | null): ProjectionLike;
+    };
+    stream?: (stream: StreamLike) => StreamLike;
+    precision?: {
+        (): number;
+        (precision: number): ProjectionLike;
+    };
+    fitExtent?: (extent: [[number, number], [number, number]], object: any) => ProjectionLike;
+    fitSize?: (size: [number, number], object: any) => ProjectionLike;
+    fitWidth?: (width: number, object: any) => ProjectionLike;
+    fitHeight?: (height: number, object: any) => ProjectionLike;
+}
+/**
+ * Stream protocol interface for D3 geographic transforms
+ */
+interface StreamLike {
+    point: (x: number, y: number) => void;
+    lineStart: () => void;
+    lineEnd: () => void;
+    polygonStart: () => void;
+    polygonEnd: () => void;
+    sphere?: () => void;
+}
+/**
+ * Factory function that creates a projection instance
+ */
+type ProjectionFactory = () => ProjectionLike;
+/**
+ * Exported configuration format (subset needed for loading)
+ */
+interface ExportedConfig {
+    version: string;
+    metadata: {
+        atlasId: string;
+        atlasName: string;
+    };
+    pattern: string;
+    referenceScale: number;
+    territories: Territory[];
+}
+interface Territory {
+    code: string;
+    name: string;
+    role: string;
+    projectionId: string;
+    projectionFamily: string;
+    parameters: ProjectionParameters;
+    layout: Layout;
+    bounds: [[number, number], [number, number]];
+}
+interface ProjectionParameters {
+    center?: [number, number];
+    rotate?: [number, number, number];
+    scale: number;
+    baseScale: number;
+    scaleMultiplier: number;
+    parallels?: [number, number];
+}
+interface Layout {
+    translateOffset: [number, number];
+    clipExtent: [[number, number], [number, number]] | null;
+}
+/**
+ * Options for creating the composite projection
+ */
+interface LoaderOptions {
+    /** Canvas width in pixels */
+    width: number;
+    /** Canvas height in pixels */
+    height: number;
+    /** Whether to apply clipping to territories (default: true) */
+    enableClipping?: boolean;
+    /** Debug mode - logs territory selection (default: false) */
+    debug?: boolean;
+}
+/**
+ * Register a projection factory with a given ID
+ *
+ * @example
+ * ```typescript
+ * import * as d3 from 'd3-geo'
+ * import { registerProjection } from '@atlas-composer/projection-loader'
+ *
+ * registerProjection('mercator', () => d3.geoMercator())
+ * registerProjection('albers', () => d3.geoAlbers())
+ * ```
+ *
+ * @param id - Projection identifier (e.g., 'mercator', 'albers')
+ * @param factory - Function that creates a new projection instance
+ */
+declare function registerProjection(id: string, factory: ProjectionFactory): void;
+/**
+ * Register multiple projections at once
+ *
+ * @example
+ * ```typescript
+ * import * as d3 from 'd3-geo'
+ * import { registerProjections } from '@atlas-composer/projection-loader'
+ *
+ * registerProjections({
+ *   'mercator': () => d3.geoMercator(),
+ *   'albers': () => d3.geoAlbers(),
+ *   'conic-equal-area': () => d3.geoConicEqualArea()
+ * })
+ * ```
+ *
+ * @param factories - Object mapping projection IDs to factory functions
+ */
+declare function registerProjections(factories: Record<string, ProjectionFactory>): void;
+/**
+ * Unregister a projection
+ *
+ * @param id - Projection identifier to remove
+ * @returns True if the projection was removed, false if it wasn't registered
+ */
+declare function unregisterProjection(id: string): boolean;
+/**
+ * Clear all registered projections
+ */
+declare function clearProjections(): void;
+/**
+ * Get list of currently registered projection IDs
+ *
+ * @returns Array of registered projection identifiers
+ */
+declare function getRegisteredProjections(): string[];
+/**
+ * Check if a projection is registered
+ *
+ * @param id - Projection identifier to check
+ * @returns True if the projection is registered
+ */
+declare function isProjectionRegistered(id: string): boolean;
+/**
+ * Create a D3-compatible projection from an exported composite projection configuration
+ *
+ * @example
+ * ```typescript
+ * import * as d3 from 'd3-geo'
+ * import { registerProjection, loadCompositeProjection } from '@atlas-composer/projection-loader'
+ *
+ * // Register projections first
+ * registerProjection('mercator', () => d3.geoMercator())
+ * registerProjection('albers', () => d3.geoAlbers())
+ *
+ * // Load configuration
+ * const config = JSON.parse(jsonString)
+ *
+ * // Create projection
+ * const projection = loadCompositeProjection(config, {
+ *   width: 800,
+ *   height: 600
+ * })
+ *
+ * // Use with D3
+ * const path = d3.geoPath(projection)
+ * svg.selectAll('path')
+ *   .data(countries.features)
+ *   .join('path')
+ *   .attr('d', path)
+ * ```
+ *
+ * @param config - Exported composite projection configuration
+ * @param options - Canvas dimensions and options
+ * @returns D3-compatible projection that routes geometry to appropriate sub-projections
+ */
+declare function loadCompositeProjection(config: ExportedConfig, options: LoaderOptions): ProjectionLike;
+/**
+ * Validate an exported configuration
+ *
+ * @param config - Configuration to validate
+ * @returns True if valid, throws error otherwise
+ */
+declare function validateConfig(config: any): config is ExportedConfig;
+/**
+ * Load composite projection from JSON string
+ *
+ * @example
+ * ```typescript
+ * import * as d3 from 'd3-geo'
+ * import { registerProjection, loadFromJSON } from '@atlas-composer/projection-loader'
+ *
+ * // Register projections first
+ * registerProjection('mercator', () => d3.geoMercator())
+ *
+ * // Load from JSON
+ * const jsonString = fs.readFileSync('france-composite.json', 'utf-8')
+ * const projection = loadFromJSON(jsonString, { width: 800, height: 600 })
+ * ```
+ */
+declare function loadFromJSON(jsonString: string, options: LoaderOptions): ProjectionLike;
+
+export { type ExportedConfig, type Layout, type LoaderOptions, type ProjectionFactory, type ProjectionLike, type ProjectionParameters, type StreamLike, type Territory, clearProjections, getRegisteredProjections, isProjectionRegistered, loadCompositeProjection, loadFromJSON, registerProjection, registerProjections, unregisterProjection, validateConfig };

package/dist/index.js

@@ -0,0 +1,239 @@
+// src/standalone-projection-loader.ts
+var projectionRegistry = /* @__PURE__ */ new Map();
+function registerProjection(id, factory) {
+  projectionRegistry.set(id, factory);
+}
+function registerProjections(factories) {
+  for (const [id, factory] of Object.entries(factories)) {
+    registerProjection(id, factory);
+  }
+}
+function unregisterProjection(id) {
+  return projectionRegistry.delete(id);
+}
+function clearProjections() {
+  projectionRegistry.clear();
+}
+function getRegisteredProjections() {
+  return Array.from(projectionRegistry.keys());
+}
+function isProjectionRegistered(id) {
+  return projectionRegistry.has(id);
+}
+function createProjectionWrapper(project) {
+  let _scale = 150;
+  let _translate = [480, 250];
+  const projection = function(coordinates) {
+    const point = project(coordinates[0] * Math.PI / 180, coordinates[1] * Math.PI / 180);
+    if (!point)
+      return null;
+    return [point[0] * _scale + _translate[0], point[1] * _scale + _translate[1]];
+  };
+  projection.scale = ((s) => {
+    if (arguments.length === 0)
+      return _scale;
+    _scale = s;
+    return projection;
+  });
+  projection.translate = ((t) => {
+    if (arguments.length === 0)
+      return _translate;
+    _translate = t;
+    return projection;
+  });
+  return projection;
+}
+function loadCompositeProjection(config, options) {
+  const { width, height, debug = false } = options;
+  if (config.version !== "1.0") {
+    throw new Error(`Unsupported configuration version: ${config.version}`);
+  }
+  if (!config.territories || config.territories.length === 0) {
+    throw new Error("Configuration must contain at least one territory");
+  }
+  const subProjections = config.territories.map((territory) => {
+    const proj = createSubProjection(territory, width, height);
+    return {
+      territory,
+      projection: proj,
+      bounds: territory.bounds
+    };
+  });
+  if (debug) {
+    console.log("[CompositeProjection] Created sub-projections:", {
+      territories: config.territories.map((t) => ({ code: t.code, name: t.name })),
+      count: subProjections.length
+    });
+  }
+  const compositeProjection = createProjectionWrapper((lambda, phi) => {
+    const lon = lambda * 180 / Math.PI;
+    const lat = phi * 180 / Math.PI;
+    let selectedProj = null;
+    for (const { projection, bounds } of subProjections) {
+      if (lon >= bounds[0][0] && lon <= bounds[1][0] && lat >= bounds[0][1] && lat <= bounds[1][1]) {
+        selectedProj = projection;
+        break;
+      }
+    }
+    if (!selectedProj && subProjections[0]) {
+      selectedProj = subProjections[0].projection;
+    }
+    return selectedProj([lambda, phi]);
+  });
+  compositeProjection.stream = function(stream) {
+    let activeStream = null;
+    let bufferedPoints = [];
+    let activeTerritoryCode = "";
+    return {
+      point(lon, lat) {
+        bufferedPoints.push([lon, lat]);
+        if (activeStream) {
+          const lonDeg = lon * 180 / Math.PI;
+          const latDeg = lat * 180 / Math.PI;
+          if (debug) {
+            console.log(`[Stream] Point: [${lonDeg.toFixed(2)}, ${latDeg.toFixed(2)}] \u2192 ${activeTerritoryCode}`);
+          }
+          activeStream.point(lon, lat);
+        }
+      },
+      lineStart() {
+        if (bufferedPoints.length > 0 && bufferedPoints[0]) {
+          const [lon, lat] = bufferedPoints[0];
+          const lonDeg = lon * 180 / Math.PI;
+          const latDeg = lat * 180 / Math.PI;
+          for (const { territory, projection, bounds } of subProjections) {
+            if (lonDeg >= bounds[0][0] && lonDeg <= bounds[1][0] && latDeg >= bounds[0][1] && latDeg <= bounds[1][1]) {
+              if (projection.stream) {
+                activeStream = projection.stream(stream);
+                activeTerritoryCode = territory.code;
+              }
+              if (debug) {
+                console.log(`[Stream] Line started in territory: ${territory.code}`);
+              }
+              break;
+            }
+          }
+          if (!activeStream && subProjections[0]) {
+            const firstProj = subProjections[0].projection;
+            if (firstProj.stream) {
+              activeStream = firstProj.stream(stream);
+              activeTerritoryCode = subProjections[0].territory.code;
+            }
+            if (debug) {
+              console.log(`[Stream] Line started (fallback): ${activeTerritoryCode}`);
+            }
+          }
+        }
+        if (activeStream) {
+          activeStream.lineStart();
+          for (const [lon, lat] of bufferedPoints) {
+            activeStream.point(lon, lat);
+          }
+        }
+        bufferedPoints = [];
+      },
+      lineEnd() {
+        if (activeStream) {
+          activeStream.lineEnd();
+        }
+      },
+      polygonStart() {
+        bufferedPoints = [];
+        activeStream = null;
+      },
+      polygonEnd() {
+        if (activeStream) {
+          activeStream.polygonEnd();
+        }
+        activeStream = null;
+      },
+      sphere() {
+        if (debug) {
+          console.warn("[Stream] sphere() called - not supported in composite projections");
+        }
+      }
+    };
+  };
+  if (compositeProjection.scale) {
+    compositeProjection.scale(1);
+  }
+  if (compositeProjection.translate) {
+    compositeProjection.translate([width / 2, height / 2]);
+  }
+  return compositeProjection;
+}
+function createSubProjection(territory, width, height) {
+  const { projectionId, parameters, layout } = territory;
+  const factory = projectionRegistry.get(projectionId);
+  if (!factory) {
+    const registered = getRegisteredProjections();
+    const availableList = registered.length > 0 ? registered.join(", ") : "none";
+    throw new Error(
+      `Projection "${projectionId}" is not registered. Available projections: ${availableList}. Use registerProjection('${projectionId}', factory) to register it.`
+    );
+  }
+  const projection = factory();
+  if (parameters.center && projection.center) {
+    projection.center(parameters.center);
+  }
+  if (parameters.rotate && projection.rotate) {
+    projection.rotate(parameters.rotate);
+  }
+  if (parameters.parallels && projection.parallels) {
+    projection.parallels(parameters.parallels);
+  }
+  if (projection.scale) {
+    projection.scale(parameters.scale);
+  }
+  if (projection.translate) {
+    const [offsetX, offsetY] = layout.translateOffset;
+    projection.translate([
+      width / 2 + offsetX,
+      height / 2 + offsetY
+    ]);
+  }
+  if (layout.clipExtent && projection.clipExtent) {
+    projection.clipExtent(layout.clipExtent);
+  }
+  return projection;
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Configuration must be an object");
+  }
+  if (!config.version) {
+    throw new Error("Configuration must have a version field");
+  }
+  if (!config.metadata || !config.metadata.atlasId) {
+    throw new Error("Configuration must have metadata with atlasId");
+  }
+  if (!config.territories || !Array.isArray(config.territories)) {
+    throw new Error("Configuration must have territories array");
+  }
+  if (config.territories.length === 0) {
+    throw new Error("Configuration must have at least one territory");
+  }
+  for (const territory of config.territories) {
+    if (!territory.code || !territory.projectionId) {
+      throw new Error(`Territory missing required fields: ${JSON.stringify(territory)}`);
+    }
+    if (!territory.parameters || !territory.bounds) {
+      throw new Error(`Territory ${territory.code} missing parameters or bounds`);
+    }
+  }
+  return true;
+}
+function loadFromJSON(jsonString, options) {
+  let config;
+  try {
+    config = JSON.parse(jsonString);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  validateConfig(config);
+  return loadCompositeProjection(config, options);
+}
+
+export { clearProjections, getRegisteredProjections, isProjectionRegistered, loadCompositeProjection, loadFromJSON, registerProjection, registerProjections, unregisterProjection, validateConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standalone-projection-loader.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Standalone Composite Projection Loader (Zero Dependencies)\n *\n * A pure JavaScript/TypeScript module that consumes exported composite projection\n * configurations and creates D3-compatible projections using a plugin architecture.\n *\n * This package has ZERO dependencies. Users must register projection factories\n * before loading configurations.\n *\n * @example\n * ```typescript\n * // Register projections first\n * import * as d3 from 'd3-geo'\n * import { registerProjection, loadCompositeProjection } from './standalone-projection-loader'\n *\n * registerProjection('mercator', () => d3.geoMercator())\n * registerProjection('albers', () => d3.geoAlbers())\n *\n * // Then load your configuration\n * const projection = loadCompositeProjection(config, { width: 800, height: 600 })\n * ```\n *\n * @packageDocumentation\n */\n\n/**\n * Generic projection-like interface that matches D3 projections\n * without requiring d3-geo as a dependency\n *\n * Note: D3 projections use getter/setter pattern where calling without\n * arguments returns the current value, and with arguments sets and returns this.\n */\nexport interface ProjectionLike {\n  (coordinates: [number, number]): [number, number] | null\n  center?: {\n    (): [number, number]\n    (center: [number, number]): ProjectionLike\n  }\n  rotate?: {\n    (): [number, number, number]\n    (angles: [number, number, number]): ProjectionLike\n  }\n  parallels?: {\n    (): [number, number]\n    (parallels: [number, number]): ProjectionLike\n  }\n  scale?: {\n    (): number\n    (scale: number): ProjectionLike\n  }\n  translate?: {\n    (): [number, number]\n    (translate: [number, number]): ProjectionLike\n  }\n  clipExtent?: {\n    (): [[number, number], [number, number]] | null\n    (extent: [[number, number], [number, number]] | null): ProjectionLike\n  }\n  stream?: (stream: StreamLike) => StreamLike\n  precision?: {\n    (): number\n    (precision: number): ProjectionLike\n  }\n  fitExtent?: (extent: [[number, number], [number, number]], object: any) => ProjectionLike\n  fitSize?: (size: [number, number], object: any) => ProjectionLike\n  fitWidth?: (width: number, object: any) => ProjectionLike\n  fitHeight?: (height: number, object: any) => ProjectionLike\n}\n\n/**\n * Stream protocol interface for D3 geographic transforms\n */\nexport interface StreamLike {\n  point: (x: number, y: number) => void\n  lineStart: () => void\n  lineEnd: () => void\n  polygonStart: () => void\n  polygonEnd: () => void\n  sphere?: () => void\n}\n\n/**\n * Factory function that creates a projection instance\n */\nexport type ProjectionFactory = () => ProjectionLike\n\n/**\n * Exported configuration format (subset needed for loading)\n */\nexport interface ExportedConfig {\n  version: string\n  metadata: {\n    atlasId: string\n    atlasName: string\n  }\n  pattern: string\n  referenceScale: number\n  territories: Territory[]\n}\n\nexport interface Territory {\n  code: string\n  name: string\n  role: string\n  projectionId: string\n  projectionFamily: string\n  parameters: ProjectionParameters\n  layout: Layout\n  bounds: [[number, number], [number, number]]\n}\n\nexport interface ProjectionParameters {\n  center?: [number, number]\n  rotate?: [number, number, number]\n  scale: number\n  baseScale: number\n  scaleMultiplier: number\n  parallels?: [number, number]\n}\n\nexport interface Layout {\n  translateOffset: [number, number]\n  clipExtent: [[number, number], [number, number]] | null\n}\n\n/**\n * Options for creating the composite projection\n */\nexport interface LoaderOptions {\n  /** Canvas width in pixels */\n  width: number\n  /** Canvas height in pixels */\n  height: number\n  /** Whether to apply clipping to territories (default: true) */\n  enableClipping?: boolean\n  /** Debug mode - logs territory selection (default: false) */\n  debug?: boolean\n}\n\n/**\n * Runtime registry for projection factories\n * Users must register projections before loading configurations\n */\nconst projectionRegistry = new Map<string, ProjectionFactory>()\n\n/**\n * Register a projection factory with a given ID\n *\n * @example\n * ```typescript\n * import * as d3 from 'd3-geo'\n * import { registerProjection } from '@atlas-composer/projection-loader'\n *\n * registerProjection('mercator', () => d3.geoMercator())\n * registerProjection('albers', () => d3.geoAlbers())\n * ```\n *\n * @param id - Projection identifier (e.g., 'mercator', 'albers')\n * @param factory - Function that creates a new projection instance\n */\nexport function registerProjection(id: string, factory: ProjectionFactory): void {\n  projectionRegistry.set(id, factory)\n}\n\n/**\n * Register multiple projections at once\n *\n * @example\n * ```typescript\n * import * as d3 from 'd3-geo'\n * import { registerProjections } from '@atlas-composer/projection-loader'\n *\n * registerProjections({\n *   'mercator': () => d3.geoMercator(),\n *   'albers': () => d3.geoAlbers(),\n *   'conic-equal-area': () => d3.geoConicEqualArea()\n * })\n * ```\n *\n * @param factories - Object mapping projection IDs to factory functions\n */\nexport function registerProjections(factories: Record<string, ProjectionFactory>): void {\n  for (const [id, factory] of Object.entries(factories)) {\n    registerProjection(id, factory)\n  }\n}\n\n/**\n * Unregister a projection\n *\n * @param id - Projection identifier to remove\n * @returns True if the projection was removed, false if it wasn't registered\n */\nexport function unregisterProjection(id: string): boolean {\n  return projectionRegistry.delete(id)\n}\n\n/**\n * Clear all registered projections\n */\nexport function clearProjections(): void {\n  projectionRegistry.clear()\n}\n\n/**\n * Get list of currently registered projection IDs\n *\n * @returns Array of registered projection identifiers\n */\nexport function getRegisteredProjections(): string[] {\n  return Array.from(projectionRegistry.keys())\n}\n\n/**\n * Check if a projection is registered\n *\n * @param id - Projection identifier to check\n * @returns True if the projection is registered\n */\nexport function isProjectionRegistered(id: string): boolean {\n  return projectionRegistry.has(id)\n}\n\n/**\n * Create a minimal projection wrapper (similar to d3.geoProjection)\n * This allows us to avoid the d3-geo dependency\n */\nfunction createProjectionWrapper(\n  project: (lambda: number, phi: number) => [number, number] | null,\n): ProjectionLike {\n  let _scale = 150\n  let _translate: [number, number] = [480, 250]\n\n  const projection = function (coordinates: [number, number]): [number, number] | null {\n    const point = project(coordinates[0] * Math.PI / 180, coordinates[1] * Math.PI / 180)\n    if (!point)\n      return null\n    return [point[0] * _scale + _translate[0], point[1] * _scale + _translate[1]]\n  } as ProjectionLike\n\n  // D3-style getter/setter for scale\n  projection.scale = ((s?: number): any => {\n    if (arguments.length === 0)\n      return _scale\n    _scale = s!\n    return projection\n  }) as any\n\n  // D3-style getter/setter for translate\n  projection.translate = ((t?: [number, number]): any => {\n    if (arguments.length === 0)\n      return _translate\n    _translate = t!\n    return projection\n  }) as any\n\n  return projection\n}\n\n/**\n * Create a D3-compatible projection from an exported composite projection configuration\n *\n * @example\n * ```typescript\n * import * as d3 from 'd3-geo'\n * import { registerProjection, loadCompositeProjection } from '@atlas-composer/projection-loader'\n *\n * // Register projections first\n * registerProjection('mercator', () => d3.geoMercator())\n * registerProjection('albers', () => d3.geoAlbers())\n *\n * // Load configuration\n * const config = JSON.parse(jsonString)\n *\n * // Create projection\n * const projection = loadCompositeProjection(config, {\n *   width: 800,\n *   height: 600\n * })\n *\n * // Use with D3\n * const path = d3.geoPath(projection)\n * svg.selectAll('path')\n *   .data(countries.features)\n *   .join('path')\n *   .attr('d', path)\n * ```\n *\n * @param config - Exported composite projection configuration\n * @param options - Canvas dimensions and options\n * @returns D3-compatible projection that routes geometry to appropriate sub-projections\n */\nexport function loadCompositeProjection(\n  config: ExportedConfig,\n  options: LoaderOptions,\n): ProjectionLike {\n  const { width, height, debug = false } = options\n\n  // Validate configuration version\n  if (config.version !== '1.0') {\n    throw new Error(`Unsupported configuration version: ${config.version}`)\n  }\n\n  if (!config.territories || config.territories.length === 0) {\n    throw new Error('Configuration must contain at least one territory')\n  }\n\n  // Create sub-projections for each territory\n  const subProjections = config.territories.map((territory) => {\n    const proj = createSubProjection(territory, width, height)\n\n    return {\n      territory,\n      projection: proj,\n      bounds: territory.bounds,\n    }\n  })\n\n  if (debug) {\n    console.log('[CompositeProjection] Created sub-projections:', {\n      territories: config.territories.map(t => ({ code: t.code, name: t.name })),\n      count: subProjections.length,\n    })\n  }\n\n  // Create composite projection using custom stream multiplexing\n  const compositeProjection = createProjectionWrapper((lambda: number, phi: number) => {\n    // Convert radians to degrees for bounds checking\n    const lon = (lambda * 180) / Math.PI\n    const lat = (phi * 180) / Math.PI\n\n    // Find which territory this point belongs to\n    let selectedProj = null\n    for (const { projection, bounds } of subProjections) {\n      if (\n        lon >= bounds[0][0] && lon <= bounds[1][0]\n        && lat >= bounds[0][1] && lat <= bounds[1][1]\n      ) {\n        selectedProj = projection\n        break\n      }\n    }\n\n    // If no territory matched, use first projection (fallback)\n    if (!selectedProj && subProjections[0]) {\n      selectedProj = subProjections[0].projection\n    }\n\n    // Project the point (should always have a projection by this point)\n    return selectedProj!([lambda, phi])\n  })\n\n  // Implement stream multiplexing for proper geometry routing\n  compositeProjection.stream = function (stream: StreamLike): StreamLike {\n    let activeStream: StreamLike | null = null\n    let bufferedPoints: Array<[number, number]> = []\n    let activeTerritoryCode = ''\n\n    return {\n      point(lon: number, lat: number) {\n        // Buffer points until we can determine which territory they belong to\n        bufferedPoints.push([lon, lat])\n\n        // If we have an active stream, forward the point\n        if (activeStream) {\n          const lonDeg = (lon * 180) / Math.PI\n          const latDeg = (lat * 180) / Math.PI\n\n          if (debug) {\n            console.log(`[Stream] Point: [${lonDeg.toFixed(2)}, ${latDeg.toFixed(2)}] → ${activeTerritoryCode}`)\n          }\n\n          activeStream.point(lon, lat)\n        }\n      },\n\n      lineStart() {\n        // Determine which territory this line belongs to\n        if (bufferedPoints.length > 0 && bufferedPoints[0]) {\n          const [lon, lat] = bufferedPoints[0]\n          const lonDeg = (lon * 180) / Math.PI\n          const latDeg = (lat * 180) / Math.PI\n\n          // Find matching territory\n          for (const { territory, projection, bounds } of subProjections) {\n            if (\n              lonDeg >= bounds[0][0] && lonDeg <= bounds[1][0]\n              && latDeg >= bounds[0][1] && latDeg <= bounds[1][1]\n            ) {\n              // Use the projection's stream if available\n              if (projection.stream) {\n                activeStream = projection.stream(stream)\n                activeTerritoryCode = territory.code\n              }\n\n              if (debug) {\n                console.log(`[Stream] Line started in territory: ${territory.code}`)\n              }\n              break\n            }\n          }\n\n          // Fallback to first projection\n          if (!activeStream && subProjections[0]) {\n            const firstProj = subProjections[0].projection\n            if (firstProj.stream) {\n              activeStream = firstProj.stream(stream)\n              activeTerritoryCode = subProjections[0].territory.code\n            }\n\n            if (debug) {\n              console.log(`[Stream] Line started (fallback): ${activeTerritoryCode}`)\n            }\n          }\n        }\n\n        if (activeStream) {\n          activeStream.lineStart()\n\n          // Replay buffered points\n          for (const [lon, lat] of bufferedPoints) {\n            activeStream.point(lon, lat)\n          }\n        }\n\n        bufferedPoints = []\n      },\n\n      lineEnd() {\n        if (activeStream) {\n          activeStream.lineEnd()\n        }\n      },\n\n      polygonStart() {\n        bufferedPoints = []\n        activeStream = null\n      },\n\n      polygonEnd() {\n        if (activeStream) {\n          activeStream.polygonEnd()\n        }\n        activeStream = null\n      },\n\n      sphere() {\n        // Not supported in composite projections\n        if (debug) {\n          console.warn('[Stream] sphere() called - not supported in composite projections')\n        }\n      },\n    }\n  }\n\n  // Set reasonable defaults for the composite projection\n  // Note: Individual territories handle their own scale/translate\n  if (compositeProjection.scale) {\n    compositeProjection.scale(1)\n  }\n  if (compositeProjection.translate) {\n    compositeProjection.translate([width / 2, height / 2])\n  }\n\n  return compositeProjection\n}\n\n/**\n * Create a sub-projection for a single territory\n */\nfunction createSubProjection(\n  territory: Territory,\n  width: number,\n  height: number,\n): ProjectionLike {\n  const { projectionId, parameters, layout } = territory\n\n  // Get projection factory from registry\n  const factory = projectionRegistry.get(projectionId)\n  if (!factory) {\n    const registered = getRegisteredProjections()\n    const availableList = registered.length > 0 ? registered.join(', ') : 'none'\n    throw new Error(\n      `Projection \"${projectionId}\" is not registered. `\n      + `Available projections: ${availableList}. `\n      + `Use registerProjection('${projectionId}', factory) to register it.`,\n    )\n  }\n\n  // Create projection instance\n  const projection = factory()\n\n  // Apply parameters\n  if (parameters.center && projection.center) {\n    projection.center(parameters.center)\n  }\n\n  if (parameters.rotate && projection.rotate) {\n    projection.rotate(parameters.rotate)\n  }\n\n  if (parameters.parallels && projection.parallels) {\n    projection.parallels(parameters.parallels)\n  }\n\n  if (projection.scale) {\n    projection.scale(parameters.scale)\n  }\n\n  // Apply layout translate\n  if (projection.translate) {\n    const [offsetX, offsetY] = layout.translateOffset\n    projection.translate([\n      width / 2 + offsetX,\n      height / 2 + offsetY,\n    ])\n  }\n\n  // Apply clipping if specified\n  if (layout.clipExtent && projection.clipExtent) {\n    projection.clipExtent(layout.clipExtent)\n  }\n\n  return projection\n}\n\n/**\n * Validate an exported configuration\n *\n * @param config - Configuration to validate\n * @returns True if valid, throws error otherwise\n */\nexport function validateConfig(config: any): config is ExportedConfig {\n  if (!config || typeof config !== 'object') {\n    throw new Error('Configuration must be an object')\n  }\n\n  if (!config.version) {\n    throw new Error('Configuration must have a version field')\n  }\n\n  if (!config.metadata || !config.metadata.atlasId) {\n    throw new Error('Configuration must have metadata with atlasId')\n  }\n\n  if (!config.territories || !Array.isArray(config.territories)) {\n    throw new Error('Configuration must have territories array')\n  }\n\n  if (config.territories.length === 0) {\n    throw new Error('Configuration must have at least one territory')\n  }\n\n  // Validate each territory\n  for (const territory of config.territories) {\n    if (!territory.code || !territory.projectionId) {\n      throw new Error(`Territory missing required fields: ${JSON.stringify(territory)}`)\n    }\n\n    if (!territory.parameters || !territory.bounds) {\n      throw new Error(`Territory ${territory.code} missing parameters or bounds`)\n    }\n  }\n\n  return true\n}\n\n/**\n * Load composite projection from JSON string\n *\n * @example\n * ```typescript\n * import * as d3 from 'd3-geo'\n * import { registerProjection, loadFromJSON } from '@atlas-composer/projection-loader'\n *\n * // Register projections first\n * registerProjection('mercator', () => d3.geoMercator())\n *\n * // Load from JSON\n * const jsonString = fs.readFileSync('france-composite.json', 'utf-8')\n * const projection = loadFromJSON(jsonString, { width: 800, height: 600 })\n * ```\n */\nexport function loadFromJSON(\n  jsonString: string,\n  options: LoaderOptions,\n): ProjectionLike {\n  let config: any\n\n  try {\n    config = JSON.parse(jsonString)\n  }\n  catch (error) {\n    throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`)\n  }\n\n  validateConfig(config)\n  return loadCompositeProjection(config, options)\n}\n\n// Default export\nexport default {\n  // Core loading functions\n  loadCompositeProjection,\n  loadFromJSON,\n  validateConfig,\n\n  // Registry management\n  registerProjection,\n  registerProjections,\n  unregisterProjection,\n  clearProjections,\n  getRegisteredProjections,\n  isProjectionRegistered,\n}\n"]}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@atlas-composer/projection-loader",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "Zero-dependency standalone loader for composite map projections with plugin architecture",
+  "author": "Lucas Poulain (ShallowRed)",
+  "license": "MIT",
+  "homepage": "https://github.com/ShallowRed/atlas-composer/tree/main/packages/projection-loader#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShallowRed/atlas-composer.git",
+    "directory": "packages/projection-loader"
+  },
+  "bugs": {
+    "url": "https://github.com/ShallowRed/atlas-composer/issues"
+  },
+  "keywords": [
+    "cartography",
+    "composite",
+    "d3",
+    "d3-geo",
+    "geography",
+    "gis",
+    "map",
+    "observable-plot",
+    "projection",
+    "tree-shakeable",
+    "zero-dependencies"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./helpers": {
+      "types": "./dist/d3-projection-helpers.d.ts",
+      "import": "./dist/d3-projection-helpers.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "size": "size-limit",
+    "size:why": "size-limit --why"
+  },
+  "size-limit": [
+    {
+      "name": "Main bundle (ESM)",
+      "path": "dist/index.js",
+      "limit": "10 KB",
+      "gzip": true
+    },
+    {
+      "name": "D3 helpers (optional)",
+      "path": "dist/d3-projection-helpers.js",
+      "limit": "3 KB",
+      "gzip": true
+    }
+  ],
+  "peerDependencies": {
+    "d3-geo": ">=3.0.0",
+    "d3-geo-projection": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "d3-geo": {
+      "optional": false
+    },
+    "d3-geo-projection": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^11.2.0",
+    "@types/d3-geo": "^3.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "~5.9.3"
+  }
+}