functionalscript 0.22.0 → 0.24.0

package/fs/io/module.js

@@ -1,132 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import http from 'node:http';
-import childProcess from 'node:child_process';
-import fs from 'node:fs';
-import process from 'node:process';
-import { concat } from "../path/module.f.js";
-import { once } from 'node:events';
-import { runProgram } from "./module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { fromVec } from "../types/uint8array/module.f.js";
-import * as testContext from 'node:test';
-const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
-const pwTest = isPlaywright
-    ? (await import('@playwright/test')).test
-    : undefined;
-const inlineTest = async (name, { expectFailure }, fn) => {
-    if (expectFailure) {
-        try {
-            await fn(inlineContext);
-        }
-        catch {
-            return;
-        }
-        throw new Error(`expected to throw: ${name}`);
-    }
-    else {
-        await fn(inlineContext);
-    }
-};
-const inlineContext = { test: inlineTest };
-const wrapInlineTest = (register) => ({
-    test: (name, opts, fn) => register(name, () => inlineTest(name, opts, fn))
-});
-const bunTestContext = wrapInlineTest(testContext.test);
-const playwrightTestContext = wrapInlineTest(pwTest);
-const prefix = 'file:///';
-const { now } = Date;
-/** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
-const streams = {
-    stdout: process.stdout,
-    stderr: process.stderr,
-};
-/**
- * Writes `data` to `stream` respecting Node.js backpressure.
- *
- * `stream.write()` returns `false` when the internal buffer is full; the data
- * is already buffered at that point (no retry needed) but the caller must not
- * issue more writes until the `'drain'` event fires. Waiting here throttles the
- * producer to the speed of the OS consumer, preventing unbounded memory growth
- * when many large messages arrive faster than they can be flushed.
- *
- * When the buffer is not full `write()` returns `true` and we return
- * immediately, so large computations with occasional prints never stall.
- *
- * @see {@link https://nodejs.org/api/stream.html#writablewritechunk}
- */
-const writeAll = async (stream, data) => {
-    if (!stream.write(data)) {
-        await once(stream, 'drain');
-    }
-};
-export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
-export const tryCatch = f => {
-    try {
-        return ok(f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
-export const io = {
-    console,
-    fs,
-    process,
-    asyncImport: (v) => {
-        const s0 = v.includes(':') || v.startsWith('/') ? v : concat(process.cwd())(v);
-        const s1 = s0.startsWith(prefix) ? s0 : `${prefix}${s0}`;
-        return asyncImport(s1);
-    },
-    performance,
-    fetch,
-    tryCatch,
-    asyncTryCatch: async (f) => {
-        try {
-            return ok(await f());
-        }
-        catch (e) {
-            return error(e);
-        }
-    },
-    http,
-    childProcess,
-    now,
-    sandbox: async (f) => {
-        let result;
-        let after;
-        const before = performance.now();
-        try {
-            let p = f();
-            after = performance.now();
-            if (p instanceof Promise) {
-                p = await p;
-                after = performance.now();
-            }
-            result = ok(p);
-        }
-        catch (e) {
-            after = performance.now();
-            result = error(e);
-        }
-        return { result, duration: after - before };
-    },
-    write: (stream, data) => writeAll(streams[stream], fromVec(data)),
-    await: awaitPromise,
-    testContext,
-    bunTestContext,
-    playwrightTestContext,
-    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
-};
-const effectRun = async (p) => {
-    const code = await runProgram(io)(io.process.argv.slice(2))(p);
-    return process.exit(code);
-};
-export default effectRun;