superlib 1.0.21 → 1.2.0

package/dist/platform/filesystem/AbsolutePath.js

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import * as pathModule from "node:path";
+class AbsolutePathClazz {
+    path;
+    constructor(path) {
+        assert(pathModule.isAbsolute(path), `Path is not absolute, was: ${path}`);
+        const normalizedPath = pathModule.resolve(path);
+        this.path = normalizedPath;
+    }
+    join(...paths) {
+        return AbsolutePath(pathModule.join(this.path, ...paths));
+    }
+    dirname() {
+        return AbsolutePath(pathModule.dirname(this.path));
+    }
+    /**
+     * Note: this returns string representing relative path
+     */
+    relativeFrom(root) {
+        return pathModule.relative(root.path, this.path);
+    }
+}
+function AbsolutePathClass(absolutePath) {
+    return new AbsolutePathClazz(absolutePath);
+}
+Object.setPrototypeOf(AbsolutePathClass, AbsolutePathClazz);
+AbsolutePathClass.prototype = AbsolutePathClazz.prototype;
+export const AbsolutePath = Object.assign(AbsolutePathClass, AbsolutePathClazz);

package/dist/platform/filesystem/FileSystem.d.ts

@@ -0,0 +1,19 @@
+import type { DirRemoveError, FileAccessError, FileWriteError, IFileSystem } from "./IFileSystem";
+import { Result } from "../../basic/Result";
+import { AbsolutePath } from "./AbsolutePath";
+export declare class FileSystem implements IFileSystem {
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    createDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    removeDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    createTempDir(prefix: string): Promise<AsyncDisposable & {
+        path: AbsolutePath;
+    }>;
+}
+//# sourceMappingURL=FileSystem.d.ts.map

package/dist/platform/filesystem/FileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/FileSystem.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEjG,OAAO,EAAM,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,qBAAa,UAAW,YAAW,WAAW;IACtC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAkBtE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAgBtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAS5C,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,eAAe,CACnB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IA6ClC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC;CAWvF"}

package/dist/platform/filesystem/FileSystem.js

@@ -0,0 +1,92 @@
+import { access, mkdir, mkdtemp, readFile, rm, rmdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as pathModule from "node:path";
+import { Ok, Result } from "../../basic/Result.js";
+import { ResultAsync } from "../../basic/ResultAsync.js";
+import { AbsolutePath } from "./AbsolutePath.js";
+export class FileSystem {
+    async readFile(path) {
+        return ResultAsync.try(() => readFile(path.path, "utf8"), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "ENOENT":
+                        return { type: "fs/file-not-found", path };
+                    case "EISDIR":
+                        return { type: "fs/file-is-a-dir", path };
+                }
+            }
+            return { type: "fs/other", cause: error };
+        }).toPromise();
+    }
+    async writeFile(path, contents) {
+        return ResultAsync.try(() => writeFile(path.path, contents, "utf8"), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "EISDIR":
+                        return { type: "fs/file-is-a-dir", path };
+                }
+            }
+            return { type: "fs/other", cause: error };
+        }).toPromise();
+    }
+    async exists(path) {
+        try {
+            await access(path.path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createDirectory(path, options) {
+        await mkdir(path.path, { recursive: options.recursive });
+    }
+    async removeDirectory(path, options) {
+        // @todo it might be possible to simplify this
+        if (options.recursive) {
+            return ResultAsync.try(() => rm(path.path, { recursive: true, force: options.force }), (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "ENOENT":
+                            return { type: "fs/dir-not-found", path };
+                    }
+                }
+                return {
+                    type: "fs/other",
+                    cause: error,
+                };
+            }).toPromise();
+        }
+        return ResultAsync.try(() => rmdir(path.path), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "EEXIST":
+                    case "ENOTEMPTY":
+                        return { type: "fs/dir-not-empty", path };
+                    case "ENOENT": {
+                        if (options.force) {
+                            return Ok();
+                        }
+                        else {
+                            return { type: "fs/dir-not-found", path };
+                        }
+                    }
+                }
+            }
+            return {
+                type: "fs/other",
+                cause: error,
+            };
+        }).toPromise();
+    }
+    async createTempDir(prefix) {
+        const tempDirPath = await mkdtemp(pathModule.join(tmpdir(), prefix));
+        const tempPath = AbsolutePath(tempDirPath);
+        return {
+            path: tempPath,
+            async [Symbol.asyncDispose]() {
+                await rm(tempPath.path, { recursive: true, force: true });
+            },
+        };
+    }
+}

