@bitblit/ratchet-common 4.0.80-alpha

package/dist/types/lang/key-value.d.ts

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

package/dist/types/lang/last-success-provider.d.ts

@@ -0,0 +1,4 @@
+/** Classes implementing this interface return a timestamp of their last success * */
+export interface LastSuccessProvider {
+    lastSuccess(): number;
+}

package/dist/types/lang/map-ratchet.d.ts

@@ -0,0 +1,15 @@
+import { KeyValue } from './key-value';
+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/dist/types/lang/no.d.ts

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

package/dist/types/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): 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/dist/types/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/dist/types/lang/promise-ratchet.d.ts

@@ -0,0 +1,32 @@
+import { TimeoutToken } from './timeout-token';
+import { LoggerLevelName } from '../logger/logger-level-name';
+export declare class PromiseRatchet {
+    /**
+     * Returns a promise that only resolves when the named event happens on the event source -
+     * the promise will return the passed object, if any, at that point.  If errEventNames are specified,
+     * the promise will reject when any of those events are fired
+     * @param evtSrc Object that will fire the event
+     * @param okEvtNames Names of the event that will be considered successes
+     * @param errEventNames Names of error events
+     * @param rval Return value, if any
+     */
+    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, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
+    intervalMS: number, maxCycles: number, label?: string, count?: number): Promise<boolean>;
+    static runBoundedParallel<T>(promiseFn: Function, // eslint-disable-line @typescript-eslint/ban-types
+    params: any[][], context: any, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
+    maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static runBoundedParallelSingleParam<T>(promiseFn: Function, // eslint-disable-line @typescript-eslint/ban-types
+    params: any[], context: any, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
+    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/dist/types/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/dist/types/lang/stop-watch.d.ts

@@ -0,0 +1,17 @@
+import { LoggerLevelName } from '../logger/logger-level-name';
+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/dist/types/lang/string-ratchet.d.ts

@@ -0,0 +1,27 @@
+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;
+}

package/dist/types/lang/time-zone-ratchet.d.ts

@@ -0,0 +1,50 @@
+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;
+    /**
+     * Returns the number of slots in a day (simple math)
+     * @param {number} slotWidthMs
+     * @returns {number} containing the number of slots in a day (last one may be partial)
+     */
+    dailySlotCount(slotWidthMs: number): number;
+    /**
+     * Imagine a day cut into N 'slots', each slotWidthMS wide - then there are
+     * 86,400,000 / slotWidthMS slots available, indexed from 0 on up.  This function
+     * returns that index
+     * @param {number} slotWidthMs
+     * @returns {number} containing the current index
+     */
+    currentTimeSlotIdx(slotWidthMs: number): number;
+    /**
+     * Imagine a day cut into N 'slots', each slotWidthMS wide - then there are
+     * 86,400,000 / slotWidthMS slots available, indexed from 0 on up.  This function
+     * returns that index
+     * @param {number} slotWidthMs
+     * @returns {number} containing the current index
+     */
+    matchingTimeSlotIdx(timestamp: number, slotWidthMs: number): number;
+    /**
+     * Given the definition of slotWidth and currentTimeSlotIdx from above, return the ms that is the
+     * start of the slot that "now" falls within.
+     * @param {number} slotWidthMs
+     * @returns {number}
+     */
+    startOfCurrentSlotEpochMS(slotWidthMs: number): number;
+    /**
+     * Given the definition of slotWidth and currentTimeSlotIdx from above, return the ms that is the
+     * start of the slot that the passed timestamp falls within.
+     * @param {number} slotWidthMs
+     * @returns {number}
+     */
+    startOfMatchingSlotEpochMS(timestamp: number, slotWidthMs: number): number;
+}

package/dist/types/lang/timeout-token.d.ts

@@ -0,0 +1,9 @@
+import { LoggerLevelName } from '../logger/logger-level-name';
+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/dist/types/lang/transform-ratchet.d.ts

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

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

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

package/dist/types/logger/log-message-builder.d.ts

@@ -0,0 +1,14 @@
+import { LoggerLevelName } from './logger-level-name';
+import { LogMessage } from './log-message';
+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/dist/types/logger/log-message-format-type.d.ts

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

package/dist/types/logger/log-message-formatter.d.ts

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

package/dist/types/logger/log-message-processor.d.ts

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

