@bitblit/ratchet-common 4.0.1-alpha

package/lib/jwt/common-jwt-token.d.ts

@@ -0,0 +1,6 @@
+import { JwtTokenBase } from './jwt-token-base.js';
+export interface CommonJwtToken<T> extends JwtTokenBase {
+    user: T;
+    proxy: T;
+    roles: string[];
+}

package/lib/jwt/expired-jwt-handling.d.ts

@@ -0,0 +1,5 @@
+export declare enum ExpiredJwtHandling {
+    RETURN_NULL = 0,
+    THROW_EXCEPTION = 1,
+    ADD_FLAG = 2
+}

package/lib/jwt/jwt-ratchet-like.d.ts

@@ -0,0 +1,15 @@
+import { JwtTokenBase } from './jwt-token-base.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { ExpiredJwtHandling } from './expired-jwt-handling.js';
+export interface JwtRatchetLike {
+    get encryptionKeyPromise(): Promise<string | string[]>;
+    get decryptKeysPromise(): Promise<string[]>;
+    get jtiGenerator(): () => string;
+    get decryptOnlyKeyUseLogLevel(): LoggerLevelName;
+    get parseFailureLogLevel(): LoggerLevelName;
+    decodeToken<T extends JwtTokenBase>(payloadString: string, expiredHandling?: ExpiredJwtHandling): Promise<T>;
+    encryptionKeyArray(): Promise<string[]>;
+    selectRandomEncryptionKey(): Promise<string>;
+    createTokenString(payload: any, expirationSeconds?: number, overrideEncryptionKey?: string): Promise<string>;
+    refreshJWTString(tokenString: string, allowExpired?: boolean, expirationSeconds?: number): Promise<string>;
+}

package/lib/jwt/jwt-ratchet.d.ts

@@ -0,0 +1,30 @@
+import { JwtTokenBase } from './jwt-token-base.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { ExpiredJwtHandling } from './expired-jwt-handling.js';
+import { JwtRatchetLike } from './jwt-ratchet-like.js';
+export declare class JwtRatchet implements JwtRatchetLike {
+    private _encryptionKeyPromise;
+    private _decryptKeysPromise?;
+    private _jtiGenerator;
+    private _decryptOnlyKeyUseLogLevel;
+    private _parseFailureLogLevel;
+    private static readonly EXPIRED_FLAG_NAME;
+    constructor(_encryptionKeyPromise: Promise<string | string[]>, _decryptKeysPromise?: Promise<string[]>, _jtiGenerator?: () => string, _decryptOnlyKeyUseLogLevel?: LoggerLevelName, _parseFailureLogLevel?: LoggerLevelName);
+    get encryptionKeyPromise(): Promise<string | string[]>;
+    get decryptKeysPromise(): Promise<string[]>;
+    get jtiGenerator(): () => string;
+    get decryptOnlyKeyUseLogLevel(): LoggerLevelName;
+    get parseFailureLogLevel(): LoggerLevelName;
+    static hasExpiredFlag(ob: any): boolean;
+    static invalidSafeDecode<T>(payloadString: string, decryptKey: string, logLevel?: LoggerLevelName): Promise<T>;
+    static secondsRemainingUntilExpiration(payloadString: string): Promise<number>;
+    static msRemainingUntilExpiration(payloadString: string): Promise<number>;
+    decodeToken<T extends JwtTokenBase>(payloadString: string, expiredHandling?: ExpiredJwtHandling): Promise<T>;
+    encryptionKeyArray(): Promise<string[]>;
+    selectRandomEncryptionKey(): Promise<string>;
+    createTokenString(payload: any, expirationSeconds?: number, overrideEncryptionKey?: string): Promise<string>;
+    refreshJWTString(tokenString: string, allowExpired?: boolean, expirationSeconds?: number): Promise<string>;
+    static decodeTokenNoVerify<T extends JwtTokenBase>(token: string): T;
+    static removeJwtFields(ob: any): void;
+    static removeExpiredFlag(ob: any): void;
+}

package/lib/jwt/jwt-ratchet.spec.d.ts

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

