@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/lang/duration-ratchet.js

@@ -1,42 +0,0 @@
-import { DateTime } from 'luxon';
-import { NumberRatchet } from './number-ratchet.js';
-export class DurationRatchet {
-    static formatMsDuration(ms, includeMS = false) {
-        const rem_ms = Math.floor(ms % 1000);
-        const seconds = Math.floor(ms / 1000) % 60;
-        const minutes = Math.floor(ms / (1000 * 60)) % 60;
-        const hours = Math.floor(ms / (1000 * 60 * 60)) % 24;
-        const days = Math.floor(ms / (1000 * 60 * 60 * 24));
-        const f = NumberRatchet.leadingZeros;
-        let rval = f(hours, 2) + 'h' + f(minutes, 2) + 'm';
-        rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) + 's' : f(seconds, 2) + 's';
-        if (days > 0) {
-            rval = days + 'd' + rval;
-        }
-        return rval;
-    }
-    static colonFormatMsDuration(ms, includeMS = false) {
-        const rem_ms = ms % 1000;
-        const seconds = Math.floor(ms / 1000) % 60;
-        const minutes = Math.floor(ms / (1000 * 60)) % 60;
-        const hours = Math.floor(ms / (1000 * 60 * 60));
-        const f = NumberRatchet.leadingZeros;
-        let rval = f(hours, 2) + ':' + f(minutes, 2) + ':';
-        rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) : f(seconds, 2);
-        return rval;
-    }
-    static daysBetween(d1, d2) {
-        const dur = DateTime.fromJSDate(d1).diff(DateTime.fromJSDate(d2));
-        return dur.days;
-    }
-    static createSteps(startEpochMS, endEpochMS, timezone, outputFormat, stepUnit) {
-        let curDate = DateTime.fromMillis(startEpochMS).setZone(timezone);
-        const endDate = DateTime.fromMillis(endEpochMS);
-        const rval = [];
-        while (curDate < endDate) {
-            rval.push(curDate.toFormat(outputFormat));
-            curDate = curDate.plus(stepUnit);
-        }
-        return rval;
-    }
-}

package/lib/lang/duration-ratchet.spec.js

@@ -1,39 +0,0 @@
-import { DurationRatchet } from './duration-ratchet.js';
-import { DateTime } from 'luxon';
-describe('#formatMsDuration', function () {
-    it('should format less than one second', function () {
-        const result = DurationRatchet.formatMsDuration(409, true);
-        expect(result).toEqual('00h00m00.409s');
-    });
-    it('should format more than one day', function () {
-        const result = DurationRatchet.formatMsDuration(1000 * 60 * 60 * 123, true);
-        expect(result).toEqual('5d03h00m00.000s');
-    });
-});
-describe('#colonFormatMsDuration', function () {
-    it('should format less than one second', function () {
-        const result = DurationRatchet.colonFormatMsDuration(409, true);
-        expect(result).toEqual('00:00:00.409');
-    });
-    it('should format more than ten hours', function () {
-        const result = DurationRatchet.colonFormatMsDuration(1000 * 60 * 60 * 11, false);
-        expect(result).toEqual('11:00:00');
-    });
-    it('should format more than one hundred hours', function () {
-        const result = DurationRatchet.colonFormatMsDuration(1000 * 60 * 60 * 123, false);
-        expect(result).toEqual('123:00:00');
-    });
-    it('should format 15 seconds', function () {
-        const result = DurationRatchet.colonFormatMsDuration(15000, false);
-        expect(result).toEqual('00:00:15');
-    });
-});
-describe('#createSteps', function () {
-    it('should create steps', function () {
-        const tt = DateTime.fromFormat('2019-01-01', 'yyyy-MM-dd');
-        const startEpochMS = DateTime.fromFormat('2019-01-01', 'yyyy-MM-dd').toJSDate().getTime();
-        const endEpochMS = DateTime.fromFormat('2019-01-05', 'yyyy-MM-dd').toJSDate().getTime();
-        const steps = DurationRatchet.createSteps(startEpochMS, endEpochMS, 'etc/GMT', 'yyyy-MM-dd', { days: 1 });
-        expect(steps.length).toEqual(4);
-    });
-});

package/lib/lang/enum-ratchet.js