package/dist/types/logger/log-message.d.ts

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

package/dist/types/logger/log-snapshot.d.ts

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

package/dist/types/logger/logger-instance.d.ts

@@ -0,0 +1,46 @@
+import { LogMessage } from './log-message';
+import { LoggerOptions } from './logger-options';
+import { LoggerRingBuffer } from './logger-ring-buffer';
+import { LoggerLevelName } from './logger-level-name';
+import { LogMessageBuilder } from './log-message-builder';
+import { LogMessageProcessor } from './log-message-processor';
+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/dist/types/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/dist/types/logger/logger-meta.d.ts

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

package/dist/types/logger/logger-options.d.ts

@@ -0,0 +1,13 @@
+import { LogMessageFormatType } from './log-message-format-type';
+import { LoggerLevelName } from './logger-level-name';
+import { LogMessageProcessor } from './log-message-processor';
+import { LoggerOutputFunction } from './logger-output-function';
+export interface LoggerOptions {
+    initialLevel?: LoggerLevelName;
+    formatType?: LogMessageFormatType;
+    trace?: string;
+    globalVars?: Record<string, string | number | boolean>;
+    outputFunction?: LoggerOutputFunction;
+    ringBufferSize?: number;
+    preProcessors?: LogMessageProcessor[];
+}

package/dist/types/logger/logger-output-function.d.ts

@@ -0,0 +1,5 @@
+export declare enum LoggerOutputFunction {
+    Console = "Console",
+    ConsoleNoDebug = "ConsoleNoDebug",
+    StdOut = "StdOut"
+}

package/dist/types/logger/logger-ring-buffer.d.ts

@@ -0,0 +1,18 @@
+import { LogMessage } from './log-message';
+import { LogSnapshot } from './log-snapshot';
+export declare class LoggerRingBuffer {
+    private _lastLogMessage;
+    private _buffer;
+    private _bufferIdx;
+    private _lastSnapshotIdx;
+    private _bufferSize;
+    constructor(size: number);
+    get currentIndex(): number;
+    get lastSnapshotIdx(): number;
+    set bufferSize(newSize: number);
+    getMessages(inStartFrom?: number, clear?: boolean, reverseSort?: boolean): LogMessage[];
+    takeSnapshot(): LogSnapshot;
+    getLastLogMessage(): LogMessage;
+    private clearRingBuffer;
+    addToRingBuffer(newMsg: LogMessage): void;
+}

package/dist/types/logger/logger-util.d.ts

@@ -0,0 +1,8 @@
+import { LoggerLevelName } from './logger-level-name';
+import { LoggerOutputFunction } from './logger-output-function';
+export declare class LoggerUtil {
+    private static LOG_LEVELS_IN_ORDER;
+    static handlerFunctionMap(outputFn?: LoggerOutputFunction): Map<LoggerLevelName, (...any: any[]) => void>;
+    static defaultHandlerFunction(): (...any: any[]) => void;
+    static levelIsEnabled(targetLevel: LoggerLevelName, currentEnabled: LoggerLevelName): boolean;
+}

package/dist/types/logger/logger.d.ts