package/lib/jwt/jwt-token-base.d.ts

@@ -0,0 +1,9 @@
+export interface JwtTokenBase {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}

package/lib/lang/array-ratchet.d.ts

@@ -0,0 +1,14 @@
+export declare class ArrayRatchet {
+    static wrapElementsInArray(input: any[]): any[][];
+    static compareTwoArrays<T>(ar1: T[], ar2: T[], fn: ComparisonFunction<T>): MatchReport<T>;
+    static extractSubarrayFromSortedByNumberField<T>(input: T[], fieldDotPath: string, minInclusive: number, maxExclusive: number): T[];
+    static findSplit(input: any[], fieldDotPath: string, target: number): number;
+}
+export interface ComparisonFunction<T> {
+    (t1: T, t2: T): number;
+}
+export interface MatchReport<T> {
+    matching: T[];
+    setOneOnly: T[];
+    setTwoOnly: T[];
+}

package/lib/lang/array-ratchet.spec.d.ts

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

package/lib/lang/base64-ratchet.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+export declare class Base64Ratchet {
+    static safeObjectToBase64JSON(input: any): any;
+    static safeBase64JSONParse(input: string): any;
+    static generateBase64VersionOfBlob(blob: Blob): Promise<string>;
+    static generateBase64VersionOfString(input: string): string;
+    static generateBase64VersionOfBuffer(input: Buffer): string;
+    static base64StringToBuffer(input: string): Buffer;
+    static base64StringToString(input: string, encoding?: BufferEncoding): string;
+}

package/lib/lang/base64-ratchet.spec.d.ts

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

package/lib/lang/boolean-ratchet.d.ts

@@ -0,0 +1,7 @@
+export declare class BooleanRatchet {
+    static allTrue(vals: boolean[], emptyArraysReturn?: boolean): boolean;
+    static anyTrue(vals: boolean[], emptyArraysReturn?: boolean): boolean;
+    static parseBool(val: any): boolean;
+    static intToBool(val: any): boolean;
+    static boolToInt(val: any): number;
+}

package/lib/lang/boolean-ratchet.spec.d.ts

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

package/lib/lang/composite-last-success-provider.d.ts

@@ -0,0 +1,7 @@
+import { LastSuccessProvider } from './last-success-provider.js';
+export declare class CompositeLastSuccessProvider implements LastSuccessProvider {
+    private sources;
+    private mostRecent;
+    constructor(src: LastSuccessProvider[], mostRecentSrc?: boolean);
+    lastSuccess(): number;
+}

package/lib/lang/composite-last-success-provider.spec.d.ts

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

package/lib/lang/date-ratchet.d.ts

@@ -0,0 +1,11 @@
+export declare class DateRatchet {
+    static COMMON_US_DATE_FORMAT: string;
+    static DEFAULT_DATE_FORMAT: string;
+    static FULL_DATE_FORMAT: string;
+    static PACIFIC_TIME_ZONE: string;
+    static UTC_TIME_ZONE: string;
+    static formatFullDate(input: Date): string;
+    static formatDefaultDateOnly(input: Date): string;
+    static parseDefaultDate(input: string): Date;
+    static parseCommonUsDate(input: string): Date;
+}

package/lib/lang/date-ratchet.spec.d.ts

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

package/lib/lang/duration-ratchet.d.ts

@@ -0,0 +1,7 @@
+import { DurationLike } from 'luxon';
+export declare class DurationRatchet {
+    static formatMsDuration(ms: number, includeMS?: boolean): string;
+    static colonFormatMsDuration(ms: number, includeMS?: boolean): string;
+    static daysBetween(d1: Date, d2: Date): number;
+    static createSteps(startEpochMS: number, endEpochMS: number, timezone: string, outputFormat: string, stepUnit: DurationLike): string[];
+}

package/lib/lang/duration-ratchet.spec.d.ts

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

package/lib/lang/enum-ratchet.d.ts

@@ -0,0 +1,5 @@
+export declare class EnumRatchet {
+    static listEnumKeys(enumeration: any): string[];
+    static keyToEnum<T>(enumeration: any, val: string, caseSensitive?: boolean): T;
+    static parseCsvToEnumArray<T>(enumeration: any, input: string): T[];
+}

