@lsdsoftware/utils 1.0.5 → 1.1.1

package/README.md

@@ -25,38 +25,9 @@ const result = await semaphore.runTask(async () => {
 ```
 
 
-### Abortable
-If you have an async operation, e.g.:
+### Connect Socket
+Observable wrapper for net.connect (see connect-socket.test.ts for usage)
 
-```typescript
-async function myTask() {
-  await step1()
-  await step2()
-  await step3()
-}
-```
 
-And you need to make it abortable:
-```typescript
-import { makeAbortable } from "@lsdsoftware/utils"
-
-const [abort, abortPromise, checkpoint] = makeAbortable()
-
-//modify task to support early termination
-async function myTask() {
-  await step1
-  checkpoint()  //will throw if aborted
-  await step2
-  checkpoint()
-  await step3
-}
-
-//call abort() when you need to
-setTimeout(() => abort(new Error("Timeout")), 5000)
-
-//use Promise.race to run your task
-const result = await Promise.race([
-  abortPromise,
-  myTask()
-])
-```
+### Spawn Child
+Observable wrapper for child_process.spawn (see spawn-child.test.ts for usage)

package/dist/connect-socket.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { NetConnectOpts, Socket } from "net";
+import * as rxjs from "rxjs";
+export interface Connection {
+    data$: rxjs.Observable<string | Buffer>;
+    error$: rxjs.Observable<Error>;
+    close$: rxjs.Observable<string>;
+    write: Socket['write'];
+    end: Socket['end'];
+}
+export declare function connectSocket(options: NetConnectOpts & {
+    timeout?: number;
+    encoding?: BufferEncoding;
+}): rxjs.Observable<Connection>;

package/dist/connect-socket.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectSocket = void 0;
+const net_1 = require("net");
+const rxjs = require("rxjs");
+function connectSocket(options) {
+    return rxjs.defer(() => {
+        const sock = (0, net_1.createConnection)(options);
+        if (options.timeout)
+            sock.setTimeout(options.timeout);
+        if (options.encoding)
+            sock.setEncoding(options.encoding);
+        return rxjs.race(rxjs.fromEvent(sock, 'error').pipe(rxjs.map(err => { throw err; })), rxjs.fromEvent(sock, 'connect').pipe(rxjs.take(1), rxjs.map(() => makeConnection(sock))));
+    });
+}
+exports.connectSocket = connectSocket;
+function makeConnection(sock) {
+    return {
+        data$: rxjs.fromEvent(sock, 'data', (data) => data).pipe(rxjs.takeUntil(rxjs.fromEvent(sock, 'end'))),
+        error$: rxjs.fromEvent(sock, 'error', (err) => err),
+        close$: rxjs.merge(rxjs.fromEvent(sock, 'close', (hadError) => hadError ? 'Normal close' : 'Close with error'), rxjs.fromEvent(sock, 'timeout', () => 'Socket timeout')),
+        write: sock.write.bind(sock),
+        end: sock.end.bind(sock)
+    };
+}

package/dist/connect-socket.test.d.ts

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

package/dist/connect-socket.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_socket_1 = require("./connect-socket");
+const rxjs = require("rxjs");
+(0, connect_socket_1.connectSocket)({ host: '127.0.0.1', port: 8080, encoding: 'utf8' }).pipe(rxjs.tap({
+    error(err) {
+        console.error("Socket connect fail", err);
+    }
+}), rxjs.retry({ delay: 10000 }), rxjs.exhaustMap(conn => {
+    console.info("Socket connected");
+    const write = (text) => {
+        console.log('Socket write:', text);
+        conn.write(text);
+    };
+    return rxjs.merge(conn.data$.pipe(rxjs.tap(chunk => console.log('Socket recv:', chunk))), conn.error$.pipe(rxjs.tap(err => console.info('Socket error:', err)))).pipe(rxjs.takeUntil(conn.close$.pipe(rxjs.tap(reason => console.info('Socket close:', reason)))), rxjs.finalize(() => conn.end()), rxjs.ignoreElements(), rxjs.startWith({ write }), rxjs.endWith(null));
+}), rxjs.repeat({ delay: 1000, count: 2 })).subscribe(conn => {
+    conn === null || conn === void 0 ? void 0 : conn.write("GET / HTTP/1.1\n\n");
+});

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { makeLineReader } from "./line-reader";
 import { makeSemaphore } from "./semaphore";
-import { makeAbortable } from "./abortable";
-export { makeLineReader, makeSemaphore, makeAbortable, };
+import { connectSocket } from "./connect-socket";
+import { spawnChild } from "./spawn-child";
+export { makeLineReader, makeSemaphore, connectSocket, spawnChild, };

package/dist/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAbortable = exports.makeSemaphore = exports.makeLineReader = void 0;
+exports.spawnChild = exports.connectSocket = exports.makeSemaphore = exports.makeLineReader = void 0;
 const line_reader_1 = require("./line-reader");
 Object.defineProperty(exports, "makeLineReader", { enumerable: true, get: function () { return line_reader_1.makeLineReader; } });
 const semaphore_1 = require("./semaphore");
 Object.defineProperty(exports, "makeSemaphore", { enumerable: true, get: function () { return semaphore_1.makeSemaphore; } });
-const abortable_1 = require("./abortable");
-Object.defineProperty(exports, "makeAbortable", { enumerable: true, get: function () { return abortable_1.makeAbortable; } });
+const connect_socket_1 = require("./connect-socket");
+Object.defineProperty(exports, "connectSocket", { enumerable: true, get: function () { return connect_socket_1.connectSocket; } });
+const spawn_child_1 = require("./spawn-child");
+Object.defineProperty(exports, "spawnChild", { enumerable: true, get: function () { return spawn_child_1.spawnChild; } });

package/dist/index.test.js

@@ -11,8 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const line_reader_test_1 = require("./line-reader.test");
 const semaphore_test_1 = require("./semaphore.test");
-const abortable_test_1 = require("./abortable.test");
-run(Object.assign(Object.assign(Object.assign({}, line_reader_test_1.default), semaphore_test_1.default), abortable_test_1.default))
+run(Object.assign(Object.assign({}, line_reader_test_1.default), semaphore_test_1.default))
     .catch(console.error);
 function run(tests) {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/line-reader.js

@@ -13,7 +13,7 @@ function makeLineReader(lineCallback) {
         write(chunk, encoding, callback) {
             // encoding param here is irrelevant because it applies only to string chunks
             const chunkStr = remainder + decoder.write(chunk);
-            const lines = chunkStr.split('\n');
+            const lines = chunkStr.split(/\r?\n/);
             // Keep the last line in remainder if it doesn't end with a newline character.
             remainder = lines.pop();
             // Push each complete line.

package/dist/line-reader.test.js

@@ -16,7 +16,7 @@ exports.default = {
         return __awaiter(this, void 0, void 0, function* () {
             const lines = [];
             const splitter = (0, line_reader_1.makeLineReader)(line => lines.push(line));
-            splitter.write('This is a line\nThis is another line\nAnd this is a line as well');
+            splitter.write('This is a line\nThis is another line\r\nAnd this is a line as well');
             splitter.end();
             assert(lines[0] == "This is a line" &&
                 lines[1] == "This is another line" &&

package/dist/semaphore.d.ts

@@ -1,3 +1,3 @@
 export declare function makeSemaphore(count: number): {
-    runTask<T>(task: () => Promise<T>, checkpoint?: () => void): Promise<T>;
+    runTask<T>(task: () => Promise<T>, onStart?: () => void): Promise<T>;
 };

package/dist/semaphore.js

@@ -13,14 +13,14 @@ exports.makeSemaphore = void 0;
 function makeSemaphore(count) {
     const waiters = [];
     return {
-        runTask(task, checkpoint) {
+        runTask(task, onStart) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (count > 0)
                     count--;
                 else
                     yield new Promise(f => waiters.push(f));
                 try {
-                    checkpoint === null || checkpoint === void 0 ? void 0 : checkpoint();
+                    onStart === null || onStart === void 0 ? void 0 : onStart();
                     return yield task();
                 }
                 finally {

package/dist/spawn-child.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcessWithoutNullStreams, SpawnOptionsWithoutStdio } from "child_process";
+import * as rxjs from "rxjs";
+export interface Child {
+    pid: number;
+    stdout$: rxjs.Observable<string | Buffer>;
+    stderr$: rxjs.Observable<string | Buffer>;
+    error$: rxjs.Observable<Error>;
+    close$: rxjs.Observable<number | NodeJS.Signals>;
+    stdin: ChildProcessWithoutNullStreams['stdin'];
+    kill: ChildProcessWithoutNullStreams['kill'];
+}
+export declare function spawnChild(command: string, args?: string[], options?: SpawnOptionsWithoutStdio): rxjs.Observable<Child>;

package/dist/spawn-child.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnChild = void 0;
+const child_process_1 = require("child_process");
+const rxjs = require("rxjs");
+function spawnChild(command, args, options) {
+    return rxjs.defer(() => {
+        const childProc = (0, child_process_1.spawn)(command, args, options);
+        return rxjs.race(rxjs.fromEvent(childProc, 'error', (err) => err).pipe(rxjs.map(err => { throw err; })), rxjs.fromEvent(childProc, 'spawn').pipe(rxjs.take(1), rxjs.map(() => makeChild(childProc))));
+    });
+}
+exports.spawnChild = spawnChild;
+function makeChild(childProc) {
+    return {
+        pid: childProc.pid,
+        stdout$: rxjs.fromEvent(childProc.stdout, 'data', (data) => data),
+        stderr$: rxjs.fromEvent(childProc.stderr, 'data', (data) => data),
+        error$: rxjs.fromEvent(childProc, 'error', (err) => err),
+        close$: rxjs.fromEvent(childProc, 'close', (code, signal) => signal || code),
+        stdin: childProc.stdin,
+        kill: childProc.kill.bind(childProc)
+    };
+}

package/dist/spawn-child.test.d.ts

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

package/dist/spawn-child.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rxjs = require("rxjs");
+const spawn_child_1 = require("./spawn-child");
+(0, spawn_child_1.spawnChild)('cat').pipe(rxjs.tap({
+    error(err) {
+        console.error("Child spawn fail", err);
+    }
+}), rxjs.retry({ delay: 10000 }), rxjs.exhaustMap(child => {
+    console.info("Child spawned", child.pid);
+    const write = (text) => {
+        console.log("Child write:", text);
+        child.stdin.write(text);
+    };
+    return rxjs.merge(child.stdout$.pipe(rxjs.tap(data => console.log("Child stdout:", data.toString()))), child.stderr$.pipe(rxjs.tap(data => console.log("Child stderr:", data.toString()))), child.error$.pipe(rxjs.tap(err => console.info("Child error:", err)))).pipe(rxjs.takeUntil(child.close$.pipe(rxjs.tap(code => console.log("Child close:", code)))), rxjs.finalize(() => child.kill()), rxjs.ignoreElements(), rxjs.startWith({ write }), rxjs.endWith(null));
+}), rxjs.repeat({ delay: 1000, count: 2 }), rxjs.switchMap(child => rxjs.iif(() => child != null, rxjs.fromEvent(process.stdin, 'data', (data) => data).pipe(rxjs.tap(data => child.write(data.toString().trim()))), rxjs.EMPTY))).subscribe({
+    complete() {
+        process.stdin.pause();
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsdsoftware/utils",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "description": "Useful JavaScript utilities",
   "main": "dist/index.js",
   "files": [
@@ -23,5 +23,8 @@
   "devDependencies": {
     "@types/node": "^20.11.20",
     "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.2"
   }
 }

package/dist/abortable.d.ts

@@ -1 +0,0 @@
-export declare function makeAbortable(): readonly [(reason: unknown) => void, Promise<never>, () => void];

package/dist/abortable.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAbortable = void 0;
-function makeAbortable() {
-    let isAborted;
-    let reject;
-    const promise = new Promise((f, r) => reject = r);
-    function abort(reason) {
-        isAborted = { reason };
-        reject(reason);
-    }
-    function checkpoint() {
-        if (isAborted)
-            throw isAborted.reason;
-    }
-    return [
-        abort,
-        promise,
-        checkpoint
-    ];
-}
-exports.makeAbortable = makeAbortable;

package/dist/abortable.test.d.ts

@@ -1,6 +0,0 @@
-declare const _default: {
-    abortable1(): Promise<void>;
-    abortable2(): Promise<void>;
-    abortable3(): Promise<void>;
-};
-export default _default;

package/dist/abortable.test.js

@@ -1,71 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const abortable_1 = require("./abortable");
-const assert = require("assert");
-function task(checkpoint, output) {
-    return __awaiter(this, void 0, void 0, function* () {
-        output.push(1);
-        yield new Promise(f => setTimeout(f, 100));
-        checkpoint();
-        output.push(2);
-        yield new Promise(f => setTimeout(f, 100));
-        checkpoint();
-        output.push(3);
-        yield new Promise(f => setTimeout(f, 100));
-    });
-}
-exports.default = {
-    abortable1() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [abort, abortPromise, checkpoint] = (0, abortable_1.makeAbortable)();
-            const timer = setTimeout(() => abort("Canceled"), 10000);
-            const output = [];
-            yield Promise.race([
-                abortPromise,
-                task(checkpoint, output)
-                    .finally(() => clearTimeout(timer))
-            ]);
-            assert(output.length == 3 &&
-                output[0] == 1 &&
-                output[1] == 2 &&
-                output[2] == 3);
-        });
-    },
-    abortable2() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [abort, abortPromise, checkpoint] = (0, abortable_1.makeAbortable)();
-            setTimeout(() => abort("Canceled"), 150);
-            const output = [];
-            yield Promise.race([
-                abortPromise.catch(err => Promise.reject(err + " by promise")),
-                task(checkpoint, output)
-            ]).then(() => assert(false), err => assert(err == "Canceled by promise"));
-            assert(output.length == 2 &&
-                output[0] == 1 &&
-                output[1] == 2);
-        });
-    },
-    abortable3() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [abort, abortPromise, checkpoint] = (0, abortable_1.makeAbortable)();
-            setTimeout(() => abort("Canceled"), 150);
-            const output = [];
-            yield Promise.race([
-                abortPromise.catch(err => new Promise(f => "Never")),
-                task(checkpoint, output)
-            ]).then(() => assert(false), err => assert(err == "Canceled"));
-            assert(output.length == 2 &&
-                output[0] == 1 &&
-                output[1] == 2);
-        });
-    },
-};