@@ -0,0 +1,52 @@
+import { LogMessage } from './log-message';
+import { LogSnapshot } from './log-snapshot';
+import { LoggerOptions } from './logger-options';
+import { LoggerInstance } from './logger-instance';
+import { LoggerLevelName } from './logger-level-name';
+import { LoggerRingBuffer } from './logger-ring-buffer';
+import { LogMessageBuilder } from './log-message-builder';
+/**
+ * Class to simplify logging across both browsers and node (especially lambda)
+ *
+ * Important note : This class is here to make logging SIMPLE - mainly it is focused on simplicity,
+ * and single point of enable/disable logging. Output goes to console, since thats the only thing
+ * that is present in both the browser and node.  If you need to do something more complicated (like
+ * logging to files,  multiple transports, etc) you really should just use something heavier like
+ * Winston directly and skip this class entirely
+ */
+export declare class Logger {
+    private static LOGGER_INSTANCES;
+    private static DEFAULT_OPTIONS;
+    static applyDefaultsToOptions(input?: LoggerOptions): LoggerOptions;
+    static changeDefaultOptions(input: LoggerOptions, retroactive?: boolean): void;
+    static getLogger(loggerName?: string, inOptions?: LoggerOptions): LoggerInstance;
+    static recordMessageBuilder(msgBuild: LogMessageBuilder): string;
+    static recordMessage(msg: LogMessage): string;
+    static formatMessages(msgs: LogMessage[]): string[];
+    static updateTracePrefix(newValue: string): void;
+    static changeRingBufferSize(newValue: number): void;
+    static getRingBuffer(): LoggerRingBuffer;
+    static dumpConfigurationIntoLog(): void;
+    static dumpOptionsIntoLog(): void;
+    static getLevel(): LoggerLevelName;
+    static setLevel(newLevel: LoggerLevelName): void;
+    static getOptions(): LoggerOptions;
+    static getMessages(inStartFrom?: number, clear?: boolean, reverseSort?: boolean): LogMessage[];
+    static consoleLogPassThru(level: LoggerLevelName, ...input: any[]): void;
+    static error(format: string, ...input: any[]): string;
+    static errorP(...input: any[]): void;
+    static warn(format: string, ...input: any[]): string;
+    static warnP(...input: any[]): void;
+    static info(format: string, ...input: any[]): string;
+    static infoP(...input: any[]): void;
+    static verbose(format: string, ...input: any[]): string;
+    static verboseP(...input: any[]): void;
+    static debug(format: string, ...input: any[]): string;
+    static debugP(...input: any[]): void;
+    static silly(format: string, ...input: any[]): string;
+    static sillyP(...input: any[]): void;
+    static takeSnapshot(): LogSnapshot;
+    static logByLevel(level: LoggerLevelName, format: string, ...input: any[]): void;
+    static importMessages(msgs: LogMessage[], prefixIn?: string, addTimestamp?: boolean): void;
+    static getLastLogMessage(): LogMessage;
+}

package/dist/types/logger/none-log-message-formatter.d.ts

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

package/dist/types/logger/structured-json-log-message-formatter.d.ts

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

package/dist/types/network/browser-local-ip-provider.d.ts

@@ -0,0 +1,7 @@
+import { LocalIpProvider } from './local-ip-provider';
+export declare class BrowserLocalIpProvider implements LocalIpProvider {
+    private currentIp;
+    constructor();
+    ready(): boolean;
+    currentLocalIpAddress(): string;
+}

package/dist/types/network/fixed-local-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import { LocalIpProvider } from './local-ip-provider';
+export declare class FixedLocalIpProvider implements LocalIpProvider {
+    private fixed;
+    constructor(fixed: string);
+    currentLocalIpAddress(): string;
+}

package/dist/types/network/local-ip-provider.d.ts

@@ -0,0 +1,4 @@
+/** Classes implementing this interface can provide the current local ip address (as a string) * */
+export interface LocalIpProvider {
+    currentLocalIpAddress(): string;
+}

package/dist/types/network/network-ratchet.d.ts

@@ -0,0 +1,9 @@
+import { ParsedUrl } from '../lang/parsed-url';
+export declare class NetworkRatchet {
+    private static LOCAL_IP;
+    static findLocalIp(useCache?: boolean): Promise<string>;
+    static parseUrl(href: string): ParsedUrl;
+    private static updateLocalIP;
+    private static grepSDP;
+    private static updateAddressList;
+}

package/dist/types/stream/buffer-writable.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Writable } from 'stream';
+export declare class BufferWritable extends Writable {
+    private _val;
+    constructor();
+    _write(chunk: any, encoding: string, callback: any): void;
+    get value(): Buffer;
+}

package/dist/types/stream/stream-ratchet.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare class StreamRatchet {
+    private constructor();
+    static readableToBufferSync(stream: Readable): Buffer;
+    static webReadableStreamToBuffer(stream: ReadableStream): Promise<Buffer>;
+    static webReadableStreamToString(stream: ReadableStream): Promise<string>;
+    static stringToReadable(input: string): Readable;
+    static stringToWebReadableStream(input: string): ReadableStream;
+    static anyToStringReadable(input: any): Readable;
+}

package/dist/types/stream/string-writable.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+export declare class StringWritable extends Writable {
+    private _val;
+    constructor();
+    _write(chunk: any, encoding: string, callback: any): void;
+    get value(): string;
+}

package/dist/types/third-party/google/google-recaptcha-ratchet.d.ts