package/lib/lang/enum-ratchet.spec.d.ts

@@ -0,0 +1,5 @@
+export declare enum TestEnum {
+    A = "a",
+    B = "b",
+    C = "c"
+}

package/lib/lang/error-ratchet.d.ts

@@ -0,0 +1,6 @@
+export declare class ErrorRatchet {
+    static safeStringifyErr(err: any, log?: boolean): string;
+    static asErr(input: any): Error;
+    static fErr(format: string, ...input: any[]): Error;
+    static throwFormattedErr(format: string, ...input: any[]): Error;
+}

package/lib/lang/error-ratchet.spec.d.ts

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

package/lib/lang/esm-ratchet.d.ts

@@ -0,0 +1,4 @@
+export declare class EsmRatchet {
+    static fetchDirName(root: string): string;
+    static fetchFileName(root: string): string;
+}

package/lib/lang/expiring-object.d.ts

@@ -0,0 +1,20 @@
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+export declare class ExpiringObject<T> {
+    private _config;
+    private _cacheObject;
+    private _lastUpdatedEpochMS;
+    private _timeRemainingMS;
+    constructor(inputConfig?: ExpiringObjectConfig<T>);
+    private defaultConfig;
+    private defaultTimeRemainingMS;
+    update(newValue: T, doNotUpdateClock?: boolean): void;
+    fetchCacheObjectTimeRemainingMS(): Promise<number>;
+    fetch(): Promise<T>;
+}
+export declare class ExpiringObjectConfig<T> {
+    timeToLiveMS?: number;
+    generator?: () => Promise<T>;
+    initialValue?: T;
+    logLevel?: LoggerLevelName;
+    overrideTimeRemainingMS?: (lastUpdatedEpochMS: number) => Promise<number>;
+}

package/lib/lang/expiring-object.spec.d.ts

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

package/lib/lang/geolocation-ratchet.d.ts

@@ -0,0 +1,40 @@
+export declare class GeolocationRatchet {
+    private constructor();
+    static distanceBetweenLocations(lat1: number, lon1: number, lat2: number, lon2: number, unit?: string): number;
+    static distanceBetweenRatchetGeoLocations(loc1: RatchetGeoLocation, loc2: RatchetGeoLocation, unit?: string): number;
+    static degreeOfLatLngInMiles(latitudeInDecimalDegress?: number): number;
+    static milesInDegLatLng(miles: number, latitudeInDecimalDegress?: number): number;
+    static centerOfBounds(bounds: RatchetLocationBounds): RatchetGeoLocation;
+    private static calculateSplits;
+    static clusterGeoBounds(inputVal: RatchetLocationBounds[], latSlices?: number, lngSlices?: number): RatchetLocationBounds[];
+    static canonicalizeBounds(inp: RatchetLocationBounds, allowCrossover?: boolean): RatchetLocationBounds;
+    static combineBounds(inp: RatchetLocationBounds[]): RatchetLocationBounds;
+    static roundLocation(r: RatchetGeoLocation, roundDigits: number): RatchetGeoLocation;
+    static locationToBounds(loc: RatchetGeoLocation, radiusMiles: number): RatchetLocationBounds;
+    static sameLocation(loc1: RatchetGeoLocation, loc2: RatchetGeoLocation): boolean;
+    static pointInBounds(pt: RatchetGeoLocation, bound: RatchetLocationBounds): boolean;
+    static pointInAnyBound(pt: RatchetGeoLocation, inBounds: RatchetLocationBounds[], minPointsBeforeMapping?: number): boolean;
+    static pointInRatchetLocationBoundsMap(pt: RatchetGeoLocation, mp: RatchetLocationBoundsMap): boolean;
+    static findRatchetLocationBoundsMapEntry(pt: RatchetGeoLocation, mp: RatchetLocationBoundsMap): RatchetLocationBoundsMapEntry;
+    static buildRatchetLocationBoundsMap(inBounds: RatchetLocationBounds[]): RatchetLocationBoundsMap;
+}
+export interface RatchetGeoLocation {
+    lat: number;
+    lng: number;
+}
+export interface RatchetLocationBounds {
+    origin: RatchetGeoLocation;
+    extent: RatchetGeoLocation;
+}
+export interface RatchetLocationBoundsMap {
+    latOffset: number;
+    lngOffset: number;
+    maxLat: number;
+    maxLng: number;
+    mapping: RatchetLocationBoundsMapEntry[][];
+}
+export interface RatchetLocationBoundsMapEntry {
+    lat: number;
+    lng: number;
+    bounds: RatchetLocationBounds[];
+}

