@xyo-network/quadkey 2.38.8 → 2.39.0-rc.1

package/src/Quadkey.ts

@@ -30,8 +30,13 @@ const RelativeDirectionConstantLookup: Record<string, number> = {
 }
 
 export class Quadkey {
+  static Zero = Quadkey.from(0, Buffer.alloc(31, 0))
+  static root = new Quadkey()
+  static type = 'Quadkey'
+
   public type = Quadkey.type
 
+  private _geoJson?: GeoJson
   private key = Buffer.alloc(32)
 
   constructor(key = Buffer.alloc(32)) {
@@ -39,24 +44,114 @@ export class Quadkey {
     this.guessZoom()
   }
 
-  public equals(obj: Quadkey): boolean {
-    return obj.toBase4HashLabel() == this.toBase4HashLabel()
+  get base10String() {
+    return this.bigNumber.toString(10)
   }
 
-  static root = new Quadkey()
+  get base4Hash() {
+    const bn = new BigNumber(this.id.toString('hex'), 16)
+    const zoom = this.zoom
+    if (zoom === 0) {
+      return ''
+    }
+    let quadkeySimple = bn.toString(4)
+    while (quadkeySimple.length < zoom) {
+      quadkeySimple = `0${quadkeySimple}`
+    }
+    return quadkeySimple
+  }
 
-  static type = 'Quadkey'
+  get base4HashLabel() {
+    const hash = this.base4Hash
+    return hash.length === 0 ? 'fhr' : hash
+  }
 
-  static fromBase4String(value?: string) {
-    if (value === 'fhr' || value === '') {
-      return Quadkey.root
+  get bigNumber() {
+    return new BigNumber(`${this.key.toString('hex')}`, 'hex')
+  }
+
+  get boundingBox(): MercatorBoundingBox {
+    return tileToBoundingBox(this.tile)
+  }
+
+  get buffer() {
+    return this.key
+  }
+
+  get center() {
+    const result = boundingBoxToCenter(this.boundingBox)
+    return new LngLat(result[0], result[1])
+  }
+
+  get children() {
+    assertEx(this.zoom < MAX_ZOOM - 1, 'Can not get children of bottom tiles')
+    const result: Quadkey[] = []
+    const shiftedId = bitShiftLeft(bitShiftLeft(this.id))
+    for (let i = 0; i < 4; i++) {
+      const currentLastByte = shiftedId.readUInt8(shiftedId.length - 1)
+      shiftedId.writeUInt8((currentLastByte & 0xfc) | i, shiftedId.length - 1)
+      result.push(new Quadkey().setId(shiftedId).setZoom(this.zoom + 1))
     }
-    if (value && value.length && value.length > 0) {
-      const quadkey = new Quadkey(Buffer.from(padHex(new BigNumber(value, 4).toString(16)), 'hex')).setZoom(value.length)
-      return quadkey.valid() ? quadkey : undefined
+    return result
+  }
+
+  get gridLocation() {
+    const tileData = tileFromQuadkey(this.base4Hash)
+
+    return {
+      col: 2 ** tileData[2] - tileData[1] - 1,
+      row: tileData[0],
+      zoom: tileData[2],
     }
   }
 
+  get hex() {
+    return `0x${this.key.toString('hex')}`
+  }
+
+  get id() {
+    return this.buffer.slice(1)
+  }
+
+  get parent(): Quadkey | undefined {
+    if (this.zoom > 0) {
+      return new Quadkey().setId(bitShiftRight(bitShiftRight(this.id))).setZoom(this.zoom - 1)
+    }
+  }
+
+  get siblings() {
+    const siblings = assertEx(this.parent?.children, `siblings: parentChildren ${this.base4Hash}`)
+    const filteredSiblings = siblings.filter((quadkey) => this.compareTo(quadkey) !== 0)
+    assertEx(filteredSiblings.length === 3, `siblings: expected 3 [${filteredSiblings.length}]`)
+    return filteredSiblings
+  }
+
+  get tile(): MercatorTile {
+    return tileFromQuadkey(this.base4Hash)
+  }
+
+  get valid() {
+    const zoom = this.zoom
+    const shift = (MAX_ZOOM - zoom) * 2
+    const id = this.id
+    let testId = id
+    for (let i = 0; i < shift; i++) {
+      testId = bitShiftLeft(testId)
+    }
+    for (let i = 0; i < shift; i++) {
+      testId = bitShiftRight(testId)
+    }
+    return testId.compare(id) === 0
+  }
+
+  get zoom() {
+    return this.buffer.readUInt8(0)
+  }
+
+  static from(zoom: number, id: Buffer) {
+    return new Quadkey().setId(id).setZoom(zoom)
+  }
+
   static fromBase10String(value: string) {
     return new Quadkey(Buffer.from(padHex(new BigNumber(value, 10).toString(16)), 'hex'))
   }
@@ -66,10 +161,36 @@ export class Quadkey {
     return new Quadkey(Buffer.from(padHex(valueToUse), 'hex'))
   }
 
+  static fromBase4String(value?: string) {
+    if (value === 'fhr' || value === '') {
+      return Quadkey.root
+    }
+    if (value && value.length && value.length > 0) {
+      const quadkey = new Quadkey(Buffer.from(padHex(new BigNumber(value, 4).toString(16)), 'hex')).setZoom(value.length)
+      return quadkey.valid ? quadkey : undefined
+    }
+  }
+
+  static fromBoundingBox(boundingBox: MercatorBoundingBox, zoom: number) {
+    const tiles = tilesFromBoundingBox(boundingBox, Math.floor(zoom))
+    const result: Quadkey[] = []
+    for (const tile of tiles) {
+      result.push(assertEx(Quadkey.fromTile(tile), 'Bad Quadkey'))
+    }
+
+    return result
+  }
+
   static fromBuffer(value: Buffer) {
     return Quadkey.fromBase16String(value.toString('hex'))
   }
 
+  static fromLngLat(point: LngLatLike, zoom: number) {
+    const tile = tileFromPoint(LngLat.convert(point), zoom)
+    const quadkeyString = tileToQuadkey(tile)
+    return Quadkey.fromBase4String(quadkeyString)
+  }
+
   static fromString(zoom: number, id: string, base = 10) {
     switch (base) {
       case 10:
@@ -81,42 +202,43 @@ export class Quadkey {
     }
   }
 
-  public static from(zoom: number, id: Buffer) {
-    return new Quadkey().setId(id).setZoom(zoom)
+  static fromTile(tile: MercatorTile) {
+    return Quadkey.fromBase4String(tileToQuadkey(tile))
   }
 
-  public static fromLngLat(point: LngLatLike, zoom: number) {
-    const tile = tileFromPoint(LngLat.convert(point), zoom)
-    const quadkeyString = tileToQuadkey(tile)
-    return Quadkey.fromBase4String(quadkeyString)
+  childrenByZoom(zoom: number) {
+    // if we are limiting by zoom, and we are already at that limit, just return this quadkey
+    if (zoom && zoom === this.zoom) {
+      return [this]
+    }
+
+    // recursively get children
+    let deepResult: Quadkey[] = []
+    for (const quadkey of this.children) {
+      deepResult = deepResult.concat(quadkey.childrenByZoom(zoom))
+    }
+    return deepResult
   }
 
-  public static fromTile(tile: MercatorTile) {
-    return Quadkey.fromBase4String(tileToQuadkey(tile))
+  clone() {
+    return Quadkey.fromBase10String(this.base10String)
   }
 
-  public isInBoundingBox(boundingBox: MercatorBoundingBox) {
-    const tileBoundingBox = tileToBoundingBox(this.toTile())
-    return (
-      boundingBox.contains(tileBoundingBox.getNorthEast()) ||
-      boundingBox.contains(tileBoundingBox.getNorthWest()) ||
-      boundingBox.contains(tileBoundingBox.getSouthEast()) ||
-      boundingBox.contains(tileBoundingBox.getSouthWest())
-    )
+  compareTo(quadkey: Quadkey) {
+    return this.bigNumber.cmp(quadkey.bigNumber)
   }
 
-  public static fromBoundingBox(boundingBox: MercatorBoundingBox, zoom: number) {
-    const tiles = tilesFromBoundingBox(boundingBox, Math.floor(zoom))
-    const result: Quadkey[] = []
-    for (const tile of tiles) {
-      result.push(assertEx(Quadkey.fromTile(tile), 'Bad Quadkey'))
-    }
+  equals(obj: Quadkey): boolean {
+    return obj.base4HashLabel == this.base4HashLabel
+  }
 
-    return result
+  geoJson() {
+    this._geoJson = this._geoJson ?? new GeoJson(this.base4Hash)
+    return this._geoJson
   }
 
-  public getGridBoundingBox(size: number) {
-    const hash = this.toBase4Hash()
+  getGridBoundingBox(size: number) {
+    const hash = this.base4Hash
     let index = 0
     let left = 0
     let top = 0
@@ -148,27 +270,24 @@ export class Quadkey {
     }
   }
 
-  public setKey(zoom: number, id: Buffer) {
-    id.copy(this.key, this.key.length - id.length)
-    this.key.writeUInt8(zoom, 0)
-    return this
-  }
-
-  public setZoom(zoom: number) {
-    assertEx(zoom < MAX_ZOOM, `Invalid zoom [${zoom}] max=${MAX_ZOOM}`)
-    this.setKey(zoom, this.id)
-    return this
+  /** @deprecated use .gridLocation instead */
+  getGridLocation() {
+    return this.gridLocation
   }
 
-  public parent() {
-    if (this.zoom > 0) {
-      return new Quadkey().setId(bitShiftRight(bitShiftRight(this.id))).setZoom(this.zoom - 1)
-    }
+  isInBoundingBox(boundingBox: MercatorBoundingBox) {
+    const tileBoundingBox = tileToBoundingBox(this.tile)
+    return (
+      boundingBox.contains(tileBoundingBox.getNorthEast()) ||
+      boundingBox.contains(tileBoundingBox.getNorthWest()) ||
+      boundingBox.contains(tileBoundingBox.getSouthEast()) ||
+      boundingBox.contains(tileBoundingBox.getSouthWest())
+    )
   }
 
-  public relative(direction: string) {
+  relative(direction: string) {
     const directionConstant = assertEx(RelativeDirectionConstantLookup[direction], 'Invalid direction')
-    let quadkey = this.toBase4Hash()
+    let quadkey = this.base4Hash
     if (quadkey.length === 0) {
       return this
     }
@@ -191,123 +310,82 @@ export class Quadkey {
     return Quadkey.fromBase4String(quadkey)
   }
 
-  public childrenByZoom(zoom: number) {
-    // if we are limiting by zoom, and we are already at that limit, just return this quadkey
-    if (zoom && zoom === this.zoom) {
-      return [this]
-    }
-
-    // recursively get children
-    let deepResult: Quadkey[] = []
-    for (const quadkey of this.children()) {
-      deepResult = deepResult.concat(quadkey.childrenByZoom(zoom))
-    }
-    return deepResult
-  }
-
-  public children() {
-    assertEx(this.zoom < MAX_ZOOM - 1, 'Can not get children of bottom tiles')
-    const result: Quadkey[] = []
-    const shiftedId = bitShiftLeft(bitShiftLeft(this.id))
-    for (let i = 0; i < 4; i++) {
-      const currentLastByte = shiftedId.readUInt8(shiftedId.length - 1)
-      shiftedId.writeUInt8((currentLastByte & 0xfc) | i, shiftedId.length - 1)
-      result.push(new Quadkey().setId(shiftedId).setZoom(this.zoom + 1))
-    }
-    return result
-  }
-
-  public siblings() {
-    const siblings = assertEx(this.parent()?.children(), `siblings: parentChildren ${this.toBase4Hash()}`)
-    const filteredSiblings = siblings.filter((quadkey) => this.compareTo(quadkey) !== 0)
-    assertEx(filteredSiblings.length === 3, `siblings: expected 3 [${filteredSiblings.length}]`)
-    return filteredSiblings
-  }
-
-  public clone() {
-    return Quadkey.fromBase10String(this.toBase10String())
-  }
-
-  public get zoom() {
-    return this.toBuffer().readUInt8(0)
+  setId(id: Buffer) {
+    this.setKey(this.zoom, id)
+    return this
   }
 
-  private _geoJson?: GeoJson
-
-  public geoJson() {
-    this._geoJson = this._geoJson ?? new GeoJson(this.toBase4Hash())
-    return this._geoJson
+  setKey(zoom: number, id: Buffer) {
+    id.copy(this.key, this.key.length - id.length)
+    this.key.writeUInt8(zoom, 0)
+    return this
   }
 
-  public setId(id: Buffer) {
-    this.setKey(this.zoom, id)
+  setZoom(zoom: number) {
+    assertEx(zoom < MAX_ZOOM, `Invalid zoom [${zoom}] max=${MAX_ZOOM}`)
+    this.setKey(zoom, this.id)
     return this
   }
 
-  public toTile(): MercatorTile {
-    return tileFromQuadkey(this.toBase4Hash())
+  /** @deprecated use .base10String*/
+  toBase10String() {
+    return this.base10String
   }
 
-  public toBoundingBox(): MercatorBoundingBox {
-    return tileToBoundingBox(this.toTile())
+  /** @deprecated use .base4Hash */
+  toBase4Hash() {
+    return this.base4Hash
   }
 
-  public toCenter() {
-    const result = boundingBoxToCenter(this.toBoundingBox())
-    return new LngLat(result[0], result[1])
+  /** @deprecated use .base4HashLabel */
+  toBase4HashLabel() {
+    const hash = this.base4HashLabel
+    return hash.length === 0 ? 'fhr' : hash
   }
 
-  public getGridLocation() {
-    const tileData = tileFromQuadkey(this.toBase4Hash())
-
-    return {
-      col: 2 ** tileData[2] - tileData[1] - 1,
-      row: tileData[0],
-      zoom: tileData[2],
-    }
+  /** @deprecated use .bigNumber */
+  toBigNumber() {
+    return this.bigNumber
   }
 
-  public valid() {
-    const zoom = this.zoom
-    const shift = (MAX_ZOOM - zoom) * 2
-    const id = this.id
-    let testId = id
-    for (let i = 0; i < shift; i++) {
-      testId = bitShiftLeft(testId)
-    }
-    for (let i = 0; i < shift; i++) {
-      testId = bitShiftRight(testId)
-    }
-    return testId.compare(id) === 0
+  /** @deprecated use .boundingBox */
+  toBoundingBox(): MercatorBoundingBox {
+    return this.boundingBox
   }
 
-  public get id() {
-    return this.toBuffer().slice(1)
+  /** @deprecated use .buffer */
+  toBuffer() {
+    return this.buffer
   }
 
-  public toBuffer() {
-    return this.key
+  /** @deprecated use .center */
+  toCenter() {
+    return this.center
   }
 
-  public toBigNumber() {
-    return new BigNumber(`${this.key.toString('hex')}`, 'hex')
+  /** @deprecated use .hex instead */
+  toHex() {
+    return this.hex
   }
 
-  public toString() {
-    return `0x${padHex(this.toBigNumber().toString(16))}`
+  toJSON(): string {
+    return this.base4HashLabel
   }
 
-  public toJSON(): string {
-    return this.toBase4HashLabel()
+  toShortString() {
+    const buffer = this.buffer
+    const part1 = buffer.slice(0, 2)
+    const part2 = buffer.slice(buffer.length - 2, buffer.length)
+    return `${part1.toString('hex')}...${part2.toString('hex')}`
   }
 
-  public toBase10String() {
-    return this.toBigNumber().toString(10)
+  toString() {
+    return `0x${padHex(this.bigNumber.toString(16))}`
   }
 
-  public toBase4HashLabel() {
-    const hash = this.toBase4Hash()
-    return hash.length === 0 ? 'fhr' : hash
+  /** @deprecated use .tile instead */
+  public toTile(): MercatorTile {
+    return this.tile
   }
 
   protected guessZoom() {
@@ -315,34 +393,4 @@ export class Quadkey {
     const quadkeySimple = bn.toString(4)
     this.setZoom(quadkeySimple.length)
   }
-
-  public toBase4Hash() {
-    const bn = new BigNumber(this.id.toString('hex'), 16)
-    const zoom = this.zoom
-    if (zoom === 0) {
-      return ''
-    }
-    let quadkeySimple = bn.toString(4)
-    while (quadkeySimple.length < zoom) {
-      quadkeySimple = `0${quadkeySimple}`
-    }
-    return quadkeySimple
-  }
-
-  public toHex() {
-    return `0x${this.key.toString('hex')}`
-  }
-
-  public toShortString() {
-    const buffer = this.toBuffer()
-    const part1 = buffer.slice(0, 2)
-    const part2 = buffer.slice(buffer.length - 2, buffer.length)
-    return `${part1.toString('hex')}...${part2.toString('hex')}`
-  }
-
-  public compareTo(quadkey: Quadkey) {
-    return this.toBigNumber().cmp(quadkey.toBigNumber())
-  }
-
-  public static Zero = Quadkey.from(0, Buffer.alloc(31, 0))
 }