@@ -1,30 +0,0 @@
-import { $enum } from 'ts-enum-util';
-import { StringRatchet } from './string-ratchet.js';
-export class EnumRatchet {
-    static listEnumKeys(enumeration) {
-        const rval = $enum(enumeration).getValues();
-        return rval;
-    }
-    static keyToEnum(enumeration, val, caseSensitive = false) {
-        const e = $enum(enumeration);
-        let rval = null;
-        if (!!val) {
-            rval = e.asValueOrDefault(val, null);
-            if (!rval && !caseSensitive) {
-                const keys = EnumRatchet.listEnumKeys(enumeration);
-                const mKey = keys.find((k) => k.toUpperCase() === val.toUpperCase());
-                if (!!mKey) {
-                    rval = e.asValueOrDefault(mKey, null);
-                }
-            }
-        }
-        return rval;
-    }
-    static parseCsvToEnumArray(enumeration, input) {
-        const split = StringRatchet.trimToEmpty(input)
-            .split(',')
-            .map((s) => s.trim());
-        const rval = split.map((s) => EnumRatchet.keyToEnum(enumeration, s)).filter((s) => !!s);
-        return rval;
-    }
-}

package/lib/lang/enum-ratchet.spec.js

@@ -1,31 +0,0 @@
-import { EnumRatchet } from './enum-ratchet.js';
-describe('#enumRatchet', function () {
-    it('should list keys', async () => {
-        const keys = EnumRatchet.listEnumKeys(TestEnum);
-        expect(keys).toBeTruthy();
-        expect(keys.length).toBeGreaterThan(1);
-    });
-    it('should find key case insensitive', async () => {
-        const t1 = EnumRatchet.keyToEnum(TestEnum, 'a');
-        const t2 = EnumRatchet.keyToEnum(TestEnum, 'b');
-        const t3 = EnumRatchet.keyToEnum(TestEnum, 'A', true);
-        const t4 = EnumRatchet.keyToEnum(TestEnum, 'A');
-        const fixed = TestEnum.A;
-        expect(t1).toBeTruthy();
-        expect(t2).toBeTruthy();
-        expect(t3).toBeNull();
-        expect(t4).toEqual(fixed);
-        expect(t4 === fixed).toBeTruthy();
-    });
-    it('should parse a csv of enums', async () => {
-        const vals = EnumRatchet.parseCsvToEnumArray(TestEnum, 'a, b');
-        expect(vals).toBeTruthy();
-        expect(vals.length).toEqual(2);
-    });
-});
-export var TestEnum;
-(function (TestEnum) {
-    TestEnum["A"] = "a";
-    TestEnum["B"] = "b";
-    TestEnum["C"] = "c";
-})(TestEnum || (TestEnum = {}));

package/lib/lang/error-ratchet.js

@@ -1,44 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import util from 'util';
-export class ErrorRatchet {
-    static safeStringifyErr(err, log = true) {
-        let rval = 'ERR WAS NULL';
-        if (err) {
-            if (err['message']) {
-                rval = err['message'];
-            }
-            else {
-                try {
-                    rval = JSON.stringify(err);
-                }
-                catch (err2) {
-                    Logger.error('Failed to json stringify');
-                    rval = String(err);
-                }
-            }
-        }
-        if (log) {
-            Logger.error('%s', rval, err);
-        }
-        return rval;
-    }
-    static asErr(input) {
-        let rval = null;
-        if (input) {
-            if (input instanceof Error) {
-                rval = input;
-            }
-            else {
-                rval = new Error('Force-Cast to error : ' + String(input));
-            }
-        }
-        return rval;
-    }
-    static fErr(format, ...input) {
-        const msg = util.format(format, ...input);
-        return new Error(msg);
-    }
-    static throwFormattedErr(format, ...input) {
-        throw ErrorRatchet.fErr(format, ...input);
-    }
-}

package/lib/lang/error-ratchet.spec.js

@@ -1,20 +0,0 @@
-import { ErrorRatchet } from './error-ratchet.js';
-describe('#errorRatchet', function () {
-    it('should cast to error', async () => {
-        const e1 = new Error('test1');
-        const e2 = 'test2';
-        const e1p = ErrorRatchet.asErr(e1);
-        const e2p = ErrorRatchet.asErr(e2);
-        const en = ErrorRatchet.asErr(null);
-        expect(en).toBeNull();
-        expect(e1p).toEqual(e1);
-        expect(e2p).not.toEqual(e2);
-        expect(e2p instanceof Error).toBeTruthy();
-    });
-    it('should correctly stringify', async () => {
-        const flag = 'test1';
-        const e1 = new Error(flag);
-        const out = ErrorRatchet.safeStringifyErr(e1);
-        expect(out).toEqual(flag);
-    });
-});