package/lib/lang/geolocation-ratchet.spec.d.ts

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

package/lib/lang/global-ratchet.d.ts

@@ -0,0 +1,6 @@
+export declare class GlobalRatchet {
+    private constructor();
+    static fetchGlobalRecord(returnNullOnNone?: boolean): Record<string, any>;
+    static fetchGlobalVar(envVar: string): string;
+    static setGlobalVar(envVar: string, value: string): void;
+}

package/lib/lang/global-ratchet.spec.d.ts

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

package/lib/lang/key-value.d.ts

@@ -0,0 +1,4 @@
+export declare class KeyValue {
+    key: string;
+    value: any;
+}

package/lib/lang/last-success-provider.d.ts

@@ -0,0 +1,3 @@
+export interface LastSuccessProvider {
+    lastSuccess(): number;
+}

package/lib/lang/map-ratchet.d.ts

@@ -0,0 +1,15 @@
+import { KeyValue } from './key-value.js';
+export declare class MapRatchet {
+    static expandNestedKeys<T>(src: any): T;
+    static mapByUniqueProperty<T, R>(input: T[], propName: string): Map<R, T>;
+    static groupByProperty<T, R>(input: T[], propName: string): Map<R, T[]>;
+    static findValue(toSearch: any, path: string[]): any;
+    static findValueDotPath(toSearch: any, dotPath: string): any;
+    static simpleDeepCompare(object1: any, object2: any): boolean;
+    static toKeyValueList(value: any): KeyValue[];
+    static fromKeyValueList(list: KeyValue[]): any;
+    static cleanup<T>(obj: T, stripZero?: boolean, stripNull?: boolean, stripUndefined?: boolean, stripEmptyString?: boolean): T;
+    static extractValueFromMapIgnoreCase(src: any, key: string): any;
+    static safeCallFunction(ob: any, fnName: string): boolean;
+    static caseInsensitiveAccess<T>(ob: any, keyName: string): T;
+}

package/lib/lang/map-ratchet.spec.d.ts

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

package/lib/lang/no.d.ts

@@ -0,0 +1,3 @@
+export declare class No {
+    static op(...args: any[]): void;
+}

package/lib/lang/no.spec.d.ts

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

package/lib/lang/number-ratchet.d.ts

@@ -0,0 +1,20 @@
+export declare class NumberRatchet {
+    private static MAX_LEADING_ZEROS_FORMAT_LENGTH;
+    static toFixedDecimalNumber(input: number | string, placesAfterPoint: number): number;
+    static leadingZeros(val: any, size: number): string;
+    static between(inTest: number, inP1: number, inP2: number): boolean;
+    static safeNumber(input: any, ifNotNumber?: number, useDefaultForNullAndUndefined?: boolean): number;
+    static numberCSVToList(inputCSV: string): number[];
+    static fitToWindow(val: number, b1: number, b2: number): number;
+    static groupNumbersIntoContiguousRanges(inputData: number[], minRangeSize?: number): SinglesAndRanges;
+    static distributeItemsEvenly(items: number, buckets: number): number[];
+    static createRange(minInclusive: number, maxExclusive: number, step?: number): number[];
+}
+export interface SinglesAndRanges {
+    singles: number[];
+    ranges: NumberRange[];
+}
+export interface NumberRange {
+    min: number;
+    max: number;
+}

package/lib/lang/number-ratchet.spec.d.ts

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

package/lib/lang/parsed-url.d.ts

@@ -0,0 +1,10 @@
+export interface ParsedUrl {
+    href: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}