@@ -0,0 +1,4 @@
+export declare class GoogleRecaptchaRatchet {
+    private static readonly GOOGLE_VERIFY_URL;
+    static verifyRecaptchaToken(keySecret: string, token: string, fetchFn?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>): Promise<boolean>;
+}

package/dist/types/third-party/twilio/twilio-ratchet.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This class is for people who just need to send an occasionaly outbound text message and don't need
+ * Twilio's 7mb non-tree-shakable library
+ */
+export declare class TwilioRatchet {
+    private accountSid;
+    private authToken;
+    private outBoundNumber;
+    static readonly TWILLIO_BASE_API_URL: string;
+    constructor(accountSid: string, authToken: string, outBoundNumber: string);
+    static sendMessageDirect(accountSid: string, authToken: string, outBoundNumber: string, recipientPhoneNumbers: string[], message: string): Promise<any[]>;
+    static generateTwilioBasicAuth(sid: string, authToken: string): string;
+    sendMessage(recipientPhoneNumbers: string[], message: string): Promise<any[]>;
+    static isValidE164Number(num: string): boolean;
+}

package/dist/types/transform/built-in-transforms.d.ts

@@ -0,0 +1,18 @@
+import { TransformRule } from './transform-rule';
+export declare class BuiltInTransforms {
+    static keysOnly(rule: TransformRule): TransformRule;
+    static valuesOnly(rule: TransformRule): TransformRule;
+    static stringReplaceTransform(input: string, output: string): TransformRule;
+    static stripStringTransform(input: string): TransformRule;
+    static retainAll(input: string[]): TransformRule;
+    static removeAll(input: string[]): TransformRule;
+    static snakeToCamelCase(): TransformRule;
+    static stringToNumber(): TransformRule;
+    static camelToSnakeCase(): TransformRule;
+    static concatenateToNewField(newFieldName: string, oldFieldNamesInOrder: string[], abortIfFieldMissing?: boolean): TransformRule;
+    static numberToBool(fieldNames: string[]): TransformRule;
+    static boolToNumber(fieldNames: string[]): TransformRule;
+    static makeDuplicateField(oldName: string, newName: string): TransformRule;
+    static addField(name: string, valueToAdd: string): TransformRule;
+    static reformatDateFields(fieldNames: string[], oldFormat: string, newFormat: string): TransformRule;
+}

package/dist/types/transform/transform-rule.d.ts

@@ -0,0 +1,3 @@
+export interface TransformRule {
+    transform(value: any, isKey: boolean, context: any): any;
+}

package/dist/types/tx/transaction-configuration.d.ts

@@ -0,0 +1,7 @@
+import { TransactionResult } from './transaction-result';
+import { LoggerLevelName } from '../logger/logger-level-name';
+export interface TransactionConfiguration<T> {
+    stepLogLevel?: LoggerLevelName;
+    executeAfterRollback?(result: TransactionResult<T>): Promise<void>;
+    executeAfterRollbackFailure?(result: TransactionResult<T>): Promise<void>;
+}

package/dist/types/tx/transaction-final-state.d.ts

@@ -0,0 +1,5 @@
+export declare enum TransactionFinalState {
+    Success = "Success",
+    RolledBack = "RolledBack",
+    RollbackFailed = "RollbackFailed"
+}

package/dist/types/tx/transaction-ratchet.d.ts

@@ -0,0 +1,6 @@
+import { TransactionStep } from './transaction-step';
+import { TransactionResult } from './transaction-result';
+import { TransactionConfiguration } from './transaction-configuration';
+export declare class TransactionRatchet {
+    static execute<T>(steps: TransactionStep<T>[], initialContext: T, inConfiguration?: TransactionConfiguration<T>): Promise<TransactionResult<T>>;
+}

package/dist/types/tx/transaction-result.d.ts

@@ -0,0 +1,9 @@
+import { TransactionFinalState } from './transaction-final-state';
+export interface TransactionResult<T> {
+    finalContext: T;
+    finalState: TransactionFinalState;
+    error?: any;
+    rollbackError?: any;
+    errorStep?: number;
+    rollbackErrorStep?: number;
+}

package/dist/types/tx/transaction-step.d.ts

@@ -0,0 +1,5 @@
+export interface TransactionStep<T> {
+    execute(context: T, stepNumber?: number): Promise<void>;
+    rollback?(context: T, stepNumber?: number): Promise<void>;
+    name?: string;
+}