@flightloop/sdk-frontend 0.0.0-stage → 1.0.0-qa.0

package/README.md

@@ -1,3 +1,146 @@
-# Temporary Holding Version
+# @flyzone/sdk-frontend
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Frontend SDK for LAANC authorization - provides UI components and business logic for drone flight authorization.
+
+## Overview
+
+This SDK provides framework-agnostic core functionality for processing LAANC (Low Altitude Authorization and Notification Capability) authorizations in frontend applications. It includes optional React hooks for easier integration with React applications.
+
+## Features
+
+- **Framework-Agnostic Core**: Pure TypeScript business logic that works with any frontend framework
+- **Geometry Management**: Create and validate circles and polygons for operation areas
+- **Authorization Processing**: Process airspace features and determine authorization requirements
+- **Validation Utilities**: Comprehensive validation for altitude, date/time, geometry, and operator data
+- **React Hooks** (Optional): Pre-built hooks for React applications
+- **TypeScript Support**: Full TypeScript definitions included
+- **Tree-Shakeable**: ESM and CJS builds with proper tree-shaking support
+
+## Installation
+
+```bash
+npm install @flyzone/sdk-frontend @flyzone/sdk-core
+```
+
+### Peer Dependencies
+
+```bash
+# Required
+npm install @flyzone/sdk-core
+
+# Optional (only if using React hooks)
+npm install react@^18.0.0
+```
+
+## Usage
+
+### Core SDK (Framework-Agnostic)
+
+```typescript
+import { createCircle, validateAltitude, detectTimezone } from '@flyzone/sdk-frontend';
+
+// Create a circular operation area
+const operationArea = createCircle(
+  { lat: 37.7749, lng: -122.4194 },
+  1000 // radius in feet
+);
+
+// Validate altitude
+const altitudeValidation = validateAltitude(200, 'Part 107');
+
+// Auto-detect timezone
+const timezone = detectTimezone(37.7749, -122.4194);
+```
+
+### React Hooks (Coming Soon)
+
+```typescript
+import { useGeometry, useAuthorization } from '@flyzone/sdk-frontend/react';
+
+function MyComponent() {
+  const geometry = useGeometry('circle');
+  const { processAuthorization } = useAuthorization();
+
+  // Use the hooks...
+}
+```
+
+## Architecture
+
+```
+@flyzone/sdk-frontend/
+├── core/                    # Framework-agnostic core logic
+│   ├── geometry/           # Geometry creation & validation
+│   ├── airspace/           # Airspace processing (coming soon)
+│   ├── validation/         # Input validation & business rules
+│   ├── formatters/         # Data transformation (coming soon)
+│   ├── transformers/       # Map provider adapters (coming soon)
+│   └── utils/              # Shared utilities
+├── react/                  # React-specific hooks (coming soon)
+└── types/                  # TypeScript definitions
+```
+
+## Development Status
+
+**Current Version:** 1.0.0 - **Phase 1 Complete**
+
+### ✅ Phase 1: Automatic Authorization (COMPLETED)
+- ✅ Project structure and TypeScript configuration
+- ✅ Geometry module (circle, polygon, operations)
+- ✅ Validation module (altitude, date/time, operator)
+- ✅ Type definitions for all modules
+- ✅ Utility functions and constants
+- ✅ **Feature categorization** - Organize airspace features by type
+- ✅ **UASFM processing** - Extract ceiling data for auto-approval
+- ✅ **Restriction detection** - TFR, Class B/C/D/E, DC FRZ, NSUFR, Special Use
+- ✅ **Advisory generation** - Create, deduplicate, prioritize advisories
+- ✅ **Summary determination** - Generate authorization summary (OK/ALERT/CAUTION/DNF/NOK)
+- ✅ **Main processor** - `processAuthorization()` function complete
+- ✅ Usage examples and documentation
+
+### 📋 Phase 2: Further Coordination (PLANNED)
+- 📋 FC overlay generation for altitudes exceeding ceiling
+- 📋 FC lead time validation (72 hours to 90 days)
+- 📋 Scheduled airspace temporal validation
+- 📋 FC-specific advisory generation
+- 📋 Authorization requirement tracking
+
+### 📋 Future Enhancements
+- 📋 Feature transformers for different map providers
+- 📋 React hooks (useGeometry, useAuthorization, etc.)
+- 📋 Complete test coverage (Jest ESM config for @turf)
+- 📋 UI component library (optional)
+
+## Building
+
+```bash
+# Install dependencies
+npm install
+
+# Build all formats (CJS, ESM, types)
+npm run build
+
+# Run tests
+npm test
+
+# Run linting
+npm run lint
+```
+
+## User Responsibilities
+
+When using this SDK, users are responsible for:
+
+1. **Map rendering and interaction** - The SDK does not render maps
+2. **Querying airspace layers** - Users query their map and pass features to the SDK
+3. **Fetching external data** - TFRs, SEAMS, etc. must be fetched by the user
+4. **UI components** - The SDK provides logic; users build or use their own UI
+5. **Backend API calls** - Use `@flyzone/sdk-backend` for API integration
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit the [GitHub repository](https://github.com/flyzone/sdk-frontend).

package/dist/cjs/core/airspace/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Airspace validation client
+ *
+ * This module provides an HTTP client for validating flight operations
+ * against LAANC airspace restrictions by calling your backend service.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationClient = exports.ValidationClient = void 0;
+// ─── Validation Client (HTTP client for your backend) ───────────────────────
+var validation_client_1 = require("./validation-client");
+Object.defineProperty(exports, "ValidationClient", { enumerable: true, get: function () { return validation_client_1.ValidationClient; } });
+Object.defineProperty(exports, "createValidationClient", { enumerable: true, get: function () { return validation_client_1.createValidationClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/core/airspace/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/airspace/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,+EAA+E;AAC/E,yDAI6B;AAH3B,qHAAA,gBAAgB,OAAA;AAChB,2HAAA,sBAAsB,OAAA"}

package/dist/cjs/core/airspace/validation-client.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Validation Client - HTTP client for calling your backend validation service
+ *
+ * This module provides an HTTP client for validating flight operations against
+ * LAANC airspace restrictions by calling your backend service, which in turn
+ * uses the flyzone-backend SDK to call the Flyzone API.
+ *
+ * Flow: Frontend App → Your Backend Service → Flyzone API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationClient = void 0;
+exports.createValidationClient = createValidationClient;
+/**
+ * HTTP client for airspace validation
+ *
+ * This client calls YOUR backend service, which should use the flyzone-backend
+ * SDK to communicate with the Flyzone API.
+ *
+ * @example
+ * ```typescript
+ * import { createValidationClient } from '@flyzone/sdk-frontend';
+ *
+ * const validationClient = createValidationClient({
+ *   backendBaseURL: 'https://your-backend.com',
+ *   headers: {
+ *     'Authorization': 'Bearer your-user-token'
+ *   }
+ * });
+ *
+ * const result = await validationClient.validate({
+ *   geometry: {
+ *     type: 'Polygon',
+ *     coordinates: [[[lon, lat], ...]]
+ *   },
+ *   startTime: '2024-03-15T14:00:00Z',
+ *   endTime: '2024-03-15T16:00:00Z',
+ *   timezone: 'America/Los_Angeles',
+ *   maxAltitude: 100,
+ * });
+ * ```
+ */
+class ValidationClient {
+    constructor(config) {
+        this.config = {
+            backendBaseURL: config.backendBaseURL.replace(/\/$/, ''), // Remove trailing slash
+            validationPath: config.validationPath ?? '/api/airspace/validate',
+            headers: config.headers ?? {},
+            timeout: config.timeout ?? 30000,
+        };
+    }
+    /**
+     * Validates a flight operation against LAANC airspace restrictions
+     *
+     * @param params - Validation request parameters
+     * @returns Promise resolving to validation response
+     * @throws Error if the request fails or times out
+     */
+    async validate(params) {
+        const url = `${this.config.backendBaseURL}${this.config.validationPath}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.config.headers,
+                },
+                body: JSON.stringify(params),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`Validation request failed: ${response.status} ${response.statusText}. ${errorData.message || ''}`);
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`Validation request timed out after ${this.config.timeout}ms`);
+                }
+                throw error;
+            }
+            throw new Error('Unknown error during validation request');
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Updates the authentication token or other headers
+     *
+     * @param headers - New headers to merge with existing headers
+     */
+    updateHeaders(headers) {
+        Object.assign(this.config.headers, headers);
+    }
+}
+exports.ValidationClient = ValidationClient;
+/**
+ * Factory function to create a validation client
+ *
+ * @param config - Client configuration
+ * @returns ValidationClient instance
+ */
+function createValidationClient(config) {
+    return new ValidationClient(config);
+}
+//# sourceMappingURL=validation-client.js.map

package/dist/cjs/core/airspace/validation-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-client.js","sourceRoot":"","sources":["../../../../src/core/airspace/validation-client.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA6IH,wDAIC;AAjHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,gBAAgB;IAG3B,YAAY,MAA8B;QACxC,IAAI,CAAC,MAAM,GAAG;YACZ,cAAc,EAAE,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,wBAAwB;YAClF,cAAc,EAAE,MAAM,CAAC,cAAc,IAAI,wBAAwB;YACjE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE;YAC7B,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK;SACjC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,CACZ,MAAiC;QAEjC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QAEzE,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE5E,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;gBAChC,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;oBAClC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO;iBACvB;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBAC5B,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC1D,MAAM,IAAI,KAAK,CACb,8BAA8B,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,KAClE,SAAS,CAAC,OAAO,IAAI,EACvB,EAAE,CACH,CAAC;YACJ,CAAC;YAED,MAAM,IAAI,GAA+B,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC/D,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;gBAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;oBAChC,MAAM,IAAI,KAAK,CACb,sCAAsC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAC9D,CAAC;gBACJ,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,SAAS,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,OAA+B;QAC3C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;CACF;AAxED,4CAwEC;AAED;;;;;GAKG;AACH,SAAgB,sBAAsB,CACpC,MAA8B;IAE9B,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACtC,CAAC"}

package/dist/cjs/core/formatters/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Data formatting utilities
+ *
+ * This module provides utilities to format data for API submission
+ * and UI display.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOperationPayload = formatOperationPayload;
+exports.formatDateTime = formatDateTime;
+exports.formatAdvisories = formatAdvisories;
+exports.formatAirspaceClass = formatAirspaceClass;
+/**
+ * Format operation data for backend API submission
+ * TODO: Implement operation payload formatting
+ */
+function formatOperationPayload(_operationData) {
+    throw new Error('Not implemented yet');
+}
+/**
+ * Format date/time with timezone to ISO string
+ * TODO: Implement datetime formatting
+ */
+function formatDateTime(_date, _timezone) {
+    throw new Error('Not implemented yet');
+}
+/**
+ * Format advisories for UI display
+ * TODO: Implement advisory formatting
+ */
+function formatAdvisories(_advisories) {
+    throw new Error('Not implemented yet');
+}
+/**
+ * Format airspace class name
+ * TODO: Implement class name formatting
+ */
+function formatAirspaceClass(_classCode) {
+    throw new Error('Not implemented yet');
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/core/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/formatters/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAQH,wDAEC;AAMD,wCAEC;AAMD,4CAEC;AAMD,kDAEC;AA9BD;;;GAGG;AACH,SAAgB,sBAAsB,CAAC,cAAmB;IACxD,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,KAAW,EAAE,SAAiB;IAC3D,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,WAAkB;IACjD,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,UAAkB;IACpD,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;AACzC,CAAC"}

package/dist/cjs/core/geometry/circle.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCircle = createCircle;
+exports.validateCircle = validateCircle;
+exports.getCircleCenter = getCircleCenter;
+exports.getCircleRadius = getCircleRadius;
+const turf = __importStar(require("@turf/turf"));
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+/**
+ * Create a circular polygon from a center point and radius
+ *
+ * @param center - Center point of the circle
+ * @param radiusFeet - Radius in feet
+ * @param options - Circle creation options
+ * @returns GeoJSON Feature with Polygon geometry
+ */
+function createCircle(center, radiusFeet, options = {}) {
+    const { steps = constants_1.CIRCLE_CONSTRAINTS.DEFAULT_STEPS } = options;
+    // Validate inputs
+    const validation = validateCircle(radiusFeet);
+    if (!validation.valid) {
+        throw new Error(`Invalid circle parameters: ${validation.errors.map(e => e.message).join(', ')}`);
+    }
+    // Convert radius to kilometers for Turf.js
+    const radiusMeters = (0, helpers_1.feetToMeters)(radiusFeet);
+    const radiusKm = radiusMeters / 1000;
+    // Create circle using Turf.js
+    const point = turf.point([center.lng, center.lat]);
+    const circle = turf.circle(point, radiusKm, { steps, units: 'kilometers' });
+    // Add metadata to properties
+    circle.properties = {
+        ...circle.properties,
+        geometryType: 'circle',
+        center: [center.lng, center.lat],
+        radiusFeet,
+        radiusMeters,
+    };
+    return circle;
+}
+/**
+ * Validate circle parameters
+ *
+ * @param radiusFeet - Radius in feet
+ * @returns Validation result
+ */
+function validateCircle(radiusFeet) {
+    const errors = [];
+    if (typeof radiusFeet !== 'number' || !isFinite(radiusFeet)) {
+        errors.push({
+            field: 'radiusFeet',
+            message: 'Radius must be a valid number',
+            code: constants_1.ERROR_CODES.INVALID_COORDINATES,
+        });
+    }
+    else {
+        if (radiusFeet < constants_1.CIRCLE_CONSTRAINTS.MIN_RADIUS) {
+            errors.push({
+                field: 'radiusFeet',
+                message: `Radius must be at least ${constants_1.CIRCLE_CONSTRAINTS.MIN_RADIUS} feet`,
+                code: constants_1.ERROR_CODES.CIRCLE_RADIUS_TOO_SMALL,
+            });
+        }
+        if (radiusFeet > constants_1.CIRCLE_CONSTRAINTS.MAX_RADIUS) {
+            errors.push({
+                field: 'radiusFeet',
+                message: `Radius must not exceed ${constants_1.CIRCLE_CONSTRAINTS.MAX_RADIUS} feet`,
+                code: constants_1.ERROR_CODES.CIRCLE_RADIUS_TOO_LARGE,
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Get the center point of a circle geometry
+ *
+ * @param circle - Circle feature
+ * @returns Center point as LatLng
+ */
+function getCircleCenter(circle) {
+    const center = circle.properties?.center;
+    if (center && Array.isArray(center) && center.length === 2) {
+        return { lng: center[0], lat: center[1] };
+    }
+    // Fallback: calculate centroid
+    const centroid = turf.centroid(circle);
+    return {
+        lng: centroid.geometry.coordinates[0],
+        lat: centroid.geometry.coordinates[1],
+    };
+}
+/**
+ * Get the radius of a circle geometry
+ *
+ * @param circle - Circle feature
+ * @returns Radius in feet, or null if not a circle
+ */
+function getCircleRadius(circle) {
+    return circle.properties?.radiusFeet ?? null;
+}
+//# sourceMappingURL=circle.js.map

package/dist/cjs/core/geometry/circle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle.js","sourceRoot":"","sources":["../../../../src/core/geometry/circle.ts"],"names":[],"mappings":"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"}

package/dist/cjs/core/geometry/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuffer = exports.calculateBearing = exports.calculateDistance = exports.checkContains = exports.checkIntersection = exports.calculateIntersection = exports.calculateCentroid = exports.calculatePerimeter = exports.calculateArea = exports.getPolygonPoints = exports.validatePolygon = exports.createPolygon = exports.getCircleRadius = exports.getCircleCenter = exports.validateCircle = exports.createCircle = void 0;
+// ─── Circle ──────────────────────────────────────────────────────────────────
+var circle_1 = require("./circle");
+Object.defineProperty(exports, "createCircle", { enumerable: true, get: function () { return circle_1.createCircle; } });
+Object.defineProperty(exports, "validateCircle", { enumerable: true, get: function () { return circle_1.validateCircle; } });
+Object.defineProperty(exports, "getCircleCenter", { enumerable: true, get: function () { return circle_1.getCircleCenter; } });
+Object.defineProperty(exports, "getCircleRadius", { enumerable: true, get: function () { return circle_1.getCircleRadius; } });
+// ─── Polygon ─────────────────────────────────────────────────────────────────
+var polygon_1 = require("./polygon");
+Object.defineProperty(exports, "createPolygon", { enumerable: true, get: function () { return polygon_1.createPolygon; } });
+Object.defineProperty(exports, "validatePolygon", { enumerable: true, get: function () { return polygon_1.validatePolygon; } });
+Object.defineProperty(exports, "getPolygonPoints", { enumerable: true, get: function () { return polygon_1.getPolygonPoints; } });
+// ─── Operations ──────────────────────────────────────────────────────────────
+var operations_1 = require("./operations");
+Object.defineProperty(exports, "calculateArea", { enumerable: true, get: function () { return operations_1.calculateArea; } });
+Object.defineProperty(exports, "calculatePerimeter", { enumerable: true, get: function () { return operations_1.calculatePerimeter; } });
+Object.defineProperty(exports, "calculateCentroid", { enumerable: true, get: function () { return operations_1.calculateCentroid; } });
+Object.defineProperty(exports, "calculateIntersection", { enumerable: true, get: function () { return operations_1.calculateIntersection; } });
+Object.defineProperty(exports, "checkIntersection", { enumerable: true, get: function () { return operations_1.checkIntersection; } });
+Object.defineProperty(exports, "checkContains", { enumerable: true, get: function () { return operations_1.checkContains; } });
+Object.defineProperty(exports, "calculateDistance", { enumerable: true, get: function () { return operations_1.calculateDistance; } });
+Object.defineProperty(exports, "calculateBearing", { enumerable: true, get: function () { return operations_1.calculateBearing; } });
+Object.defineProperty(exports, "createBuffer", { enumerable: true, get: function () { return operations_1.createBuffer; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/core/geometry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/geometry/index.ts"],"names":[],"mappings":";;;AAAA,gFAAgF;AAChF,mCAKkB;AAJhB,sGAAA,YAAY,OAAA;AACZ,wGAAA,cAAc,OAAA;AACd,yGAAA,eAAe,OAAA;AACf,yGAAA,eAAe,OAAA;AAGjB,gFAAgF;AAChF,qCAImB;AAHjB,wGAAA,aAAa,OAAA;AACb,0GAAA,eAAe,OAAA;AACf,2GAAA,gBAAgB,OAAA;AAGlB,gFAAgF;AAChF,2CAUsB;AATpB,2GAAA,aAAa,OAAA;AACb,gHAAA,kBAAkB,OAAA;AAClB,+GAAA,iBAAiB,OAAA;AACjB,mHAAA,qBAAqB,OAAA;AACrB,+GAAA,iBAAiB,OAAA;AACjB,2GAAA,aAAa,OAAA;AACb,+GAAA,iBAAiB,OAAA;AACjB,8GAAA,gBAAgB,OAAA;AAChB,0GAAA,YAAY,OAAA"}

package/dist/cjs/core/geometry/operations.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateArea = calculateArea;
+exports.calculatePerimeter = calculatePerimeter;
+exports.calculateCentroid = calculateCentroid;
+exports.calculateIntersection = calculateIntersection;
+exports.checkIntersection = checkIntersection;
+exports.checkContains = checkContains;
+exports.calculateDistance = calculateDistance;
+exports.calculateBearing = calculateBearing;
+exports.createBuffer = createBuffer;
+const turf = __importStar(require("@turf/turf"));
+const helpers_1 = require("../utils/helpers");
+/**
+ * Calculate the area of a geometry in square feet
+ *
+ * @param geometry - GeoJSON geometry
+ * @returns Area in square feet
+ */
+function calculateArea(geometry) {
+    const areaSquareMeters = turf.area(geometry);
+    return areaSquareMeters * 10.7639; // Convert to square feet
+}
+/**
+ * Calculate the perimeter/length of a geometry in feet
+ *
+ * @param geometry - GeoJSON geometry
+ * @returns Perimeter/length in feet
+ */
+function calculatePerimeter(geometry) {
+    const lengthMeters = turf.length(geometry, { units: 'meters' });
+    return (0, helpers_1.metersToFeet)(lengthMeters);
+}
+/**
+ * Calculate the centroid of a geometry
+ *
+ * @param geometry - GeoJSON geometry
+ * @returns Centroid as LatLng
+ */
+function calculateCentroid(geometry) {
+    const centroid = turf.centroid(geometry);
+    return {
+        lng: centroid.geometry.coordinates[0],
+        lat: centroid.geometry.coordinates[1],
+    };
+}
+/**
+ * Calculate the intersection of two geometries
+ *
+ * @param geometry1 - First geometry
+ * @param geometry2 - Second geometry
+ * @returns Intersection geometry, or null if no intersection
+ */
+function calculateIntersection(geometry1, geometry2) {
+    try {
+        const intersection = turf.intersect(geometry1, geometry2);
+        return intersection ? intersection.geometry : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if two geometries intersect
+ *
+ * @param geometry1 - First geometry
+ * @param geometry2 - Second geometry
+ * @returns True if geometries intersect
+ */
+function checkIntersection(geometry1, geometry2) {
+    try {
+        // Check if geometries intersect by attempting to find intersection
+        const intersection = calculateIntersection(geometry1, geometry2);
+        return intersection !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if one geometry contains another
+ *
+ * @param container - Container geometry
+ * @param contained - Potentially contained geometry
+ * @returns True if container contains the other geometry
+ */
+function checkContains(container, contained) {
+    try {
+        const feature1 = container.type === 'Feature' ? container : turf.feature(container);
+        const feature2 = contained.type === 'Feature' ? contained : turf.feature(contained);
+        return turf.booleanContains(feature1, feature2);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Calculate distance between two points in feet
+ *
+ * @param point1 - First point
+ * @param point2 - Second point
+ * @returns Distance in feet
+ */
+function calculateDistance(point1, point2) {
+    const from = turf.point([point1.lng, point1.lat]);
+    const to = turf.point([point2.lng, point2.lat]);
+    const distanceMeters = turf.distance(from, to, { units: 'meters' });
+    return (0, helpers_1.metersToFeet)(distanceMeters);
+}
+/**
+ * Calculate bearing between two points in degrees
+ *
+ * @param point1 - Starting point
+ * @param point2 - Ending point
+ * @returns Bearing in degrees (0-360)
+ */
+function calculateBearing(point1, point2) {
+    const from = turf.point([point1.lng, point1.lat]);
+    const to = turf.point([point2.lng, point2.lat]);
+    const bearing = turf.bearing(from, to);
+    // Convert to 0-360 range
+    return (bearing + 360) % 360;
+}
+/**
+ * Create a buffer around a geometry
+ *
+ * @param geometry - Input geometry
+ * @param radiusFeet - Buffer radius in feet
+ * @returns Buffered geometry
+ */
+function createBuffer(geometry, radiusFeet) {
+    const radiusMeters = radiusFeet * 0.3048;
+    const radiusKm = radiusMeters / 1000;
+    return turf.buffer(geometry, radiusKm, { units: 'kilometers' });
+}
+//# sourceMappingURL=operations.js.map