package/lib/lang/esm-ratchet.js

@@ -1,17 +0,0 @@
-import url from 'url';
-export class EsmRatchet {
-    static fetchDirName(root) {
-        if (!root) {
-            throw new Error('Need to provide root (should be import.meta.url)');
-        }
-        const rval = url.fileURLToPath(new URL('.', root));
-        return rval;
-    }
-    static fetchFileName(root) {
-        if (!root) {
-            throw new Error('Need to provide root (should be import.meta.url)');
-        }
-        const rval = url.fileURLToPath(root);
-        return rval;
-    }
-}

package/lib/lang/expiring-object.js

@@ -1,72 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { ErrorRatchet } from './error-ratchet.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-export class ExpiringObject {
-    _config;
-    _cacheObject;
-    _lastUpdatedEpochMS;
-    _timeRemainingMS;
-    constructor(inputConfig) {
-        this._config = Object.assign({}, this.defaultConfig(), inputConfig || {});
-        if (this._config.overrideTimeRemainingMS && this._config.timeToLiveMS) {
-            ErrorRatchet.throwFormattedErr('Cannot define both time to live and overrideTimeRemainingMS');
-        }
-        if (!this._config.overrideTimeRemainingMS && !this._config.timeToLiveMS) {
-            ErrorRatchet.throwFormattedErr('Must define exactly one of timeToLiveMS or overrideTimeRemainingMS');
-        }
-        if (this._config.initialValue) {
-            this.update(this._config.initialValue);
-        }
-        this._timeRemainingMS = this._config.overrideTimeRemainingMS || this.defaultTimeRemainingMS;
-    }
-    defaultConfig() {
-        const rval = {
-            generator: null,
-            initialValue: null,
-            logLevel: LoggerLevelName.debug,
-            overrideTimeRemainingMS: null,
-            timeToLiveMS: 1_000 * 60,
-        };
-        return rval;
-    }
-    async defaultTimeRemainingMS(lastUpdatedEpochMS) {
-        let rval = 0;
-        if (lastUpdatedEpochMS) {
-            const ageMS = new Date().getTime() - lastUpdatedEpochMS;
-            rval = Math.max(0, this._config.timeToLiveMS - ageMS);
-        }
-        return rval;
-    }
-    update(newValue, doNotUpdateClock = false) {
-        this._cacheObject = newValue;
-        if (!doNotUpdateClock) {
-            this._lastUpdatedEpochMS = new Date().getTime();
-        }
-        Logger.logByLevel(this._config.logLevel, 'Updated cache value to %j', newValue);
-    }
-    async fetchCacheObjectTimeRemainingMS() {
-        return this._timeRemainingMS(this._lastUpdatedEpochMS);
-    }
-    async fetch() {
-        const remainMS = await this._timeRemainingMS(this._lastUpdatedEpochMS);
-        if (!remainMS) {
-            this._cacheObject = null;
-            this._lastUpdatedEpochMS = null;
-        }
-        if (!this._cacheObject) {
-            if (this._config.generator) {
-                const newValue = await this._config.generator();
-                Logger.logByLevel(this._config.logLevel, 'Auto call to generator returned %j', newValue);
-                this.update(newValue);
-            }
-        }
-        return this._cacheObject;
-    }
-}
-export class ExpiringObjectConfig {
-    timeToLiveMS;
-    generator;
-    initialValue;
-    logLevel;
-    overrideTimeRemainingMS;
-}

package/lib/lang/expiring-object.spec.js

