@bitblit/ratchet-common 4.0.80-alpha

package/dist/es/lang/base64-ratchet.js

@@ -0,0 +1,45 @@
+import { Logger } from '../logger/logger';
+export class Base64Ratchet {
+    static safeObjectToBase64JSON(input) {
+        return !!input ? Base64Ratchet.generateBase64VersionOfString(JSON.stringify(input)) : null;
+    }
+    static safeBase64JSONParse(input) {
+        let rval = {};
+        try {
+            if (input) {
+                rval = JSON.parse(Base64Ratchet.base64StringToString(input));
+            }
+        }
+        catch (err) {
+            Logger.warn('Error parsing b64/json : %s as json, got %s', input, err, err);
+            rval = {};
+        }
+        return rval;
+    }
+    static generateBase64VersionOfBlob(blob) {
+        return new Promise(function (resolve, reject) {
+            if (!blob || blob.size == 0) {
+                reject('Wont convert null or non-blob or empty blob');
+            }
+            else {
+                const reader = new FileReader();
+                reader.onloadend = function () {
+                    resolve(reader.result.toString());
+                };
+                reader.readAsDataURL(blob);
+            }
+        });
+    }
+    static generateBase64VersionOfString(input) {
+        return Base64Ratchet.generateBase64VersionOfBuffer(Buffer.from(input));
+    }
+    static generateBase64VersionOfBuffer(input) {
+        return input.toString('base64');
+    }
+    static base64StringToBuffer(input) {
+        return Buffer.from(input, 'base64');
+    }
+    static base64StringToString(input, encoding = 'utf8') {
+        return Buffer.from(input, 'base64').toString(encoding);
+    }
+}

package/dist/es/lang/boolean-ratchet.js

@@ -0,0 +1,45 @@
+import { NumberRatchet } from './number-ratchet';
+export class BooleanRatchet {
+    static allTrue(vals, emptyArraysReturn = false) {
+        let rval = null;
+        if (!!vals) {
+            if (vals.length > 0) {
+                rval = vals.reduce((a, i) => a && i, true);
+            }
+            else {
+                rval = emptyArraysReturn;
+            }
+        }
+        else {
+            rval = false;
+        }
+        return rval;
+    }
+    static anyTrue(vals, emptyArraysReturn = false) {
+        let rval = null;
+        if (!!vals) {
+            if (vals.length > 0) {
+                rval = vals.reduce((a, i) => a || i, false);
+            }
+            else {
+                rval = emptyArraysReturn;
+            }
+        }
+        else {
+            rval = false;
+        }
+        return rval;
+    }
+    static parseBool(val) {
+        return val === true || (val !== null && val !== undefined && typeof val === 'string' && val.toLowerCase() === 'true');
+    }
+    static intToBool(val) {
+        if (val === null || val === undefined) {
+            return false;
+        }
+        return NumberRatchet.safeNumber(val) !== 0;
+    }
+    static boolToInt(val) {
+        return BooleanRatchet.parseBool(val) ? 1 : 0;
+    }
+}

package/dist/es/lang/composite-last-success-provider.js

@@ -0,0 +1,24 @@
+export class CompositeLastSuccessProvider {
+    constructor(src, mostRecentSrc = true) {
+        if (!src || src.length == 0) {
+            throw Error('Cannot create composite provider with null/empty sources');
+        }
+        this.sources = src;
+        this.mostRecent = mostRecentSrc;
+    }
+    lastSuccess() {
+        let rval = null;
+        this.sources.forEach((s) => {
+            const val = s.lastSuccess();
+            if (val != null) {
+                if (rval == null) {
+                    rval = val;
+                }
+                else {
+                    rval = (val > rval && this.mostRecent) || (val < rval && !this.mostRecent) ? val : rval;
+                }
+            }
+        });
+        return rval;
+    }
+}

package/dist/es/lang/date-ratchet.js

