@bitblit/ratchet-common 4.0.99-alpha → 4.0.103-alpha

package/{dist/es → lib}/logger/log-message-builder.js

@@ -1,4 +1,5 @@
 export class LogMessageBuilder {
+    wrapped;
     constructor(lvl, messageSource) {
         if (!lvl) {
             throw Error('Cannot set level to null/undefined');

package/{dist/types → lib}/logger/log-message-formatter.d.ts

@@ -1,5 +1,5 @@
-import { LogMessage } from './log-message';
-import { LoggerMeta } from './logger-meta';
+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-formatter.js

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

package/{dist/types → lib}/logger/log-message-processor.d.ts

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

package/lib/logger/log-message-processor.js

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

package/{dist/types → lib}/logger/log-message.d.ts

@@ -1,4 +1,4 @@
-import { LoggerLevelName } from './logger-level-name';
+import { LoggerLevelName } from './logger-level-name.js';
 export interface LogMessage {
     lvl: LoggerLevelName;
     timestamp: number;

package/lib/logger/log-message.js

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

package/{dist/types → lib}/logger/log-snapshot.d.ts

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

package/lib/logger/log-snapshot.js

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

package/{dist/types → lib}/logger/logger-instance.d.ts

@@ -1,9 +1,9 @@
-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';
+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;

package/{dist/es → lib}/logger/logger-instance.js

@@ -1,12 +1,19 @@
-import { LoggerRingBuffer } from './logger-ring-buffer';
-import { LoggerLevelName } from './logger-level-name';
-import { LoggerUtil } from './logger-util';
-import { LogMessageFormatType } from './log-message-format-type';
-import { ClassicSingleLineLogMessageFormatter } from './classic-single-line-log-message-formatter';
-import { NoneLogMessageFormatter } from './none-log-message-formatter';
-import { StructuredJsonLogMessageFormatter } from './structured-json-log-message-formatter';
-import { StringRatchet } from '../lang/string-ratchet';
+import { LoggerRingBuffer } from './logger-ring-buffer.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerUtil } from './logger-util.js';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { ClassicSingleLineLogMessageFormatter } from './classic-single-line-log-message-formatter.js';
+import { NoneLogMessageFormatter } from './none-log-message-formatter.js';
+import { StructuredJsonLogMessageFormatter } from './structured-json-log-message-formatter.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
 export class LoggerInstance {
+    loggerInstanceName;
+    _loggerMeta;
+    _ringBuffer;
+    _formatter;
+    _level;
+    _handlerFunctionMap;
+    _options;
     constructor(loggerInstanceName = 'default', inOptions) {
         this.loggerInstanceName = loggerInstanceName;
         this.options = inOptions;

package/{dist/types → lib}/logger/logger-meta.d.ts

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

package/lib/logger/logger-meta.js

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

package/{dist/types → lib}/logger/logger-options.d.ts

@@ -1,7 +1,7 @@
-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';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessageProcessor } from './log-message-processor.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
 export interface LoggerOptions {
     initialLevel?: LoggerLevelName;
     formatType?: LogMessageFormatType;

package/lib/logger/logger-options.js

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

package/{dist/types → lib}/logger/logger-ring-buffer.d.ts

@@ -1,5 +1,5 @@
-import { LogMessage } from './log-message';
-import { LogSnapshot } from './log-snapshot';
+import { LogMessage } from './log-message.js';
+import { LogSnapshot } from './log-snapshot.js';
 export declare class LoggerRingBuffer {
     private _lastLogMessage;
     private _buffer;

package/{dist/es → lib}/logger/logger-ring-buffer.js

@@ -1,11 +1,12 @@
-import { Logger } from './logger';
-import { LoggerLevelName } from './logger-level-name';
+import { Logger } from './logger.js';
+import { LoggerLevelName } from './logger-level-name.js';
 export class LoggerRingBuffer {
+    _lastLogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: LoggerLevelName.info };
+    _buffer = [];
+    _bufferIdx = 0;
+    _lastSnapshotIdx = 0;
+    _bufferSize;
     constructor(size) {
-        this._lastLogMessage = { messageSource: 'No message yet', timestamp: new Date().getTime(), lvl: LoggerLevelName.info };
-        this._buffer = [];
-        this._bufferIdx = 0;
-        this._lastSnapshotIdx = 0;
         if (!size) {
             throw new Error('Cannot create ring buffer of size 0');
         }

package/{dist/types → lib}/logger/logger-util.d.ts

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

package/{dist/es → lib}/logger/logger-util.js

@@ -1,6 +1,14 @@
-import { LoggerLevelName } from './logger-level-name';
-import { LoggerOutputFunction } from './logger-output-function';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
 export class LoggerUtil {
+    static LOG_LEVELS_IN_ORDER = [
+        LoggerLevelName.error,
+        LoggerLevelName.warn,
+        LoggerLevelName.info,
+        LoggerLevelName.verbose,
+        LoggerLevelName.debug,
+        LoggerLevelName.silly,
+    ];
     static handlerFunctionMap(outputFn = LoggerOutputFunction.Console) {
         const output = new Map();
         if (outputFn === LoggerOutputFunction.StdOut) {
@@ -34,11 +42,3 @@ export class LoggerUtil {
         return idxTarget > -1 && lvl > -1 && lvl >= idxTarget;
     }
 }
-LoggerUtil.LOG_LEVELS_IN_ORDER = [
-    LoggerLevelName.error,
-    LoggerLevelName.warn,
-    LoggerLevelName.info,
-    LoggerLevelName.verbose,
-    LoggerLevelName.debug,
-    LoggerLevelName.silly,
-];

package/lib/logger/logger-util.spec.d.ts

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

package/lib/logger/logger-util.spec.js

@@ -0,0 +1,9 @@
+import { LoggerUtil } from './logger-util.js';
+import { LoggerLevelName } from './logger-level-name.js';
+describe('#checkLevel', function () {
+    it('should check that level logging works', function () {
+        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.info, LoggerLevelName.warn)).toEqual(false);
+        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.info)).toEqual(true);
+        expect(LoggerUtil.levelIsEnabled(LoggerLevelName.warn, LoggerLevelName.warn)).toEqual(true);
+    });
+});

package/{dist/types → lib}/logger/logger.d.ts

@@ -1,19 +1,10 @@
-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
- */
+import { LogMessage } from './log-message.js';
+import { LogSnapshot } from './log-snapshot.js';
+import { LoggerOptions } from './logger-options.js';
+import { LoggerInstance } from './logger-instance.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerRingBuffer } from './logger-ring-buffer.js';
+import { LogMessageBuilder } from './log-message-builder.js';
 export declare class Logger {
     private static LOGGER_INSTANCES;
     private static DEFAULT_OPTIONS;

package/{dist/es → lib}/logger/logger.js

@@ -1,8 +1,18 @@
-import { LoggerInstance } from './logger-instance';
-import { LogMessageFormatType } from './log-message-format-type';
-import { LoggerLevelName } from './logger-level-name';
-import { LoggerOutputFunction } from './logger-output-function';
+import { LoggerInstance } from './logger-instance.js';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
 export class Logger {
+    static LOGGER_INSTANCES = new Map();
+    static DEFAULT_OPTIONS = {
+        initialLevel: LoggerLevelName.info,
+        formatType: LogMessageFormatType.ClassicSingleLine,
+        trace: null,
+        globalVars: {},
+        outputFunction: LoggerOutputFunction.Console,
+        ringBufferSize: 0,
+        preProcessors: [],
+    };
     static applyDefaultsToOptions(input) {
         const rval = input || {};
         rval.initialLevel = rval.initialLevel ?? Logger.DEFAULT_OPTIONS.initialLevel;
@@ -122,13 +132,3 @@ export class Logger {
         return buf ? buf.getLastLogMessage() : null;
     }
 }
-Logger.LOGGER_INSTANCES = new Map();
-Logger.DEFAULT_OPTIONS = {
-    initialLevel: LoggerLevelName.info,
-    formatType: LogMessageFormatType.ClassicSingleLine,
-    trace: null,
-    globalVars: {},
-    outputFunction: LoggerOutputFunction.Console,
-    ringBufferSize: 0,
-    preProcessors: [],
-};

package/lib/logger/logger.spec.d.ts

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

package/lib/logger/logger.spec.js

@@ -0,0 +1,134 @@
+import { Logger } from './logger.js';
+import { LoggerLevelName } from './logger-level-name.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
+import { LogMessageBuilder } from './log-message-builder.js';
+import { LogMessageFormatType } from './log-message-format-type.js';
+import { LoggerOutputFunction } from './logger-output-function.js';
+describe('#setLevel', function () {
+    it('should change the level to debug then info then debug', function () {
+        Logger.dumpConfigurationIntoLog();
+        expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
+        Logger.setLevel(LoggerLevelName.debug);
+        expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
+        Logger.setLevel(LoggerLevelName.info);
+        expect(Logger.getLevel()).toEqual(LoggerLevelName.info);
+        Logger.setLevel(LoggerLevelName.debug);
+        expect(Logger.getLevel()).toEqual(LoggerLevelName.debug);
+    });
+});
+describe('#takeSnapshot', function () {
+    it('should advance the pointer correctly after a snapshot', function () {
+        Logger.changeRingBufferSize(5);
+        expect(Logger.getRingBuffer().currentIndex).toEqual(0);
+        Logger.info('m1');
+        Logger.info('m2');
+        Logger.info('m3');
+        const snap1 = Logger.takeSnapshot();
+        Logger.info('m4');
+        Logger.info('m5');
+        const snap2 = Logger.takeSnapshot();
+        Logger.info('m6');
+        Logger.info('m7');
+        Logger.info('m8');
+        const snap3 = Logger.takeSnapshot();
+        expect(snap1.messages.length).toEqual(3);
+        expect(snap2.messages.length).toEqual(2);
+        expect(snap3.messages.length).toEqual(3);
+        expect(Logger.getRingBuffer().currentIndex).toEqual(8);
+    });
+});
+describe('#testTracePrefix', function () {
+    it('should apply a trace prefix correctly', function () {
+        Logger.updateTracePrefix('::TRACE::');
+        Logger.changeRingBufferSize(3);
+        Logger.info('m1');
+        Logger.info('m2');
+        const snap1 = Logger.takeSnapshot();
+        const snap1String = Logger.formatMessages(snap1.messages);
+        expect(snap1String.length).toBeGreaterThan(0);
+        snap1String.forEach((m) => {
+            expect(m.indexOf('::TRACE::')).toBeGreaterThan(-1);
+        });
+        Logger.updateTracePrefix(null);
+        Logger.info('m1');
+        Logger.info('m2');
+        const snap2 = Logger.takeSnapshot();
+        expect(snap2.messages.length).toBeGreaterThan(0);
+        snap2.messages.forEach((m) => {
+            expect(m.messageSource.indexOf('::TRACE::')).toEqual(-1);
+        });
+    });
+});
+describe('#testLastMessage', function () {
+    it('should return the last message', function () {
+        Logger.info('m1');
+        Logger.info('m2');
+        const last = Logger.getLastLogMessage();
+        expect(last).toBeTruthy();
+        expect(last.lvl).toEqual(LoggerLevelName.info);
+        expect(last.messageSource.endsWith('m2')).toBeTruthy();
+    });
+});
+describe('#testPassThruFunctions', function () {
+    it('should pass through values', function () {
+        Logger.setLevel(LoggerLevelName.debug);
+        Logger.error('Test %s', 'tVal');
+        Logger.errorP('TestP %s', 'tVal');
+        Logger.errorP('TestP 2', 27, { some: 'Object' });
+        Logger.warn('Test %s', 'tVal');
+        Logger.warnP('TestP %s', 'tVal');
+        Logger.info('Test %s', 'tVal');
+        Logger.infoP('TestP %s', 'tVal');
+        Logger.debug('Test %s', 'tVal');
+        Logger.debugP('TestP %s', 'tVal');
+        Logger.verbose('Test %s', 'tVal');
+        Logger.verboseP('TestP %s', 'tVal');
+        Logger.silly('Test %s', 'tVal');
+        Logger.sillyP('TestP %s', 'tVal');
+        Logger.setLevel(LoggerLevelName.debug);
+    });
+});
+describe('#testFormatter', function () {
+    it('should format values', function () {
+        const msg = {
+            lvl: LoggerLevelName.info,
+            timestamp: Date.now(),
+            messageSource: 'Test %d %d',
+            subsVars: [1, 2],
+            params: {},
+        };
+        Logger.info('Test %d %d', 3, 4);
+        const msgS = Logger.formatMessages([msg])[0];
+        expect(msgS).toEqual('[info] Test 1 2');
+    });
+});
+describe('#testPreProcessor', function () {
+    it('should perform a preprocess', function () {
+        const preProc = {
+            process(msg) {
+                msg.messageSource = 'Preprocess';
+                return msg;
+            },
+        };
+        const output = Logger.getLogger(StringRatchet.createRandomHexString(4), { preProcessors: [preProc] }).info('This is a test %s', 'bob');
+        expect(output).toEqual('[info] Preprocess bob');
+    });
+});
+describe('#testBuilder', function () {
+    it('should use a builder', function () {
+        const output = Logger.getLogger(StringRatchet.createRandomHexString(4)).recordMessageBuilder(new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']));
+        expect(output).toEqual('[warn] This is a test bob');
+    });
+});
+describe('#testStructured', function () {
+    it('should use a structured logger', function () {
+        const output = Logger.getLogger(StringRatchet.createRandomHexString(4), {
+            formatType: LogMessageFormatType.StructuredJson,
+            outputFunction: LoggerOutputFunction.StdOut,
+        }).recordMessageBuilder(new LogMessageBuilder(LoggerLevelName.warn, 'This is a test %s').subVars(['bob']).p('a', 27));
+        const parsed = JSON.parse(output);
+        expect(parsed.msg).toEqual('This is a test bob');
+        expect(parsed.logLevel).toEqual('warn');
+        expect(parsed.a).toEqual(27);
+    });
+});

package/lib/logger/none-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 NoneLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}

package/lib/logger/structured-json-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 StructuredJsonLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}

package/{dist/types → lib}/network/browser-local-ip-provider.d.ts

@@ -1,4 +1,4 @@
-import { LocalIpProvider } from './local-ip-provider';
+import { LocalIpProvider } from './local-ip-provider.js';
 export declare class BrowserLocalIpProvider implements LocalIpProvider {
     private currentIp;
     constructor();

package/{dist/es → lib}/network/browser-local-ip-provider.js

@@ -1,8 +1,8 @@
-import { NetworkRatchet } from './network-ratchet';
-import { Logger } from '../logger/logger';
+import { NetworkRatchet } from './network-ratchet.js';
+import { Logger } from '../logger/logger.js';
 export class BrowserLocalIpProvider {
+    currentIp = 'UNSET';
     constructor() {
-        this.currentIp = 'UNSET';
         NetworkRatchet.findLocalIp(false)
             .then((result) => {
             Logger.info('Setting local IP to %s', result);

package/lib/network/browser-local-ip-provider.spec.d.ts

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

package/lib/network/browser-local-ip-provider.spec.js

@@ -0,0 +1,16 @@
+import { BrowserLocalIpProvider } from './browser-local-ip-provider.js';
+import { NetworkRatchet } from './network-ratchet.js';
+import { PromiseRatchet } from '../lang/promise-ratchet.js';
+import { jest } from '@jest/globals';
+jest.mock('./network-ratchet');
+describe('#browserLocalIpProvider', function () {
+    it('should pull a local ip and return it', async () => {
+        const mockStaticFn = jest.fn(() => Promise.resolve('192.168.1.1'));
+        NetworkRatchet.findLocalIp = mockStaticFn;
+        const up = new BrowserLocalIpProvider();
+        while (!up.ready()) {
+            await PromiseRatchet.wait(250);
+        }
+        expect(up.currentLocalIpAddress()).toEqual('192.168.1.1');
+    });
+});

package/{dist/types → lib}/network/fixed-local-ip-provider.d.ts

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

package/{dist/es → lib}/network/fixed-local-ip-provider.js

@@ -1,4 +1,5 @@
 export class FixedLocalIpProvider {
+    fixed;
     constructor(fixed) {
         this.fixed = fixed;
     }

package/lib/network/local-ip-provider.d.ts

@@ -0,0 +1,3 @@
+export interface LocalIpProvider {
+    currentLocalIpAddress(): string;
+}

package/lib/network/local-ip-provider.js

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

package/{dist/types → lib}/network/network-ratchet.d.ts

@@ -1,4 +1,4 @@
-import { ParsedUrl } from '../lang/parsed-url';
+import { ParsedUrl } from '../lang/parsed-url.js';
 export declare class NetworkRatchet {
     private static LOCAL_IP;
     static findLocalIp(useCache?: boolean): Promise<string>;

package/{dist/es → lib}/network/network-ratchet.js

@@ -1,5 +1,6 @@
-import { Logger } from '../logger/logger';
+import { Logger } from '../logger/logger.js';
 export class NetworkRatchet {
+    static LOCAL_IP = null;
     static findLocalIp(useCache = true) {
         Logger.info('Attempting to find local IP (V 2)');
         if (NetworkRatchet.LOCAL_IP && useCache) {
@@ -99,4 +100,3 @@ export class NetworkRatchet {
         }
     }
 }
-NetworkRatchet.LOCAL_IP = null;

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

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

package/lib/network/network-ratchet.spec.js

@@ -0,0 +1,13 @@
+import { NetworkRatchet } from './network-ratchet.js';
+describe('#parseUrl', function () {
+    it('should parse the url and return correct values', function () {
+        const result = NetworkRatchet.parseUrl('http://example.com:3000/pathname/?search=test#hash');
+        expect(result.protocol).toEqual('http:');
+        expect(result.host).toEqual('example.com:3000');
+        expect(result.hostname).toEqual('example.com');
+        expect(result.port).toEqual('3000');
+        expect(result.pathname).toEqual('/pathname/');
+        expect(result.search).toEqual('?search=test');
+        expect(result.hash).toEqual('#hash');
+    });
+});

package/{dist/types → lib}/stream/buffer-writable.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { Writable } from 'stream';
 export declare class BufferWritable extends Writable {
     private _val;

package/{dist/es → lib}/stream/buffer-writable.js

@@ -1,8 +1,8 @@
 import { Writable } from 'stream';
 export class BufferWritable extends Writable {
+    _val = [];
     constructor() {
         super();
-        this._val = [];
     }
     _write(chunk, encoding, callback) {
         if (chunk) {

package/lib/stream/multi-stream.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable, ReadableOptions } from 'stream';
+export declare class MultiStream extends Readable {
+    _object: any;
+    constructor(object: any, options?: ReadableOptions);
+    _read(): void;
+}

package/lib/stream/multi-stream.js

@@ -0,0 +1,12 @@
+import { Readable } from 'stream';
+export class MultiStream extends Readable {
+    _object;
+    constructor(object, options = {}) {
+        super(object instanceof Buffer || typeof object === 'string' ? options : { objectMode: true });
+        this._object = object;
+    }
+    _read() {
+        this.push(this._object);
+        this._object = null;
+    }
+}

package/{dist/types → lib}/stream/stream-ratchet.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { Readable } from 'stream';
 export declare class StreamRatchet {
     private constructor();

package/{dist/es → lib}/stream/stream-ratchet.js

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
-import { ErrorRatchet } from '../lang/error-ratchet';
-import { StringRatchet } from '../lang/string-ratchet';
+import { ErrorRatchet } from '../lang/error-ratchet.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
 export class StreamRatchet {
     constructor() { }
     static readableToBufferSync(stream) {

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

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

package/lib/stream/stream-ratchet.spec.js

@@ -0,0 +1,13 @@
+import { StreamRatchet } from './stream-ratchet.js';
+describe('#StreamRatchet', function () {
+    it('should wrap a string in a readable', async () => {
+        const r = StreamRatchet.stringToReadable('test');
+        const out = r.read(200);
+        expect(out.length).toEqual(4);
+    });
+    it('should wrap an number in a readable', async () => {
+        const r = StreamRatchet.anyToStringReadable(401);
+        const out = r.read(200);
+        expect(out.length).toEqual(3);
+    });
+});

package/{dist/types → lib}/stream/string-writable.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { Writable } from 'stream';
 export declare class StringWritable extends Writable {
     private _val;

package/{dist/es → lib}/stream/string-writable.js

@@ -1,8 +1,8 @@
 import { Writable } from 'stream';
 export class StringWritable extends Writable {
+    _val = '';
     constructor() {
         super();
-        this._val = '';
     }
     _write(chunk, encoding, callback) {
         this._val += chunk ? chunk.toString() : '';

package/lib/stream/string-writable.spec.d.ts

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