package/lib/lang/promise-ratchet.d.ts

@@ -0,0 +1,18 @@
+import { TimeoutToken } from './timeout-token.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+export declare class PromiseRatchet {
+    static resolveOnEvent<T>(evtSrc: any, okEvtNames: string[], errEvtNames?: string[], rval?: T): Promise<T>;
+    static timeout<T>(srcPromise: Promise<T>, title: string, timeoutMS: number): Promise<T | TimeoutToken>;
+    static createTimeoutPromise(title: string, timeoutMS: number): Promise<TimeoutToken>;
+    static wait(time: number): Promise<void>;
+    static dumpResult(result: any, autoDebug?: boolean): void;
+    static dumpError(err: any, autoDebug?: boolean): void;
+    static logErrorAndReturnNull(err: any, autoDebug?: boolean): void;
+    static runPromiseAndDump<T>(promise: Promise<T>): void;
+    static waitFor(testFunction: (n: number) => any, expectedValue: any, intervalMS: number, maxCycles: number, label?: string, count?: number): Promise<boolean>;
+    static runBoundedParallel<T>(promiseFn: Function, params: any[][], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static runBoundedParallelSingleParam<T>(promiseFn: Function, params: any[], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static asyncForEachSerial(array: any[], callback: Function): Promise<void>;
+    static asyncForEachParallel(array: any[], callback: Function): Promise<void>;
+    private constructor();
+}

package/lib/lang/promise-ratchet.spec.d.ts

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

package/lib/lang/require-ratchet.d.ts

@@ -0,0 +1,11 @@
+export declare class RequireRatchet {
+    static isNullOrUndefined(ob: any): boolean;
+    static notNullOrUndefined(ob: any, name?: string): void;
+    static notNullUndefinedOrOnlyWhitespaceString(ob: string, name?: string): void;
+    static notNullUndefinedOrEmptyArray(ob: any[], name?: string): void;
+    static equal(ob1: any, ob2: any, message?: string): void;
+    static true(ob: boolean, message?: string): void;
+    static noNullOrUndefinedValuesInArray(arr: any[], expectedLength?: number, customMsg?: string): void;
+    static noNullOrUndefinedValuesInRestArgs(expectedLength: number, ...restArgs: any[]): void;
+    static constructorArgumentsMatchLengthAndAreNonNull(): void;
+}

package/lib/lang/require-ratchet.spec.d.ts

@@ -0,0 +1,3 @@
+export declare class ConstructorTester {
+    constructor(testVal1: string, testVal2: string);
+}

package/lib/lang/stop-watch.d.ts

@@ -0,0 +1,17 @@
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+export declare class StopWatch {
+    private label;
+    private starts;
+    private ends;
+    private createTime;
+    constructor(label?: string);
+    start(name: string): number;
+    stop(name: string): number;
+    reset(name: string): void;
+    hasTimer(name: string): boolean;
+    log(name?: string, shortForm?: boolean, logLevel?: LoggerLevelName): void;
+    logExpected(pctComplete: number, name?: string, shortForm?: boolean, logLevel?: LoggerLevelName): void;
+    dump(name?: string, shortForm?: boolean): string;
+    dumpExpected(pctComplete: number, name?: string, shortForm?: boolean): string;
+    elapsedMS(name?: string): number;
+}

package/lib/lang/string-ratchet.d.ts

@@ -0,0 +1,28 @@
+export declare class StringRatchet {
+    static RFC_3986_RESERVED: string[];
+    static stringToUint8Array(val: string): Uint8Array;
+    static uint8ArrayToString(val: Uint8Array): string;
+    static attemptJsonParse(val: string): any;
+    static canParseAsJson(val: string): boolean;
+    static allUnique(input: string): boolean;
+    static allPermutationsOfLength(len: number, alphabet: string): string[];
+    static createType4Guid(): string;
+    static createRandomHexString(len?: number): string;
+    static canonicalize(value: string): string;
+    static formatBytes(bytes: number, decimals?: number): string;
+    static safeString(input: any): string;
+    static stringContainsOnlyNumbers(input: string): boolean;
+    static stringContainsOnlyAlphanumeric(input: string): boolean;
+    static stringContainsOnlyHex(input: string): boolean;
+    static stringContainsOnly(inVal: string, validCharsIn: string): boolean;
+    static obscure(input: string, prefixLength?: number, suffixLength?: number): string;
+    static leadingZeros(inVal: any, size: number): string;
+    static trimToEmpty(input: string): string;
+    static trimToNull(input: string): string;
+    static trimAllStringPropertiesToNullInPlace<T>(input: T): T;
+    static trimAllStringPropertiesToEmptyInPlace<T>(input: T): T;
+    private static trimAllStringPropertiesInPlace;
+    static stripNonNumeric(input: string): string;
+    static csvSafe(input: any): string;
+    static stripNonAscii(value: string): string;
+}

package/lib/lang/string-ratchet.spec.d.ts

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

package/lib/lang/time-zone-ratchet.d.ts

@@ -0,0 +1,19 @@
+export declare class TimeZoneRatchet {
+    static PACIFIC: TimeZoneRatchet;
+    private timezone;
+    constructor(timezone: string);
+    currentHour(): number;
+    private toEpochSeconds;
+    startOfTodayEpochSeconds(): number;
+    startOfMatchingDayEpochSeconds(inputTS: number): number;
+    startOfMatchingDayEpochMS(inputTS: number): number;
+    startOfCurrentHourEpochSeconds(): number;
+    startOfCurrentMinuteEpochSeconds(): number;
+    startOfCurrentSecondEpochSeconds(): number;
+    startOfTodayEpochMS(): number;
+    dailySlotCount(slotWidthMs: number): number;
+    currentTimeSlotIdx(slotWidthMs: number): number;
+    matchingTimeSlotIdx(timestamp: number, slotWidthMs: number): number;
+    startOfCurrentSlotEpochMS(slotWidthMs: number): number;
+    startOfMatchingSlotEpochMS(timestamp: number, slotWidthMs: number): number;
+}

package/lib/lang/time-zone-ratchet.spec.d.ts

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

package/lib/lang/timeout-token.d.ts

@@ -0,0 +1,9 @@
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+export declare class TimeoutToken {
+    private title;
+    private timeoutMS;
+    private __timeoutTokenFlagField;
+    constructor(title: string, timeoutMS: number);
+    writeToLog(logLevel?: LoggerLevelName): void;
+    static isTimeoutToken(value: any): boolean;
+}

package/lib/lang/timeout-token.spec.d.ts

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

package/lib/lang/transform-ratchet.d.ts

@@ -0,0 +1,7 @@
+import { TransformRule } from '../transform/transform-rule.js';
+export declare class TransformRatchet {
+    static transform(toTransform: any, rules?: TransformRule[]): any;
+    private static transformGeneric;
+    private static applyTransformToObject;
+    private static applyTransformToPrimitive;
+}

package/lib/lang/transform-ratchet.spec.d.ts

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

package/lib/logger/classic-single-line-log-message-formatter.d.ts

@@ -0,0 +1,6 @@
+import { LogMessage } from './log-message.js';
+import { LogMessageFormatter } from './log-message-formatter.js';
+import { LoggerMeta } from './logger-meta.js';
+export declare class ClassicSingleLineLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}

