@lsdsoftware/utils 1.0.4 → 1.1.0

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

@@ -10,7 +10,8 @@ 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");
-run(Object.assign({}, line_reader_test_1.default))
+const semaphore_test_1 = require("./semaphore.test");
+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.test.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
-    lineSplitStream1(): Promise<void>;
-    lineSplitStream2(): Promise<void>;
-    lineSplitStream3(): Promise<void>;
+    lineReader1(): Promise<void>;
+    lineReader2(): Promise<void>;
+    lineReader3(): Promise<void>;
 };
 export default _default;

package/dist/line-reader.test.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const line_reader_1 = require("./line-reader");
 const assert = require("assert");
 exports.default = {
-    lineSplitStream1() {
+    lineReader1() {
         return __awaiter(this, void 0, void 0, function* () {
             const lines = [];
             const splitter = (0, line_reader_1.makeLineReader)(line => lines.push(line));
@@ -23,7 +23,7 @@ exports.default = {
                 lines[2] == "And this is a line as well");
         });
     },
-    lineSplitStream2() {
+    lineReader2() {
         return __awaiter(this, void 0, void 0, function* () {
             const lines = [];
             const splitter = (0, line_reader_1.makeLineReader)(line => lines.push(line));
@@ -33,7 +33,7 @@ exports.default = {
                 lines[1] == "This is a line");
         });
     },
-    lineSplitStream3() {
+    lineReader3() {
         return __awaiter(this, void 0, void 0, function* () {
             const lines = [];
             const splitter = (0, line_reader_1.makeLineReader)(line => lines.push(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));
-                checkpoint === null || checkpoint === void 0 ? void 0 : checkpoint();
                 try {
+                    onStart === null || onStart === void 0 ? void 0 : onStart();
                     return yield task();
                 }
                 finally {

package/dist/semaphore.test.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    semaphore1(): Promise<void>;
+    semaphore2(): Promise<void>;
+    semaphore3(): Promise<void>;
+};
+export default _default;

package/dist/semaphore.test.js

@@ -0,0 +1,84 @@
+"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 semaphore_1 = require("./semaphore");
+const assert = require("assert");
+exports.default = {
+    semaphore1() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sema = (0, semaphore_1.makeSemaphore)(1);
+            const output = [];
+            yield Promise.all([
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(1);
+                    yield new Promise(f => setTimeout(f, 100));
+                    output.push(2);
+                })),
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(3);
+                    yield new Promise(f => setTimeout(f, 50));
+                    output.push(4);
+                }))
+            ]);
+            assert(output.length == 4 &&
+                output[0] == 1 &&
+                output[1] == 2 &&
+                output[2] == 3 &&
+                output[3] == 4);
+        });
+    },
+    semaphore2() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sema = (0, semaphore_1.makeSemaphore)(2);
+            const output = [];
+            yield Promise.all([
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(1);
+                    yield new Promise(f => setTimeout(f, 100));
+                    output.push(2);
+                })),
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(3);
+                    yield new Promise(f => setTimeout(f, 50));
+                    output.push(4);
+                }))
+            ]);
+            assert(output.length == 4 &&
+                output[0] == 1 &&
+                output[1] == 3 &&
+                output[2] == 4 &&
+                output[3] == 2);
+        });
+    },
+    semaphore3() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sema = (0, semaphore_1.makeSemaphore)(1);
+            const output = [];
+            yield Promise.all([
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(1);
+                    yield new Promise(f => setTimeout(f, 100));
+                    output.push(2);
+                }), () => {
+                    throw new Error("Canceled");
+                }).then(() => assert(false), err => assert(err.message == "Canceled")),
+                sema.runTask(() => __awaiter(this, void 0, void 0, function* () {
+                    output.push(3);
+                    yield new Promise(f => setTimeout(f, 50));
+                    output.push(4);
+                }))
+            ]);
+            assert(output.length == 2 &&
+                output[0] == 3 &&
+                output[1] == 4);
+        });
+    },
+};

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/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function mockTimer(): {
+    sleep(duration: number): Promise<void>;
+    run(): void;
+};

package/dist/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTimer = void 0;
+function mockTimer() {
+    const queue = [];
+    return {
+        sleep(duration) {
+            return new Promise(f => queue.push({ callback: f, duration }));
+        },
+        run() {
+            queue.sort((a, b) => a.duration - b.duration);
+            for (const { callback } of queue)
+                callback();
+        }
+    };
+}
+exports.mockTimer = mockTimer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsdsoftware/utils",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "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;