@@ -1,51 +0,0 @@
-import { ExpiringObject } from './expiring-object.js';
-import { PromiseRatchet } from './promise-ratchet.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-describe('#expiringObject', function () {
-    it('should default the object', async () => {
-        const expObject = new ExpiringObject({
-            initialValue: 7,
-            timeToLiveMS: 50_000,
-            logLevel: LoggerLevelName.info,
-        });
-        const val = await expObject.fetch();
-        expect(val).toEqual(7);
-    });
-    it('should expire the object', async () => {
-        const expObject = new ExpiringObject({
-            initialValue: 7,
-            timeToLiveMS: 100,
-            logLevel: LoggerLevelName.info,
-        });
-        const val = await expObject.fetch();
-        expect(val).toEqual(7);
-        await PromiseRatchet.wait(101);
-        const val2 = await expObject.fetch();
-        expect(val2).toBeNull();
-    });
-    it('should regen the object', async () => {
-        const expObject = new ExpiringObject({
-            initialValue: 7,
-            timeToLiveMS: 100,
-            generator: async () => 8,
-            logLevel: LoggerLevelName.info,
-        });
-        const val = await expObject.fetch();
-        expect(val).toEqual(7);
-        await PromiseRatchet.wait(101);
-        const val2 = await expObject.fetch();
-        expect(val2).toEqual(8);
-    });
-    it('should return time remaining', async () => {
-        const expObject = new ExpiringObject({
-            initialValue: 7,
-            timeToLiveMS: 10_000,
-            logLevel: LoggerLevelName.info,
-        });
-        const val = await expObject.fetch();
-        expect(val).toEqual(7);
-        const rem = await expObject.fetchCacheObjectTimeRemainingMS();
-        expect(rem).toBeGreaterThan(0);
-        expect(rem).toBeLessThanOrEqual(10_000);
-    });
-});

package/lib/lang/geolocation-ratchet.js