package/lib/logger/log-message-builder.d.ts

@@ -0,0 +1,14 @@
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessage } from './log-message.js';
+export declare class LogMessageBuilder {
+    private wrapped;
+    constructor(lvl: LoggerLevelName, messageSource?: string);
+    clone(): LogMessageBuilder;
+    level(lvl: LoggerLevelName): LogMessageBuilder;
+    timestamp(val: number): LogMessageBuilder;
+    messageSource(val: string): LogMessageBuilder;
+    subVars(val: any[]): LogMessageBuilder;
+    params(val: Record<string, string | number | boolean>): LogMessageBuilder;
+    p(name: string, value: string | number | boolean): LogMessageBuilder;
+    toMessage(): LogMessage;
+}

package/lib/logger/log-message-format-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum LogMessageFormatType {
+    ClassicSingleLine = "ClassicSingleLine",
+    StructuredJson = "StructuredJson",
+    None = "None"
+}

package/lib/logger/log-message-formatter.d.ts

@@ -0,0 +1,5 @@
+import { LogMessage } from './log-message.js';
+import { LoggerMeta } from './logger-meta.js';
+export interface LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}

package/lib/logger/log-message-processor.d.ts

@@ -0,0 +1,5 @@
+import { LogMessage } from './log-message.js';
+export interface LogMessageProcessor {
+    label?(): string;
+    process(msg: LogMessage): LogMessage;
+}

