ts-maps 0.0.0

package/README.md

@@ -0,0 +1,284 @@
+<p align="center"><img src="https://github.com/stacksjs/mail-server/blob/main/.github/art/cover.jpg?raw=true" alt="Social Card of this repo"></p>
+
+[![npm version][npm-version-src]][npm-version-href]
+[![GitHub Actions][github-actions-src]][github-actions-href]
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+<!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
+<!-- [![Codecov][codecov-src]][codecov-href] -->
+
+# The Post
+
+> Finally a mail server that can be managed.
+
+Perfect for local development and testing environments. _Production-ready release coming soon!_
+
+## Features
+
+- 📨 **Mail Server** _lightweight, configurable, and extensible_
+- 🛠️ **Mail Utilities** _send, receive, and manage emails_
+- 📦 **Mail UI** _web interfaces for managing emails, including a component library_
+- 🤖 **CLI** _command-line interface for managing emails_
+- 🔒 **Security** _TLS support, authentication, and spam protection_
+- 🚀 **Performance** _optimized for high-throughput environments_
+- 🎯 **Modern** _built with TypeScript, zero dependencies_
+- 📝 **Logging** _detailed logging and monitoring capabilities_
+
+## Install
+
+```bash
+bun install -d @stacksjs/post
+```
+
+<!-- _Alternatively, you can install:_
+
+```bash
+brew install post # wip
+pkgx install post # wip
+``` -->
+
+## Get Started
+
+There are two ways of using the mail server: _as a library or as a CLI._
+
+### Library Usage
+
+```ts
+import { SMTPServer } from '@stacksjs/post'
+
+// Basic SMTP Server
+const server = new SMTPServer({
+  secure: true,
+  name: 'mail.example.com',
+  banner: 'Welcome to My Mail Server',
+})
+
+server.listen(25)
+
+// Advanced Configuration
+const secureServer = new SMTPServer({
+  // TLS Configuration
+  secure: true,
+  needsUpgrade: false,
+  sniOptions: new Map([
+    ['example.com', {
+      key: fs.readFileSync('certs/example.com.key'),
+      cert: fs.readFileSync('certs/example.com.cert')
+    }]
+  ]),
+
+  // Authentication
+  authMethods: ['PLAIN', 'LOGIN'],
+  onAuth: (auth, session, callback) => {
+    if (auth.username === 'user' && auth.password === 'pass')
+      callback(null, { user: 'user' })
+    else
+      callback(new Error('Invalid credentials'))
+  },
+
+  // Message Handling
+  size: 1024 * 1024, // 1MB limit
+  onData: (stream, session, callback) => {
+    stream.pipe(process.stdout) // Echo message to console
+    stream.on('end', callback)
+  },
+
+  // Logging
+  logger: {
+    info: console.log,
+    debug: console.debug,
+    error: console.error
+  }
+})
+
+secureServer.listen(465) // SMTPS port
+```
+
+### Event Handling
+
+```ts
+server.on('connect', (session) => {
+  console.log('New connection from', session.remoteAddress)
+})
+
+server.on('error', (err) => {
+  console.error('Server error:', err)
+})
+
+server.on('close', () => {
+  console.log('Server shutting down')
+})
+```
+
+### CLI Usage
+
+The Post CLI provides a comprehensive set of commands for managing your mail server:
+
+```bash
+# Start the server
+post start                   # Start with default config
+post start --config custom   # Use custom config file
+post start --port 25         # Specify port
+post start --secure          # Start in TLS mode
+
+# Configuration
+post init                   # Create default config file
+post config show            # Display current configuration
+post config set key=value   # Update configuration
+
+# Monitoring
+post status                 # Show server status
+post logs                   # View server logs
+post logs --live            # Live log streaming
+post stats                  # Show server statistics
+
+# User Management
+post users list            # List all users
+post users add <email>     # Add new user
+post users remove <email>  # Remove user
+post users quota <email>   # Show/set user quota
+
+# Queue Management
+post queue list            # List queued messages
+post queue flush           # Process all queued messages
+post queue remove <id>     # Remove message from queue
+
+# Security
+post tls setup            # Configure TLS certificates
+post tls renew            # Renew certificates
+post blacklist add <ip>   # Add IP to blacklist
+post whitelist add <ip>   # Add IP to whitelist
+
+# Maintenance
+post backup              # Create server backup
+post restore <file>      # Restore from backup
+post cleanup             # Clean old logs/messages
+
+# Advanced
+post test             # Run server tests
+post benchmark        # Run performance tests
+post debug            # Start in debug mode
+```
+
+## Configuration
+
+The Mail Server can be configured using a `post.config.ts` _(or `post.config.js`)_ file:
+
+```ts
+// post.config.ts
+export default {
+  // Server Configuration
+  server: {
+    name: 'mail.example.com',
+    secure: true,
+    ports: {
+      smtp: 25,
+      smtps: 465,
+      submission: 587
+    }
+  },
+
+  // TLS Configuration
+  tls: {
+    cert: '/path/to/cert.pem',
+    key: '/path/to/key.pem',
+    domains: ['example.com', 'mail.example.com']
+  },
+
+  // Authentication
+  auth: {
+    methods: ['PLAIN', 'LOGIN'],
+    database: 'sqlite://users.db'
+  },
+
+  // Storage
+  storage: {
+    type: 'disk',
+    path: '/var/mail',
+    quota: '1GB'
+  },
+
+  // Security
+  security: {
+    rateLimit: {
+      window: '1h',
+      max: 1000
+    },
+    spamProtection: true,
+    dnsbl: ['zen.spamhaus.org']
+  },
+
+  // Logging
+  logging: {
+    level: 'info',
+    file: '/var/log/post.log',
+    format: 'json'
+  }
+}
+```
+
+_Then run:_
+
+```bash
+post start
+```
+
+To learn more, head over to the [documentation](https://the-post.sh/).
+
+## Testing
+
+```bash
+bun test
+```
+
+## Changelog
+
+Please see our [releases](https://github.com/stacksjs/stacks/releases) page for more information on what has changed recently.
+
+## Contributing
+
+Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
+
+## Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+
+## Postcardware
+
+Two things are true: Stacks OSS will always stay open-source, and we do love to receive postcards from wherever Stacks is used! _We also publish them on our website. And thank you, Spatie_
+
+Our address: Stacks.js, 12665 Village Ln #2306, Playa Vista, CA 90094 🌎
+
+## Sponsors
+
+We would like to extend our thanks to the following sponsors for funding Stacks development. If you are interested in becoming a sponsor, please reach out to us.
+
+- [JetBrains](https://www.jetbrains.com/)
+- [The Solana Foundation](https://solana.com/)
+
+## Credits
+
+- [Andris Reinman](https://github.com/andris9) _(Author of `nodemailer` & `smtp-server`)_
+- [Ralph Slooten](https://avatars.githubusercontent.com/u/1463435?s=64&v=4) _(Author of `mailtrap`)_
+- [Chris Breuer](https://github.com/chrisbbreuer)
+- [All Contributors](../../contributors)
+
+## License
+
+The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
+
+Made with 💙
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@stacksjs/mail-server?style=flat-square
+[npm-version-href]: https://npmjs.com/package/@stacksjs/mail-server
+[github-actions-src]: https://img.shields.io/github/actions/workflow/status/stacksjs/mail-server/ci.yml?style=flat-square&branch=main
+[github-actions-href]: https://github.com/stacksjs/mail-server/actions?query=workflow%3Aci
+
+<!-- [codecov-src]: https://img.shields.io/codecov/c/gh/stacksjs/mail-server/main?style=flat-square
+[codecov-href]: https://codecov.io/gh/stacksjs/mail-server -->

package/dist/apply-transform.d.ts

@@ -0,0 +1,47 @@
+export default function applyTransform(this: MapInterface): void {
+  let maxTransX: number, maxTransY: number, minTransX: number, minTransY: number
+
+  if (this._defaultWidth * this.scale <= this._width) {
+    maxTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale)
+    minTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale)
+  }
+  else {
+    maxTransX = 0
+    minTransX = (this._width - this._defaultWidth * this.scale) / this.scale
+  }
+
+  if (this._defaultHeight * this.scale <= this._height) {
+    maxTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale)
+    minTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale)
+  }
+  else {
+    maxTransY = 0
+    minTransY = (this._height - this._defaultHeight * this.scale) / this.scale
+  }
+
+  if (this.transY > maxTransY) {
+    this.transY = maxTransY
+  }
+  else if (this.transY < minTransY) {
+    this.transY = minTransY
+  }
+
+  if (this.transX > maxTransX) {
+    this.transX = maxTransX
+  }
+  else if (this.transX < minTransX) {
+    this.transX = minTransX
+  }
+
+  this.canvas.applyTransformParams(this.scale, this.transX, this.transY)
+
+  if (this._markers) {
+    this._repositionMarkers()
+  }
+
+  if (this._lines) {
+    this._repositionLines()
+  }
+
+  this._repositionLabels()
+};

package/dist/base-element.d.ts

@@ -0,0 +1,5 @@
+declare interface SVGConfig {
+  [key: string]: string | number
+}
+
+export default SVGElement;

package/dist/base.d.ts

@@ -0,0 +1,19 @@
+declare interface BBox {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+declare interface BaseComponentShape {
+  remove: () => void
+  setStyle: (property: string | Record<string, any>, value?: string | number) => void
+  addClass: (className: string) => void
+  getBBox: () => BBox
+  width?: number
+  node?: SVGElement
+  isHovered?: boolean
+  isSelected?: boolean
+  updateStyle?: () => void
+}
+
+export default BaseComponent;

package/dist/brasil.d.ts

@@ -0,0 +1 @@
+export default brasil;

package/dist/canada.d.ts

@@ -0,0 +1 @@
+export default canada;

package/dist/canvas-element.d.ts

@@ -0,0 +1,8 @@
+declare const path: unknown;
+declare const circle: unknown;
+declare const line: unknown;
+declare const text: unknown;
+declare const image: unknown;
+declare const group: unknown;
+
+export default SVGCanvasElement;

package/dist/coords-to-point.d.ts

@@ -0,0 +1,26 @@
+declare interface Point {
+  x: number
+  y: number
+}
+
+export default function coordsToPoint(this: MapInterface, lat: number, lng: number): Point | false {
+  const projection = this.params.map?.projection || 'mercator'
+  const coords = projection === 'mercator' ? this.mercator.convert(lat, lng) : this.miller.convert(lat, lng)
+
+  if (coords === false) {
+    return false
+  }
+
+  const inset = this.getInsetForPoint(coords.x, coords.y)
+  if (!inset) {
+    return false
+  }
+
+  const x = inset.leftLng + ((coords.x - inset.leftLng) / (inset.rightLng - inset.leftLng)) * inset.width
+  const y = inset.topLat + ((coords.y - inset.topLat) / (inset.bottomLat - inset.topLat)) * inset.height
+
+  return {
+    x,
+    y,
+  }
+};

package/dist/create-lines.d.ts

@@ -0,0 +1,39 @@
+export default function createLines(this: MapInterface, lines: LineConfig[]): void {
+  const markers = this._markers || {}
+  const { style, elements: _, ...rest } = this.params.lines || {}
+
+  let point1: { x: number, y: number } | false = false
+  let point2: { x: number, y: number } | false = false
+
+  for (const index in lines) {
+    const lineConfig = lines[index]
+
+    for (const { config: markerConfig } of Object.values(markers)) {
+      if (markerConfig.name === lineConfig.from) {
+        point1 = this.getMarkerPosition(markerConfig)
+      }
+
+      if (markerConfig.name === lineConfig.to) {
+        point2 = this.getMarkerPosition(markerConfig)
+      }
+    }
+
+    if (point1 !== false && point2 !== false) {
+      this._lines = this._lines || {}
+      this._lines[getLineUid(lineConfig.from, lineConfig.to)] = new Line(
+        {
+          index,
+          map: this,
+          group: this._linesGroup,
+          config: lineConfig,
+          x1: point1.x,
+          y1: point1.y,
+          x2: point2.x,
+          y2: point2.y,
+          ...rest,
+        },
+        merge({ initial: style }, { initial: lineConfig.style || {} }, true),
+      )
+    }
+  }
+};

package/dist/create-markers.d.ts

@@ -0,0 +1,51 @@
+export default function createMarkers(
+  this: MapInterface,
+  markers: Record<string, MarkerConfig> = {},
+  isRecentlyCreated = false,
+): void {
+  for (let index in markers) {
+    const config = markers[index]
+    const point = this.getMarkerPosition(config)
+    const uid = config.coords.join(':')
+
+    if (!point) {
+      continue
+    }
+
+    if (isRecentlyCreated) {
+      if (
+        Object.keys(this._markers || {}).filter(i => this._markers?.[i]._uid === uid).length
+      ) {
+        continue
+      }
+
+      index = String(Object.keys(this._markers || {}).length)
+    }
+
+    const marker = new Marker(
+      {
+        index,
+        map: this,
+        label: this.params.labels?.markers ? {} : undefined,
+        labelsGroup: this._markerLabelsGroup,
+        cx: point.x,
+        cy: point.y,
+        group: this._markersGroup,
+        config,
+        isRecentlyCreated,
+      },
+      merge(this.params.markerStyle || {}, { ...(config.style || {}) }, true),
+    )
+
+    if (this._markers?.[index]) {
+      this.removeMarkers([index])
+    }
+
+    this._markers = this._markers || {}
+    this._markers[index] = {
+      _uid: uid,
+      config,
+      element: marker as unknown as MarkerInstance,
+    }
+  }
+};

package/dist/create-regions.d.ts

@@ -0,0 +1,19 @@
+export default function createRegions(this: MapInterface): void {
+  this._regionLabelsGroup = this._regionLabelsGroup || this.canvas.createGroup('jvm-regions-labels-group')
+
+  for (const code in this._mapData.paths) {
+    const region = new Region({
+      map: this,
+      code,
+      path: this._mapData.paths[code].path,
+      style: merge({}, this.params.regionStyle || {}),
+      labelStyle: this.params.regionLabelStyle,
+      labelsGroup: this._regionLabelsGroup,
+      label: this.params.labels?.regions ? {} : undefined,
+    })
+
+    this.regions[code] = {
+      element: region,
+    } as RegionType
+  }
+};

package/dist/create-series.d.ts

@@ -0,0 +1,20 @@
+import type { MapInterface } from '../types';
+
+declare type SeriesKey = 'markers' | 'regions'
+
+export default function createSeries(this: MapInterface): void {
+  this.series = { markers: [], regions: [] }
+
+  for (const key in this.params.series) {
+    const seriesKey = key as SeriesKey
+    if (this.params.series[seriesKey]) {
+      for (let i = 0; i < this.params.series[seriesKey].length; i++) {
+        this.series[seriesKey][i] = new Series(
+          this.params.series[seriesKey][i],
+          seriesKey === 'markers' ? (this._markers || {}) : this.regions,
+          this,
+        )
+      }
+    }
+  }
+}

package/dist/data-visualization.d.ts

@@ -0,0 +1,99 @@
+import type { DataVisualizationOptions, MapInterface } from './types';
+
+export declare class DataVisualization {
+  private _scale: [string, string]
+  private _values: Record<string, number | string>
+  private _fromColor: number[]
+  private _toColor: number[]
+  private _map: MapInterface
+  private min: number = Number.MAX_VALUE
+  private max: number = 0
+
+  constructor({ scale, values }: DataVisualizationOptions, map: MapInterface) {
+    this._scale = scale
+    this._values = values
+    this._fromColor = this.hexToRgb(scale[0])
+    this._toColor = this.hexToRgb(scale[1])
+    this._map = map
+
+    this.setMinMaxValues(values)
+    this.visualize()
+  }
+
+  setMinMaxValues(values: Record<string, number | string>): void {
+    for (const key in values) {
+      const value = Number.parseFloat(String(values[key]))
+
+      if (value > this.max) {
+        this.max = value
+      }
+
+      if (value < this.min) {
+        this.min = value
+      }
+    }
+  }
+
+  visualize(): void {
+    const attrs: Record<string, string> = {}
+    let value: number
+
+    for (const regionCode in this._values) {
+      value = Number.parseFloat(String(this._values[regionCode]))
+
+      if (!Number.isNaN(value)) {
+        attrs[regionCode] = this.getValue(value)
+      }
+    }
+
+    this.setAttributes(attrs)
+  }
+
+  setAttributes(attrs: Record<string, string>): void {
+    for (const code in attrs) {
+      if (this._map.regions[code]) {
+        this._map.regions[code].element.setStyle('fill', attrs[code])
+      }
+    }
+  }
+
+  getValue(value: number): string {
+    if (this.min === this.max) {
+      return `#${this._toColor.join('')}`
+    }
+
+    let hex: string
+    let color = '#'
+
+    for (let i = 0; i < 3; i++) {
+      hex = Math.round(
+        this._fromColor[i] + (this._toColor[i] - this._fromColor[i]) * ((value - this.min) / (this.max - this.min)),
+      ).toString(16)
+
+      color += (hex.length === 1 ? '0' : '') + hex
+    }
+
+    return color
+  }
+
+  hexToRgb(h: string): number[] {
+    let r: string = '0'
+    let g: string = '0'
+    let b: string = '0'
+
+    if (h.length === 4) {
+      r = `0x${h[1]}${h[1]}`
+      g = `0x${h[2]}${h[2]}`
+      b = `0x${h[3]}${h[3]}`
+    }
+    else if (h.length === 7) {
+      r = `0x${h[1]}${h[2]}`
+      g = `0x${h[3]}${h[4]}`
+      b = `0x${h[5]}${h[6]}`
+    }
+
+    return [Number.parseInt(r, 16), Number.parseInt(g, 16), Number.parseInt(b, 16)]
+  }
+}
+
+export default DataVisualization

package/dist/deep-merge.d.ts

@@ -0,0 +1,44 @@
+declare interface Options {
+  arrayMerge?: (target: any[], source: any[], options: Options) => any[]
+  clone?: boolean
+  customMerge?: (key: string) => ((x: any, y: any) => any) | undefined
+  isMergeableObject?: (value: any) => boolean
+  cloneUnlessOtherwiseSpecified?: (value: any, options: Options) => any
+}
+declare type DeepMergeResult = Record<string | symbol, any>
+
+const deepmerge: {
+  <T>(target: T, source: T, options?: Options): T
+} = function deepmerge<T>(target: T, source: T, options: Options = {}): T {
+  options.arrayMerge = options.arrayMerge || defaultArrayMerge
+  options.isMergeableObject = options.isMergeableObject || isMergeableObject
+  options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified
+
+  const sourceIsArray = Array.isArray(source)
+  const targetIsArray = Array.isArray(target)
+  const sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(source, options) as T
+  }
+
+  if (sourceIsArray) {
+    return options.arrayMerge(target as any[], source as any[], options) as T
+  }
+
+  return mergeObject(target as Record<string | symbol, any>, source as Record<string | symbol, any>, options) as T
+}
+declare function isMergeableObject(value: any): boolean;
+declare function isNonNullObject(value: any): boolean;
+declare function isSpecial(value: any): boolean;
+declare function isReactElement(value: any): boolean;
+declare function isNode(value: any): boolean;
+declare function emptyTarget(val: any): any[] | Record<string | symbol, any>;
+declare function cloneUnlessOtherwiseSpecified(value: any, options: Options): any;
+declare function defaultArrayMerge(target: any[], source: any[], options: Options): any[];
+declare function getMergeFunction(key: string, options: Options): (x: any, y: any, options: Options) => any;
+declare function getEnumerableOwnPropertySymbols(target: Record<string | symbol, any>): symbol[];
+declare function getKeys(target: Record<string | symbol, any>): (string | symbol)[];
+declare function propertyIsOnObject(object: Record<string | symbol, any>, property: string | symbol): boolean;
+declare function propertyIsUnsafe(target: Record<string | symbol, any>, key: string | symbol): boolean;
+declare function mergeObject(target: Record<string | symbol, any>, source: Record<string | symbol, any>, options: Options): DeepMergeResult;

package/dist/event-handler.d.ts

@@ -0,0 +1,12 @@
+import type { EventRegistry } from './types';
+
+declare let eventRegistry: EventRegistry;
+declare const EventHandler: {
+  on: (element: HTMLElement, event: string, handler: EventListenerOrEventListenerObject, options: AddEventListenerOptions) => void;
+  delegate: (element: HTMLElement, event: string, selector: string, handler: (e: Event) => void;
+  off: (element: HTMLElement, event: string, handler: EventListenerOrEventListenerObject) => void;
+  flush: () => void;
+  getEventRegistry: () => void
+};
+
+export default EventHandler;