@@ -1,263 +0,0 @@
-import { RequireRatchet } from './require-ratchet.js';
-import { NumberRatchet } from './number-ratchet.js';
-import { ErrorRatchet } from './error-ratchet.js';
-import { Logger } from '../logger/logger.js';
-export class GeolocationRatchet {
-    constructor() { }
-    static distanceBetweenLocations(lat1, lon1, lat2, lon2, unit = 'M') {
-        const uU = !!unit ? unit.toUpperCase() : '';
-        if (['M', 'K', 'N', 'F', 'E'].indexOf(uU) === -1) {
-            throw new Error('Invalid unit');
-        }
-        if (lat1 == lat2 && lon1 == lon2) {
-            return 0;
-        }
-        else {
-            const radlat1 = (Math.PI * lat1) / 180;
-            const radlat2 = (Math.PI * lat2) / 180;
-            const theta = lon1 - lon2;
-            const radtheta = (Math.PI * theta) / 180;
-            let dist = Math.sin(radlat1) * Math.sin(radlat2) + Math.cos(radlat1) * Math.cos(radlat2) * Math.cos(radtheta);
-            if (dist > 1) {
-                dist = 1;
-            }
-            dist = Math.acos(dist);
-            dist = (dist * 180) / Math.PI;
-            dist = dist * 60 * 1.1515;
-            if (uU === 'F') {
-                dist *= 5280;
-            }
-            if (uU === 'K') {
-                dist *= 1.609344;
-            }
-            if (uU === 'E') {
-                dist *= 1609.344;
-            }
-            if (uU === 'N') {
-                dist *= 0.8684;
-            }
-            return dist;
-        }
-    }
-    static distanceBetweenRatchetGeoLocations(loc1, loc2, unit = 'M') {
-        return GeolocationRatchet.distanceBetweenLocations(loc1.lat, loc1.lng, loc2.lat, loc2.lng, unit);
-    }
-    static degreeOfLatLngInMiles(latitudeInDecimalDegress = 0) {
-        const latInRads = (latitudeInDecimalDegress * Math.PI) / 180;
-        const cosLat = Math.cos(latInRads);
-        const rval = NumberRatchet.safeNumber((cosLat * 69.172).toFixed(4));
-        return rval;
-    }
-    static milesInDegLatLng(miles, latitudeInDecimalDegress = 0) {
-        RequireRatchet.notNullOrUndefined(miles);
-        RequireRatchet.true(miles >= 0);
-        const degreeInMiles = GeolocationRatchet.degreeOfLatLngInMiles(latitudeInDecimalDegress);
-        return miles / degreeInMiles;
-    }
-    static centerOfBounds(bounds) {
-        RequireRatchet.notNullOrUndefined(bounds);
-        return {
-            lat: (bounds.extent.lat + bounds.origin.lat) / 2,
-            lng: (bounds.extent.lng + bounds.origin.lng) / 2,
-        };
-    }
-    static calculateSplits(input, slices, field) {
-        RequireRatchet.notNullOrUndefined(input);
-        RequireRatchet.notNullOrUndefined(slices);
-        RequireRatchet.notNullOrUndefined(field);
-        input.sort((a, b) => a.origin[field] - b.origin[field]);
-        const centers = input.map((i) => GeolocationRatchet.centerOfBounds(i));
-        const vals = centers.map((c) => c[field]);
-        const splits = [];
-        for (let i = 1; i < vals.length; i++) {
-            const size = vals[i] - vals[i - 1];
-            if (splits.length < slices) {
-                splits.push({ idx: i, size: size });
-                splits.sort((a, b) => a.size - b.size);
-            }
-            else if (size > splits[0].size) {
-                splits[0] = { idx: i, size: size };
-                splits.sort((a, b) => a.size - b.size);
-            }
-            else {
-                Logger.silly('Skipping, size : %d, %j', size, splits);
-            }
-        }
-        Logger.info('Splits at : %j', splits);
-        splits.sort((a, b) => a.idx - b.idx);
-        return splits;
-    }
-    static clusterGeoBounds(inputVal, latSlices = 2, lngSlices = 5) {
-        let rval = null;
-        if (latSlices * lngSlices < 2) {
-            ErrorRatchet.throwFormattedErr('Cannot set slices to less than 2 : %d x %d', latSlices, lngSlices);
-        }
-        if (!!inputVal) {
-            rval = [];
-            const input = Object.assign([], inputVal);
-            input.sort((a, b) => a.origin.lng - b.origin.lng);
-            const lngSplits = GeolocationRatchet.calculateSplits(inputVal, lngSlices - 1, 'lng');
-            lngSplits.sort((a, b) => a.idx - b.idx);
-            for (let i = 0; i <= lngSplits.length; i++) {
-                const lngStartIdx = i === 0 ? 0 : lngSplits[i - 1].idx;
-                const lngEndIdx = i === lngSplits.length ? input.length : lngSplits[i].idx;
-                const lngBatch = input.slice(lngStartIdx, lngEndIdx);
-                lngBatch.sort((a, b) => a.origin.lat - b.origin.lat);
-                const latSplits = GeolocationRatchet.calculateSplits(lngBatch, latSlices - 1, 'lat');
-                for (let j = 0; j <= latSplits.length; j++) {
-                    const latStartIdx = j == 0 ? 0 : latSplits[j - 1].idx;
-                    const latEndIdx = j === latSplits.length ? lngBatch.length : latSplits[j].idx;
-                    const latBatch = lngBatch.slice(latStartIdx, latEndIdx);
-                    rval.push(GeolocationRatchet.combineBounds(latBatch));
-                }
-            }
-            Logger.info('New bounds : %j', rval);
-        }
-        return rval;
-    }
-    static canonicalizeBounds(inp, allowCrossover = false) {
-        RequireRatchet.notNullOrUndefined(inp, 'RatchetLocationBounds');
-        const minLat = Math.min(inp.extent.lat, inp.origin.lat);
-        const maxLat = Math.max(inp.extent.lat, inp.origin.lat);
-        const minLng = Math.min(inp.extent.lng, inp.origin.lng);
-        const maxLng = Math.max(inp.extent.lng, inp.origin.lng);
-        const latXover = (minLat < 0 && maxLat > 0) || (minLat > 0 && maxLat < 0);
-        const lngXover = (minLat < 0 && maxLat > 0) || (minLat > 0 && maxLat < 0);
-        if (latXover || lngXover) {
-            if (allowCrossover) {
-                return inp;
-            }
-            else {
-                throw new Error('Cannot canonicalize, bounds crosses over boundary');
-            }
-        }
-        const rval = {
-            origin: {
-                lat: minLat,
-                lng: minLng,
-            },
-            extent: {
-                lat: maxLat,
-                lng: maxLng,
-            },
-        };
-        return rval;
-    }
-    static combineBounds(inp) {
-        let rval = null;
-        if (inp && inp.length > 0) {
-            rval = {
-                origin: {
-                    lat: inp.map((i) => i.origin.lat).reduce((a, i) => Math.min(a, i)),
-                    lng: inp.map((i) => i.origin.lng).reduce((a, i) => Math.min(a, i)),
-                },
-                extent: {
-                    lat: inp.map((i) => i.extent.lat).reduce((a, i) => Math.max(a, i)),
-                    lng: inp.map((i) => i.extent.lng).reduce((a, i) => Math.max(a, i)),
-                },
-            };
-        }
-        return rval;
-    }
-    static roundLocation(r, roundDigits) {
-        return {
-            lat: NumberRatchet.safeNumber(r.lat.toFixed(roundDigits)),
-            lng: NumberRatchet.safeNumber(r.lng.toFixed(roundDigits)),
-        };
-    }
-    static locationToBounds(loc, radiusMiles) {
-        const offset = GeolocationRatchet.milesInDegLatLng(radiusMiles, loc.lat);
-        const gfb = {
-            origin: {
-                lat: loc.lat - offset,
-                lng: loc.lng - offset,
-            },
-            extent: {
-                lat: loc.lat + offset,
-                lng: loc.lng + offset,
-            },
-        };
-        return gfb;
-    }
-    static sameLocation(loc1, loc2) {
-        return !!loc1 && !!loc2 && loc1.lat === loc2.lat && loc1.lng === loc2.lng;
-    }
-    static pointInBounds(pt, bound) {
-        return (!!pt &&
-            !!bound &&
-            NumberRatchet.between(pt.lat, bound.origin.lat, bound.extent.lat) &&
-            NumberRatchet.between(pt.lng, bound.origin.lng, bound.extent.lng));
-    }
-    static pointInAnyBound(pt, inBounds, minPointsBeforeMapping = 10) {
-        let rval = false;
-        if (inBounds.length > minPointsBeforeMapping) {
-            const mp = GeolocationRatchet.buildRatchetLocationBoundsMap(inBounds);
-            rval = GeolocationRatchet.pointInRatchetLocationBoundsMap(pt, mp);
-        }
-        else {
-            for (let i = 0; i < inBounds.length && !rval; i++) {
-                rval = GeolocationRatchet.pointInBounds(pt, inBounds[i]);
-            }
-        }
-        return rval;
-    }
-    static pointInRatchetLocationBoundsMap(pt, mp) {
-        let rval = false;
-        const entry = GeolocationRatchet.findRatchetLocationBoundsMapEntry(pt, mp);
-        if (!!entry) {
-            const bounds = entry.bounds;
-            for (let i = 0; i < bounds.length && !rval; i++) {
-                rval = GeolocationRatchet.pointInBounds(pt, bounds[i]);
-            }
-        }
-        return rval;
-    }
-    static findRatchetLocationBoundsMapEntry(pt, mp) {
-        let rval = null;
-        if (pt.lat >= mp.latOffset && pt.lat <= mp.maxLat && pt.lng >= mp.lngOffset && pt.lng <= mp.maxLng) {
-            const ltIdx = Math.trunc(pt.lat) - mp.latOffset;
-            const lngIdx = Math.trunc(pt.lng) - mp.lngOffset;
-            rval = mp.mapping[ltIdx][lngIdx];
-        }
-        return rval;
-    }
-    static buildRatchetLocationBoundsMap(inBounds) {
-        const minLat = inBounds.map((i) => i.origin.lat).reduce((a, i) => Math.min(a, i));
-        const minLng = inBounds.map((i) => i.origin.lng).reduce((a, i) => Math.min(a, i));
-        const maxLat = inBounds.map((i) => i.extent.lat).reduce((a, i) => Math.max(a, i));
-        const maxLng = inBounds.map((i) => i.extent.lng).reduce((a, i) => Math.max(a, i));
-        const latOffset = Math.trunc(minLat) - 1;
-        const lngOffset = Math.trunc(minLng) - 1;
-        const latEntries = Math.trunc(maxLat) - latOffset + 1;
-        const lngEntries = Math.trunc(maxLng) - lngOffset + 1;
-        const mapping = [];
-        for (let i = 0; i < latEntries; i++) {
-            const newRow = [];
-            for (let j = 0; j < lngEntries; j++) {
-                newRow.push({
-                    lat: latOffset + i,
-                    lng: lngOffset + j,
-                    bounds: [],
-                });
-            }
-            mapping.push(newRow);
-        }
-        inBounds.forEach((b) => {
-            for (let i = Math.trunc(b.origin.lat); i <= Math.trunc(b.extent.lat); i++) {
-                const latIdx = i - latOffset;
-                const row = mapping[latIdx];
-                for (let j = Math.trunc(b.origin.lng); j <= Math.trunc(b.extent.lng); j++) {
-                    const lngIdx = j - lngOffset;
-                    row[lngIdx].bounds.push(b);
-                }
-            }
-        });
-        return {
-            latOffset: latOffset,
-            lngOffset: lngOffset,
-            maxLat: latOffset + latEntries,
-            maxLng: lngOffset + lngEntries,
-            mapping: mapping,
-        };
-    }
-}