package/lib/logger/log-message.d.ts

@@ -0,0 +1,8 @@
+import { LoggerLevelName } from './logger-level-name.js';
+export interface LogMessage {
+    lvl: LoggerLevelName;
+    timestamp: number;
+    messageSource: string;
+    subsVars?: any[];
+    params?: Record<string, string | number | boolean>;
+}

package/lib/logger/log-snapshot.d.ts

@@ -0,0 +1,5 @@
+import { LogMessage } from './log-message.js';
+export interface LogSnapshot {
+    logMessagesTruncated: number;
+    messages: LogMessage[];
+}

package/lib/logger/logger-instance.d.ts

@@ -0,0 +1,46 @@
+import { LogMessage } from './log-message.js';
+import { LoggerOptions } from './logger-options.js';
+import { LoggerRingBuffer } from './logger-ring-buffer.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessageBuilder } from './log-message-builder.js';
+import { LogMessageProcessor } from './log-message-processor.js';
+export declare class LoggerInstance {
+    private loggerInstanceName;
+    private _loggerMeta;
+    private _ringBuffer;
+    private _formatter;
+    private _level;
+    private _handlerFunctionMap;
+    private _options;
+    constructor(loggerInstanceName: string, inOptions: LoggerOptions);
+    addPreProcessor(proc: LogMessageProcessor): LogMessageProcessor[];
+    get ringBuffer(): LoggerRingBuffer;
+    dumpConfigurationIntoLog(): void;
+    dumpOptionsIntoLog(): void;
+    changeRingBufferSize(newSize: number): void;
+    updateTracePrefix(newValue: string): void;
+    get options(): LoggerOptions;
+    set options(newOpts: LoggerOptions);
+    get level(): LoggerLevelName;
+    set level(newLevel: LoggerLevelName);
+    consoleLogPassThru(level: LoggerLevelName, ...input: any[]): void;
+    createLogMessage(level: LoggerLevelName, params: Record<string, string>, format: string, ...input: any[]): LogMessage;
+    formatMessage(msg: LogMessage): string;
+    formatMessages(msgs: LogMessage[]): string[];
+    recordMessageBuilder(msgBuild: LogMessageBuilder): string;
+    recordMessage(inMsg: LogMessage): string;
+    error(format: string, ...input: any[]): string;
+    errorP(...input: any[]): void;
+    warn(format: string, ...input: any[]): string;
+    warnP(...input: any[]): void;
+    info(format: string, ...input: any[]): string;
+    infoP(...input: any[]): void;
+    verbose(format: string, ...input: any[]): string;
+    verboseP(...input: any[]): void;
+    debug(format: string, ...input: any[]): string;
+    debugP(...input: any[]): void;
+    silly(format: string, ...input: any[]): string;
+    sillyP(...input: any[]): void;
+    logByLevel(level: LoggerLevelName, format: string, ...input: any[]): void;
+    importMessages(msgs: LogMessage[], prefixIn?: string, addTimestamp?: boolean): void;
+}

package/lib/logger/logger-level-name.d.ts

@@ -0,0 +1,8 @@
+export declare enum LoggerLevelName {
+    error = "error",
+    warn = "warn",
+    info = "info",
+    verbose = "verbose",
+    debug = "debug",
+    silly = "silly"
+}

package/lib/logger/logger-meta.d.ts

@@ -0,0 +1,6 @@
+import { LoggerOptions } from './logger-options.js';
+export interface LoggerMeta {
+    options: LoggerOptions;
+    loggerInstanceName: string;
+    loggerInstanceId: string;
+}