@@ -0,0 +1,29 @@
+import { DateTime } from 'luxon';
+export class DateRatchet {
+    static formatFullDate(input) {
+        return DateTime.fromJSDate(input).toFormat(DateRatchet.FULL_DATE_FORMAT);
+    }
+    static formatDefaultDateOnly(input) {
+        return DateTime.fromJSDate(input).toFormat(DateRatchet.DEFAULT_DATE_FORMAT);
+    }
+    static parseDefaultDate(input) {
+        const rval = DateTime.fromFormat(input, DateRatchet.DEFAULT_DATE_FORMAT).toJSDate();
+        return rval;
+    }
+    static parseCommonUsDate(input) {
+        let rval = null;
+        if (!!input) {
+            let templ = DateRatchet.COMMON_US_DATE_FORMAT;
+            if (input.indexOf('-') === 2) {
+                templ = templ.split('/').join('-');
+            }
+            rval = DateTime.fromFormat(input, templ).toJSDate();
+        }
+        return rval;
+    }
+}
+DateRatchet.COMMON_US_DATE_FORMAT = 'MM/dd/yyyy';
+DateRatchet.DEFAULT_DATE_FORMAT = 'yyyy-MM-dd';
+DateRatchet.FULL_DATE_FORMAT = 'yyyy-MM-dd_HH_mm_ss';
+DateRatchet.PACIFIC_TIME_ZONE = 'America/Los_Angeles';
+DateRatchet.UTC_TIME_ZONE = 'etc/UTC';

package/dist/es/lang/duration-ratchet.js

@@ -0,0 +1,42 @@
+import { DateTime } from 'luxon';
+import { NumberRatchet } from './number-ratchet';
+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/dist/es/lang/enum-ratchet.js

@@ -0,0 +1,30 @@
+import { $enum } from 'ts-enum-util';
+import { StringRatchet } from './string-ratchet';
+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/dist/es/lang/error-ratchet.js

@@ -0,0 +1,44 @@
+import { Logger } from '../logger/logger';
+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/dist/es/lang/expiring-object.js

@@ -0,0 +1,63 @@
+import { Logger } from '../logger/logger';
+import { ErrorRatchet } from './error-ratchet';
+import { LoggerLevelName } from '../logger/logger-level-name';
+export class ExpiringObject {
+    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: 1000 * 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 {
+}

package/dist/es/lang/geolocation-ratchet.js

@@ -0,0 +1,263 @@
+import { RequireRatchet } from './require-ratchet';
+import { NumberRatchet } from './number-ratchet';
+import { ErrorRatchet } from './error-ratchet';
+import { Logger } from '../logger/logger';
+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,
+        };
+    }
+}

package/dist/es/lang/global-ratchet.js

@@ -0,0 +1,43 @@
+import { ErrorRatchet } from './error-ratchet';
+import { RequireRatchet } from './require-ratchet';
+import { Logger } from '../logger/logger';
+export class GlobalRatchet {
+    constructor() { }
+    static fetchGlobalRecord(returnNullOnNone) {
+        let rval = null;
+        if (process?.env) {
+            Logger.silly('Using process.env as global');
+            rval = process.env;
+        }
+        else if (global?.process?.env) {
+            Logger.silly('Using global.process.env as global');
+            rval = global.process.env;
+        }
+        else if (global) {
+            Logger.silly('Using process.env as global');
+            rval = global;
+        }
+        if (!rval) {
+            if (returnNullOnNone) {
+                Logger.silly('Returning null as global');
+                rval = null;
+            }
+            else {
+                throw ErrorRatchet.fErr('Could not find process.env OR global in scope');
+            }
+        }
+        return rval;
+    }
+    static fetchGlobalVar(envVar) {
+        RequireRatchet.notNullOrUndefined(envVar, 'envVar');
+        const myGlobal = GlobalRatchet.fetchGlobalRecord();
+        const value = myGlobal[envVar];
+        return value;
+    }
+    static setGlobalVar(envVar, value) {
+        RequireRatchet.notNullOrUndefined(envVar, 'envVar');
+        RequireRatchet.notNullOrUndefined(value, 'value');
+        const myGlobal = GlobalRatchet.fetchGlobalRecord();
+        myGlobal[envVar] = value;
+    }
+}

package/dist/es/lang/key-value.js

@@ -0,0 +1,2 @@
+export class KeyValue {
+}

package/dist/es/lang/last-success-provider.js

@@ -0,0 +1 @@
+export {};