package/dist/platform/filesystem/IFileSystem.d.ts

@@ -0,0 +1,46 @@
+import type { Result } from "../../basic/Result";
+import type { AbsolutePath } from "./AbsolutePath";
+export interface IFileSystem {
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    createDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    removeDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    createTempDir(prefix: string): Promise<AsyncDisposable & {
+        path: AbsolutePath;
+    }>;
+}
+export type FileAccessError = {
+    type: "fs/file-not-found";
+    path: AbsolutePath;
+} | {
+    type: "fs/file-is-a-dir";
+    path: AbsolutePath;
+} | {
+    type: "fs/other";
+    cause: unknown;
+};
+export type FileWriteError = {
+    type: "fs/file-is-a-dir";
+    path: AbsolutePath;
+} | {
+    type: "fs/other";
+    cause: unknown;
+};
+export type DirAccessError = {
+    type: "fs/dir-not-found";
+    path: AbsolutePath;
+} | {
+    type: "fs/other";
+    cause: unknown;
+};
+export type DirRemoveError = DirAccessError | {
+    type: "fs/dir-not-empty";
+    path: AbsolutePath;
+};
+//# sourceMappingURL=IFileSystem.d.ts.map

package/dist/platform/filesystem/IFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IFileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/IFileSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGlD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;IACtE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IACtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5C,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnF,eAAe,CACb,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IAExC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC,CAAA;CACjF;AAED,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA"}

package/dist/platform/filesystem/IFileSystem.js

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

package/dist/platform/filesystem/MemoryFileSystem.d.ts

