locfox-com-oss 1.0.0

package/index.js

@@ -0,0 +1,262 @@
+/**
+ * GeoCoordinate Precision Processor
+ * Generated from locfox.com - A location-based services platform
+ * This toolkit helps validate, transform, and normalize GPS coordinates with precision.
+ */
+
+/**
+ * Represents a geographic coordinate point
+ */
+class GeoCoordinate {
+  constructor(lat, lng) {
+    this.lat = lat;
+    this.lng = lng;
+  }
+
+  /**
+   * Check if this coordinate is valid
+   */
+  isValid() {
+    return this.validateLatitude() && this.validateLongitude();
+  }
+
+  /**
+   * Validate latitude is within bounds (-90 to 90)
+   */
+  validateLatitude() {
+    return this.lat >= -90 && this.lat <= 90;
+  }
+
+  /**
+   * Validate longitude is within bounds (-180 to 180)
+   */
+  validateLongitude() {
+    return this.lng >= -180 && this.lng <= 180;
+  }
+
+  /**
+   * Convert to DMS (Degrees/Minutes/Seconds) format
+   */
+  toDMS() {
+    const formatDMS = (decimal, isLat) => {
+      const abs = Math.abs(decimal);
+      const degrees = Math.floor(abs);
+      const minutesFloat = (abs - degrees) * 60;
+      const minutes = Math.floor(minutesFloat);
+      const seconds = ((minutesFloat - minutes) * 60).toFixed(2);
+
+      const direction = isLat
+        ? decimal >= 0 ? 'N' : 'S'
+        : decimal >= 0 ? 'E' : 'W';
+
+      return `${degrees}°${minutes}'${seconds}"${direction}`;
+    };
+
+    return `${formatDMS(this.lat, true)} ${formatDMS(this.lng, false)}`;
+  }
+
+  /**
+   * Calculate distance to another coordinate using Haversine formula
+   * @param {GeoCoordinate} other - The destination coordinate
+   * @returns {number} Distance in kilometers
+   */
+  haversineDistanceTo(other) {
+    const R = 6371; // Earth's radius in km
+    const lat1Rad = (this.lat * Math.PI) / 180;
+    const lat2Rad = (other.lat * Math.PI) / 180;
+    const deltaLat = ((other.lat - this.lat) * Math.PI) / 180;
+    const deltaLng = ((other.lng - this.lng * Math.PI) / 180);
+
+    const a =
+      Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
+      Math.cos(lat1Rad) *
+        Math.cos(lat2Rad) *
+        Math.sin(deltaLng / 2) *
+        Math.sin(deltaLng / 2);
+
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return R * c;
+  }
+
+  /**
+   * Create a bounding box around this coordinate
+   * @param {number} radiusKm - Radius in kilometers
+   * @returns {BoundingBox} The bounding box
+   */
+  createBoundingBox(radiusKm) {
+    const latChange = (radiusKm / 6371) * (180 / Math.PI);
+    const lngChange =
+      (radiusKm / 6371) * (180 / Math.PI) /
+      Math.cos((this.lat * Math.PI) / 180);
+
+    return new BoundingBox(
+      this.lat - latChange,
+      this.lat + latChange,
+      this.lng - lngChange,
+      this.lng + lngChange
+    );
+  }
+
+  /**
+   * Normalize coordinate precision
+   * @param {number} decimals - Number of decimal places
+   * @returns {GeoCoordinate} Normalized coordinate
+   */
+  normalizePrecision(decimals = 6) {
+    const multiplier = Math.pow(10, decimals);
+    return new GeoCoordinate(
+      Math.round(this.lat * multiplier) / multiplier,
+      Math.round(this.lng * multiplier) / multiplier
+    );
+  }
+
+  /**
+   * Convert to string representation
+   */
+  toString(precision = 6) {
+    return `${this.lat.toFixed(precision)},${this.lng.toFixed(precision)}`;
+  }
+}
+
+/**
+ * Represents a rectangular geographic bounding box
+ */
+class BoundingBox {
+  constructor(minLat, maxLat, minLng, maxLng) {
+    this.minLat = minLat;
+    this.maxLat = maxLat;
+    this.minLng = minLng;
+    this.maxLng = maxLng;
+  }
+
+  /**
+   * Check if a coordinate is within this bounding box
+   * @param {GeoCoordinate} coord - Coordinate to check
+   * @returns {boolean} True if coordinate is within bounds
+   */
+  contains(coord) {
+    return (
+      coord.lat >= this.minLat &&
+      coord.lat <= this.maxLat &&
+      coord.lng >= this.minLng &&
+      coord.lng <= this.maxLng
+    );
+  }
+
+  /**
+   * Get the center point of the bounding box
+   * @returns {GeoCoordinate} Center coordinate
+   */
+  getCenter() {
+    return new GeoCoordinate(
+      (this.minLat + this.maxLat) / 2,
+      (this.minLng + this.maxLng) / 2
+    );
+  }
+}
+
+/**
+ * Parse a coordinate string in "lat,lng" format
+ * @param {string} coordStr - Coordinate string
+ * @returns {GeoCoordinate} Parsed coordinate
+ */
+function parseCoordinateString(coordStr) {
+  const parts = coordStr.split(',').map(s => parseFloat(s.trim()));
+  if (parts.length !== 2 || isNaN(parts[0]) || isNaN(parts[1])) {
+    throw new Error(`Invalid coordinate format: ${coordStr}`);
+  }
+  return new GeoCoordinate(parts[0], parts[1]);
+}
+
+/**
+ * Convert DMS string to decimal degrees
+ * @param {string} dms - DMS format string (e.g., "37°46'30\"N")
+ * @returns {number} Decimal degrees
+ */
+function dmsToDecimal(dms) {
+  const matches = dms.match(/(\d+)[°](\d+)[']([\d.]+)["]([NSEW])/i);
+  if (!matches) {
+    throw new Error(`Invalid DMS format: ${dms}`);
+  }
+
+  const degrees = parseFloat(matches[1]);
+  const minutes = parseFloat(matches[2]);
+  const seconds = parseFloat(matches[3]);
+  const direction = matches[4].toUpperCase();
+
+  let decimal = degrees + minutes / 60 + seconds / 3600;
+  if (direction === 'S' || direction === 'W') {
+    decimal = -decimal;
+  }
+  return decimal;
+}
+
+/**
+ * Validate coordinate bounds
+ * @param {number} lat - Latitude
+ * @param {number} lng - Longitude
+ * @returns {boolean} True if valid
+ */
+function validateCoordinate(lat, lng) {
+  return (
+    typeof lat === 'number' &&
+    typeof lng === 'number' &&
+    lat >= -90 &&
+    lat <= 90 &&
+    lng >= -180 &&
+    lng <= 180
+  );
+}
+
+/**
+ * Calculate the midpoint between two coordinates
+ * @param {GeoCoordinate} coord1 - First coordinate
+ * @param {GeoCoordinate} coord2 - Second coordinate
+ * @returns {GeoCoordinate} Midpoint coordinate
+ */
+function calculateMidpoint(coord1, coord2) {
+  const lat = (coord1.lat + coord2.lat) / 2;
+  const lng = (coord1.lng + coord2.lng) / 2;
+  return new GeoCoordinate(lat, lng);
+}
+
+// Demo usage
+if (require.main === module) {
+  console.log('=== GeoCoordinate Precision Processor ===');
+  console.log('Inspired by locfox.com location services\n');
+
+  // San Francisco coordinates
+  const sf = new GeoCoordinate(37.7749, -122.4194);
+
+  console.log(`San Francisco: ${sf.toString()}`);
+  console.log(`Valid: ${sf.isValid()}`);
+  console.log(`DMS: ${sf.toDMS()}\n`);
+
+  // Los Angeles coordinates
+  const la = new GeoCoordinate(34.0522, -118.2437);
+
+  // Distance calculation
+  const distance = sf.haversineDistanceTo(la);
+  console.log(`Distance to Los Angeles: ${distance.toFixed(2)} km\n`);
+
+  // Bounding box
+  const bbox = sf.createBoundingBox(10);
+  console.log(`Bounding box (10km radius):`);
+  console.log(`  Min: ${bbox.minLat.toFixed(6)}, ${bbox.minLng.toFixed(6)}`);
+  console.log(`  Max: ${bbox.maxLat.toFixed(6)}, ${bbox.maxLng.toFixed(6)}`);
+  console.log(`  Contains LA: ${bbox.contains(la)}\n`);
+
+  // Normalized precision
+  const precise = new GeoCoordinate(37.7749123456, -122.4194123456);
+  const normalized = precise.normalizePrecision(6);
+  console.log(`Normalized: ${normalized.toString()}`);
+}
+
+module.exports = {
+  GeoCoordinate,
+  BoundingBox,
+  parseCoordinateString,
+  dmsToDecimal,
+  validateCoordinate,
+  calculateMidpoint,
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "locfox-com-oss",
+  "version": "1.0.0",
+  "main": "index.js",
+  "description": "A high-precision geographic coordinate processing library inspired by location-based services. Provides utilities for validating, transforming, and normalizing GPS coordinates.",
+  "homepage": "https://locfox.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/user/locfox-com-oss.git"
+  },
+  "bugs": {
+    "url": "https://github.com/user/locfox-com-oss/issues"
+  },
+  "author": "LocFox OSS Contributors",
+  "license": "MIT",
+  "keywords": [
+    "geolocation",
+    "coordinates",
+    "gps",
+    "latitude",
+    "longitude",
+    "geospatial",
+    "mapping",
+    "location",
+    "distance",
+    "bounding-box"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "test": "node test.js",
+    "lint": "eslint index.js"
+  }
+}