@@ -0,0 +1,29 @@
+import type { DirRemoveError, FileAccessError, FileWriteError, IFileSystem } from "./IFileSystem";
+import { type Result } from "../../basic/Result";
+import { AbsolutePath } from "./AbsolutePath";
+type TempDirHandle = AsyncDisposable & {
+    path: AbsolutePath;
+};
+export declare class MemoryFileSystem implements IFileSystem {
+    private readonly files;
+    private readonly directories;
+    private readonly root;
+    private tempDirCounter;
+    constructor();
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    createDirectory(dirPath: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    removeDirectory(dirPath: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    createTempDir(prefix: string): Promise<TempDirHandle>;
+    private removeDirectoryRecursive;
+    private isWithinDir;
+    private hasEntriesWithin;
+}
+export {};
+//# sourceMappingURL=MemoryFileSystem.d.ts.map

package/dist/platform/filesystem/MemoryFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryFileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/MemoryFileSystem.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEjG,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,KAAK,aAAa,GAAG,eAAe,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA;AAE7D,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IAEzC,OAAO,CAAC,cAAc,CAAI;;IAMpB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAatE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAUtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAI5C,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BtF,eAAe,CACnB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAsBlC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiB3D,OAAO,CAAC,wBAAwB;IAgBhC,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,gBAAgB;CAezB"}

package/dist/platform/filesystem/MemoryFileSystem.js

@@ -0,0 +1,126 @@
+import * as pathModule from "node:path";
+import { Err, Ok } from "../../basic/Result.js";
+import { AbsolutePath } from "./AbsolutePath.js";
+export class MemoryFileSystem {
+    files = new Map();
+    directories = new Set();
+    root = AbsolutePath("/");
+    tempDirCounter = 0; // used for numbering of temp dirs
+    constructor() {
+        this.directories.add(this.root.path);
+    }
+    async readFile(path) {
+        if (this.directories.has(path.path)) {
+            return Err({ type: "fs/file-is-a-dir", path });
+        }
+        const contents = this.files.get(path.path);
+        if (contents === undefined) {
+            return Err({ type: "fs/file-not-found", path });
+        }
+        return Ok(contents);
+    }
+    async writeFile(path, contents) {
+        await this.createDirectory(path.dirname(), { recursive: true });
+        if (this.directories.has(path.path)) {
+            return Err({ type: "fs/file-is-a-dir", path });
+        }
+        this.files.set(path.path, contents);
+        return Ok();
+    }
+    async exists(path) {
+        return this.files.has(path.path) || this.directories.has(path.path);
+    }
+    async createDirectory(dirPath, options) {
+        if (this.directories.has(dirPath.path)) {
+            if (!options.recursive) {
+                throw new Error(`Directory already exists: ${dirPath.path}`);
+            }
+            return;
+        }
+        const parentPath = dirPath.dirname();
+        if (!options.recursive && !this.directories.has(parentPath.path)) {
+            throw new Error(`Parent directory does not exist: ${parentPath.path}`);
+        }
+        if (options.recursive) {
+            let current = dirPath.path;
+            while (!this.directories.has(current)) {
+                this.directories.add(current);
+                const parentPath = pathModule.dirname(current);
+                if (parentPath === current) {
+                    break;
+                }
+                current = parentPath;
+            }
+        }
+        else {
+            this.directories.add(dirPath.path);
+        }
+    }
+    async removeDirectory(dirPath, options) {
+        if (!this.directories.has(dirPath.path)) {
+            if (options.force) {
+                return Ok();
+            }
+            return Err({ type: "fs/dir-not-found", path: dirPath });
+        }
+        const hasChildren = this.hasEntriesWithin(dirPath.path);
+        if (hasChildren && !options.recursive) {
+            return Err({ type: "fs/dir-not-empty", path: dirPath });
+        }
+        if (options.recursive) {
+            this.removeDirectoryRecursive(dirPath.path);
+        }
+        else {
+            this.directories.delete(dirPath.path);
+        }
+        return Ok();
+    }
+    async createTempDir(prefix) {
+        const tempDirPath = this.root.join("tmp", `${prefix}${this.tempDirCounter++}`);
+        await this.createDirectory(tempDirPath, { recursive: true });
+        const removeTempDir = () => {
+            this.removeDirectoryRecursive(tempDirPath.path);
+        };
+        return {
+            path: tempDirPath,
+            async [Symbol.asyncDispose]() {
+                removeTempDir();
+            },
+        };
+    }
+    removeDirectoryRecursive(dirPath) {
+        for (const filePath of this.files.keys()) {
+            if (this.isWithinDir(filePath, dirPath)) {
+                this.files.delete(filePath);
+            }
+        }
+        for (const directoryPath of Array.from(this.directories)) {
+            if (this.isWithinDir(directoryPath, dirPath)) {
+                this.directories.delete(directoryPath);
+            }
+        }
+        this.directories.add(this.root.path);
+    }
+    isWithinDir(targetPath, dirPath) {
+        const relative = pathModule.relative(dirPath, targetPath);
+        if (relative === "") {
+            return true;
+        }
+        return (!relative.startsWith(`..${pathModule.sep}`) &&
+            relative !== ".." &&
+            !pathModule.isAbsolute(relative));
+    }
+    hasEntriesWithin(dirPath) {
+        for (const filePath of this.files.keys()) {
+            if (this.isWithinDir(filePath, dirPath) && filePath !== dirPath) {
+                return true;
+            }
+        }
+        for (const directoryPath of this.directories) {
+            if (this.isWithinDir(directoryPath, dirPath) && directoryPath !== dirPath) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/platform/filesystem/index.d.ts

@@ -0,0 +1,5 @@
+export { type IFileSystem } from "./IFileSystem";
+export { FileSystem } from "./FileSystem";
+export { MemoryFileSystem } from "./MemoryFileSystem";
+export { AbsolutePath } from "./AbsolutePath";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/platform/filesystem/index.js

@@ -0,0 +1,4 @@
+export {} from "./IFileSystem.js";
+export { FileSystem } from "./FileSystem.js";
+export { MemoryFileSystem } from "./MemoryFileSystem.js";
+export { AbsolutePath } from "./AbsolutePath.js";

package/dist/platform/get-port/checkPort.d.ts

@@ -0,0 +1,2 @@
+export declare function checkPort(port: number): Promise<boolean>;
+//# sourceMappingURL=checkPort.d.ts.map

package/dist/platform/get-port/checkPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPort.d.ts","sourceRoot":"","sources":["../../../src/platform/get-port/checkPort.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBxD"}

package/dist/platform/get-port/checkPort.js

@@ -0,0 +1,20 @@
+import { createServer } from "node:net";
+export function checkPort(port) {
+    return new Promise((resolve) => {
+        try {
+            const server = createServer();
+            server.unref();
+            server.on("error", () => {
+                resolve(false);
+            });
+            server.listen(port, "localhost", () => {
+                server.close(() => {
+                    resolve(true);
+                });
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/platform/get-port/getPort.d.ts

@@ -0,0 +1,8 @@
+import { type IRandom } from "../../random";
+interface GetPortDependencies {
+    random: IRandom;
+    checkPort: (port: number) => Promise<boolean>;
+}
+export declare function getPort(dependencies?: GetPortDependencies): Promise<number>;
+export {};
+//# sourceMappingURL=getPort.d.ts.map

package/dist/platform/get-port/getPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPort.d.ts","sourceRoot":"","sources":["../../../src/platform/get-port/getPort.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAGvD,UAAU,mBAAmB;IAC3B,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAE9C;AAED,wBAAsB,OAAO,CAC3B,YAAY,GAAE,mBAA6D,GAC1E,OAAO,CAAC,MAAM,CAAC,CAUjB"}

package/dist/platform/get-port/getPort.js

@@ -0,0 +1,13 @@
+import { RealRandom } from "../../random/index.js";
+import { checkPort } from "./checkPort.js";
+export async function getPort(dependencies = { random: new RealRandom(), checkPort }) {
+    while (true) {
+        const port = dependencies.random.nextInteger(LOW_PORT, HIGH_PORT);
+        const isAvailable = await dependencies.checkPort(port);
+        if (isAvailable) {
+            return port;
+        }
+    }
+}
+const LOW_PORT = 49152;
+const HIGH_PORT = 65535;

package/dist/platform/safeFetch/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./makeSafeFetch";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/safeFetch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/safeFetch/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/platform/safeFetch/index.js

@@ -0,0 +1 @@
+export * from "./makeSafeFetch.js";

package/dist/platform/safeFetch/makeSafeFetch.d.ts

@@ -0,0 +1,23 @@
+import type { TimeoutErr } from "../../task/timeout";
+import type { DurationLike } from "../../time";
+import { type Result } from "../../basic";
+import { type RetryOptions } from "../../task/retry";
+export interface SafeFetchOptions {
+    retry?: RetryOptions<SafeFetchResult> & {
+        untilStatus?: UntilStatusFn;
+    };
+    timeout?: DurationLike;
+}
+type UntilStatusFn = (status: number) => boolean;
+export type SafeFetchError = {
+    type: "fetch/network";
+    cause: unknown;
+} | {
+    type: "fetch/http";
+    status: number;
+} | TimeoutErr;
+export type SafeFetchResult = Result<Response, SafeFetchError>;
+export type SafeFetch = (...args: Parameters<typeof fetch>) => Promise<SafeFetchResult>;
+export declare function makeSafeFetch(options: SafeFetchOptions): SafeFetch;
+export {};
+//# sourceMappingURL=makeSafeFetch.d.ts.map

package/dist/platform/safeFetch/makeSafeFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeSafeFetch.d.ts","sourceRoot":"","sources":["../../../src/platform/safeFetch/makeSafeFetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,OAAO,EAAwB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AAE/D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,YAAY,CAAC,eAAe,CAAC,GAAG;QAAE,WAAW,CAAC,EAAE,aAAa,CAAA;KAAE,CAAA;IACvE,OAAO,CAAC,EAAE,YAAY,CAAA;CACvB;AAED,KAAK,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAA;AAEhD,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtC,UAAU,CAAA;AAEd,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAA;AAE9D,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAEvF,wBAAgB,aAAa,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CA0BlE"}

package/dist/platform/safeFetch/makeSafeFetch.js

@@ -0,0 +1,19 @@
+import { Err, Ok, ResultAsync } from "../../basic/index.js";
+import { Task } from "../../task/index.js";
+import {} from "../../task/retry.js";
+export function makeSafeFetch(options) {
+    const untilStatus = options.retry?.untilStatus ?? ((status) => status >= 200 && status < 300);
+    return async (url, requestInit = {}) => {
+        const fetchTask = async () => {
+            return ResultAsync.try(() => fetch(url, requestInit), (error) => ({ type: "fetch/network", cause: error }))
+                .andThen((response) => {
+                if (!untilStatus(response.status)) {
+                    return Err({ type: "fetch/http", status: response.status });
+                }
+                return Ok(response);
+            })
+                .toPromise();
+        };
+        return Task.pipe(fetchTask, options.timeout && Task.timeout({ timeout: options.timeout, useResult: true }), options.retry && Task.retry(options.retry));
+    };
+}

package/dist/random/FixedRandom.d.ts

@@ -0,0 +1,12 @@
+import type { IRandom } from "./Random";
+export declare class FixedRandom implements IRandom {
+    private readonly sequence;
+    private index;
+    constructor(sequence: any[]);
+    private takeValue;
+    next(): number;
+    nextInteger(min: number, max: number): number;
+    nextNumber(min: number, max: number): number;
+    nextBoolean(): boolean;
+}
+//# sourceMappingURL=FixedRandom.d.ts.map

package/dist/random/FixedRandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixedRandom.d.ts","sourceRoot":"","sources":["../../src/random/FixedRandom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAIvC,qBAAa,WAAY,YAAW,OAAO;IAE7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IADrC,OAAO,CAAC,KAAK,CAAI;gBACY,QAAQ,EAAE,GAAG,EAAE;IAE5C,OAAO,CAAC,SAAS;IAOjB,IAAI,IAAI,MAAM;IAUd,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAoB7C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAc5C,WAAW,IAAI,OAAO;CAKvB"}

package/dist/random/FixedRandom.js

@@ -0,0 +1,43 @@
+import { assert } from "../basic/index.js";
+export class FixedRandom {
+    sequence;
+    index = 0;
+    constructor(sequence) {
+        this.sequence = sequence;
+    }
+    takeValue(methodName) {
+        assert(this.index < this.sequence.length, `FixedRandom.${methodName} sequence is exhausted`);
+        const value = this.sequence[this.index];
+        this.index += 1;
+        return value;
+    }
+    next() {
+        const value = this.takeValue("next");
+        assert(Number.isFinite(value), `FixedRandom.next expected number, got: ${value}`);
+        assert(value >= 0 && value < 1, `FixedRandom.next expected number in range <0;1), got: ${value}`);
+        return value;
+    }
+    nextInteger(min, max) {
+        assert(Number.isInteger(min) && !Number.isNaN(min), `min is expected to be an integer, was: ${min}`);
+        assert(Number.isInteger(max) && !Number.isNaN(max), `max is expected to be an integer, was: ${max}`);
+        assert(min < max, `expected min to be less than max, min=${min} max=${max}`);
+        const value = this.takeValue("nextInteger");
+        assert(Number.isInteger(value), `FixedRandom.nextInteger expected integer, got: ${value}`);
+        assert(value >= min && value <= max, `FixedRandom.nextInteger expected integer in range <${min};${max}>, got: ${value}`);
+        return value;
+    }
+    nextNumber(min, max) {
+        assert(Number.isFinite(min), `min is expected to be a number, was: ${min}`);
+        assert(Number.isFinite(max), `max is expected to be a number, was: ${max}`);
+        assert(min < max, `expected min to be less than max, min=${min} max=${max}`);
+        const value = this.takeValue("nextNumber");
+        assert(Number.isFinite(value), `FixedRandom.nextNumber expected number, got: ${value}`);
+        assert(value >= min && value < max, `FixedRandom.nextNumber expected number in range <${min};${max}), got: ${value}`);
+        return value;
+    }
+    nextBoolean() {
+        const value = this.takeValue("nextBoolean");
+        assert(typeof value === "boolean", `FixedRandom.nextBoolean expected boolean, got: ${value}`);
+        return value;
+    }
+}

package/dist/random/Random.d.ts

@@ -0,0 +1,18 @@
+import type { PublicInterface } from "../types";
+export type IRandom = PublicInterface<AbstractRandom>;
+export declare abstract class AbstractRandom {
+    /**
+     * Returns next random number in range of <0;1)
+     */
+    abstract next(): number;
+    /**
+     * Returns next random integer in range of <min;max>
+     */
+    nextInteger(min: number, max: number): number;
+    /**
+     * Returns next random number in range of <min, max)
+     */
+    nextNumber(min: number, max: number): number;
+    nextBoolean(): boolean;
+}
+//# sourceMappingURL=Random.d.ts.map

package/dist/random/Random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/random/Random.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAI/C,MAAM,MAAM,OAAO,GAAG,eAAe,CAAC,cAAc,CAAC,CAAA;AAErD,8BAAsB,cAAc;IAClC;;OAEG;IACH,QAAQ,CAAC,IAAI,IAAI,MAAM;IAEvB;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAc7C;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAQ5C,WAAW,IAAI,OAAO;CAGvB"}

package/dist/random/Random.js

@@ -0,0 +1,24 @@
+import { assert } from "../basic/assert.js";
+export class AbstractRandom {
+    /**
+     * Returns next random integer in range of <min;max>
+     */
+    nextInteger(min, max) {
+        assert(Number.isInteger(min) && !Number.isNaN(min), `min is expected to be an integer, was: ${min}`);
+        assert(Number.isInteger(max) && !Number.isNaN(max), `max is expected to be an integer, was: ${max}`);
+        assert(min < max, `expected min to be less than max, min=${min} max=${max}`);
+        return Math.floor(this.next() * (max - min + 1)) + min;
+    }
+    /**
+     * Returns next random number in range of <min, max)
+     */
+    nextNumber(min, max) {
+        assert(Number.isFinite(min), `min is expected to be a number, was: ${min}`);
+        assert(Number.isFinite(max), `max is expected to be a number, was: ${max}`);
+        assert(min < max, `expected min to be less than max, min=${min} max=${max}`);
+        return this.next() * (max - min) + min;
+    }
+    nextBoolean() {
+        return this.nextInteger(0, 1) === 1;
+    }
+}

package/dist/random/RealRandom.d.ts

@@ -0,0 +1,5 @@
+import { AbstractRandom } from "./Random";
+export declare class RealRandom extends AbstractRandom {
+    next(): number;
+}
+//# sourceMappingURL=RealRandom.d.ts.map

package/dist/random/RealRandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealRandom.d.ts","sourceRoot":"","sources":["../../src/random/RealRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC,qBAAa,UAAW,SAAQ,cAAc;IAC5C,IAAI,IAAI,MAAM;CAGf"}

package/dist/random/RealRandom.js

@@ -0,0 +1,6 @@
+import { AbstractRandom } from "./Random.js";
+export class RealRandom extends AbstractRandom {
+    next() {
+        return Math.random();
+    }
+}

package/dist/random/SeededRandom.d.ts

@@ -0,0 +1,10 @@
+import { AbstractRandom } from "./Random";
+export declare class SeededRandom extends AbstractRandom {
+    private m;
+    private a;
+    private c;
+    private state;
+    constructor(seed?: number);
+    next(): number;
+}
+//# sourceMappingURL=SeededRandom.d.ts.map

package/dist/random/SeededRandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeededRandom.d.ts","sourceRoot":"","sources":["../../src/random/SeededRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC,qBAAa,YAAa,SAAQ,cAAc;IAC9C,OAAO,CAAC,CAAC,CAAU;IACnB,OAAO,CAAC,CAAC,CAAa;IACtB,OAAO,CAAC,CAAC,CAAQ;IACjB,OAAO,CAAC,KAAK,CAAQ;gBAET,IAAI,GAAE,MAAgB;IAK3B,IAAI,IAAI,MAAM;CAItB"}