functionalscript 0.17.0 → 0.19.0

package/fs/dev/tf/module.f.js

@@ -3,9 +3,11 @@
  *
  * @module
  */
-import { fold } from "../../types/list/module.f.js";
-import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
-import { env, loadModuleMap } from "../module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
+import { all, sandbox, test } from "../../types/effects/node/module.f.js";
+import { pure, do_ } from "../../types/effects/module.f.js";
+import { loadModuleMap } from "../module.f.js";
+import { invert } from "../../types/result/module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
@@ -18,24 +20,12 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (sandbox) => (throws) => (x) => {
+export const parseTestSet = (throws, x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
-                const xt = x;
-                if (!throws && xt.name !== 'throw') {
-                    return xt;
-                }
-                // Pass-on-throw: the test passes if it throws. Triggered when the
-                // enclosing tree node is named 'throw' (so any function reference
-                // works, not only inline ones whose inferred name is 'throw').
-                return () => {
-                    const { result: [tag, value] } = sandbox(xt);
-                    if (tag === 'ok') {
-                        throw value;
-                    }
-                    return value;
-                };
+                const fn = x;
+                return { fn, throws: throws || fn.name === 'throw' };
             }
             break;
         }
@@ -48,77 +38,166 @@ export const parseTestSet = (sandbox) => (throws) => (x) => {
     }
     return [];
 };
-const test = async (io) => {
-    const moduleMap = await loadModuleMap(io);
-    const log = stdio(io);
-    const error = stderr(io);
-    const { sandbox } = io;
-    const env_ = env(io);
-    const isGitHub = env_('GITHUB_ACTION') !== undefined;
-    const parse = parseTestSet(sandbox);
-    const f = ([k, v]) => {
-        const test = i => throws => v => ts => {
-            const next = test(`${i}| `);
-            const set = parse(throws)(v);
-            if (typeof set === 'function') {
-                const { result: [s, r], duration: delta } = sandbox(set);
-                if (s !== 'ok') {
-                    ts = addFail(delta)(ts);
-                    if (isGitHub) {
-                        // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                        error(`::error file=${k},line=1,title=${i}()::${r}`);
-                    }
-                    else {
-                        error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
-                        error(`${fgRed}${r}${reset}`);
-                    }
-                }
-                else {
-                    ts = addPass(delta)(ts);
-                    log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                    // The result of a function is walked as a fresh sub-tree;
-                    // the parent's `throws` flag does not propagate into it.
-                    ts = next(false)(r)(ts);
-                }
-            }
-            else {
-                const f = ([k, v]) => ts => {
-                    log(`${i}${k}:`);
-                    ts = next(throws || k === 'throw')(v)(ts);
-                    return ts;
-                };
-                ts = fold(f)(ts)(set);
-            }
-            return ts;
-        };
-        return ts => {
-            if (isTest(k)) {
-                log(`testing ${k}`);
-                ts = test('| ')(false)(v.default)(ts);
-                // Non-default exports are walked as a sibling test group so
-                // a test file can spread its tests across multiple named
-                // exports (see issue 27 in `issues/README.md`). Skip exports
-                // that parseTestSet would treat as empty (constants, types,
-                // non-test helpers) to avoid noisy empty entries in output.
-                const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
-                    (typeof val === 'object' && val !== null))));
-                if (Object.keys(others).length !== 0) {
-                    ts = test('| ')(false)(others)(ts);
+/**
+ * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
+ * pairs, without running anything. Return-value sub-trees are not walked
+ * (that requires execution); only the static object/array/function structure
+ * is traversed.
+ */
+export const collectTests = (path, throws, v) => {
+    const set = parseTestSet(throws, v);
+    if (set instanceof Array) {
+        return set.flatMap(([ck, cv]) => collectTests([...path, ck], throws || ck === 'throw', cv));
+    }
+    return [[path, set]];
+};
+export const registerModule = (ctx, k, v) => {
+    const registerOne = (ctx, [path, { fn, throws }]) => test(ctx, fmtImport(k, path), throws, (t) => {
+        if (throws) {
+            fn();
+            return pure(undefined);
+        }
+        const r = fn();
+        const sub = collectTests([...path, null], false, r);
+        if (sub.length === 0) {
+            return pure(undefined);
+        }
+        return all(...sub.map(e => registerOne(t, e))).step(() => pure(undefined));
+    });
+    const tests = collectTests([], false, v);
+    if (tests.length === 0) {
+        return pure(undefined);
+    }
+    return all(...tests.map(e => registerOne(ctx, e))).step(() => pure(undefined));
+};
+const mergeState = (a, b) => ({ time: a.time + b.time, pass: a.pass + b.pass, fail: a.fail + b.fail });
+const zero = { time: 0, pass: 0, fail: 0 };
+const runModule = ({ result, test }) => (k, v) => (ts) => {
+    const one = ([testPath, set]) => test(k, testPath, set)
+        .step(sr => {
+        const { result: [s, r], duration } = sr;
+        return result(k, testPath, sr)
+            .step(() => {
+            if (s === 'ok') {
+                if (set.throws) {
+                    return pure(addPass(duration)(zero));
                 }
+                // Walk return-value sub-tree; null marks the call boundary so
+                // paths render as e.g. `outer().inner`. throws resets to false.
+                return walk([...testPath, null], false, r)
+                    .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
             }
-            return ts;
-        };
+            return pure(addFail(duration)(zero));
+        });
+    });
+    const walk = (path, throws, v) => {
+        const effects = collectTests(path, throws, v).map(one);
+        return all(...effects)
+            .step(states => pure(states.reduce(mergeState, zero)));
     };
-    let ts = { time: 0, pass: 0, fail: 0 };
-    ts = fold(f)(ts)(Object.entries(moduleMap));
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
-    log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
-    return ts.fail !== 0 ? 1 : 0;
+    return walk([], false, v)
+        .step(delta => pure(mergeState(ts, delta)));
+};
+const { entries } = Object;
+export const runModuleMap = (reporter) => (moduleMap) => {
+    const { summary } = reporter;
+    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+    return modules.reduce((acc, [k, v]) => acc.step(runModule(reporter)(k, v)), pure({ time: 0, pass: 0, fail: 0 }))
+        .step(ts => summary(ts.pass, ts.fail, ts.time)
+        .step(() => pure(ts.fail !== 0 ? 1 : 0)));
+};
+export const testAll = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+export const registerModuleMap = (ctx, moduleMap) => {
+    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+    if (modules.length === 0) {
+        return pure(undefined);
+    }
+    return all(...modules.map(([k, v]) => registerModule(ctx, k, v))).step(() => pure(undefined));
 };
-export const anyLog = (f) => (s) => (state) => {
-    f(s);
-    return state;
+const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
+const isDigit = (c) => c >= '0' && c <= '9';
+export const isInteger = (s) => s.length > 0 && [...s].every(isDigit) && (s === '0' || s[0] !== '0');
+export const isIdentifier = (s) => s.length > 0 && isAlpha(s[0]) && [...s.slice(1)].every(c => isAlpha(c) || isDigit(c));
+const fmtKey = (k) => k === null ? '()'
+    : isInteger(k) ? `[${k}]`
+        : isIdentifier(k) ? `.${k}`
+            : `[${JSON.stringify(k)}]`;
+/**
+ * Renders a key chain as a JS property-access expression: identifier keys use
+ * dot notation, integer keys use `[N]`, other strings use `["key"]`, and `null`
+ * emits `()` to mark a function-call boundary.
+ * E.g. `['math', 'add']` → `.math.add`, `['outer', null, 'inner']` → `.outer().inner`.
+ */
+export const fmtPath = (path) => path.reduce((acc, k) => acc + fmtKey(k), '');
+/**
+ * Formats a fully-qualified test identifier as a JS-like expression, e.g.
+ * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * Self-contained per line — suitable for parallel output and as a CLI filter argument.
+ */
+export const fmtImport = (file, path) => `import(${JSON.stringify(file)})${fmtPath(path)}()`;
+/**
+ * Renders a key chain for terminal output: `| ` per level of depth, followed
+ * by the last segment formatted as a bare integer, a bare identifier, or a
+ * JSON-quoted string. E.g. `['math', 'add']` → `| | add`,
+ * `['a', '0']` → `| | 0`, `['x', 'hello world']` → `| | "hello world"`.
+ */
+export const fmtTerm = (path) => {
+    const keys = path.flatMap(k => k !== null ? [k] : []);
+    const indent = '| '.repeat(keys.length);
+    if (keys.length === 0) {
+        return `${indent}()`;
+    }
+    const last = keys[keys.length - 1];
+    return `${indent}${isInteger(last) || isIdentifier(last) ? last : JSON.stringify(last)}`;
+};
+/**
+ * Percent-encodes characters that GitHub workflow-command property values
+ * treat as separators (`%`, `:`, `,`) plus newlines.
+ * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+ */
+export const ghEscape = (s) => s.replaceAll('%', '%25')
+    .replaceAll(':', '%3A')
+    .replaceAll(',', '%2C')
+    .replaceAll('\r', '%0D')
+    .replaceAll('\n', '%0A');
+export const defaultTest = (file, path, { fn, throws }) => sandbox(fn)
+    .step(r => pure(throws ? { ...r, result: invert(r.result) } : r));
+const fmtResultLine = (file, path, color, label, duration) => `${fmtImport(file, path)}: ${color}${label}${reset}, ${timeFormat(duration)}`;
+/**
+ * The terminal/GitHub reporter used by `fjs t`. Output goes through
+ * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
+ * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * annotations instead of colored lines. Exported as a factory so the
+ * GitHub format path can be exercised directly from tests.
+ */
+export const defaultReporter = (options) => {
+    const write = csiWrite(options);
+    const line = (w) => {
+        const x = write(w);
+        return (s) => x(s + '\n');
+    };
+    const csiLog = line('stdout');
+    const csiError = line('stderr');
+    const isGitHub = options.env['GITHUB_ACTION'] !== undefined;
+    return {
+        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+        result: (file, path, { result: [s, v], duration }) => s === 'ok'
+            ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration))
+            : isGitHub
+                ? csiError(`::error file=${file},line=1,title=${ghEscape(fmtImport(file, path))}::${ghEscape(String(v))}`)
+                : csiError(fmtResultLine(file, path, fgRed, 'error', duration))
+                    .step(() => csiError(`${fgRed}${v}${reset}`)),
+        summary: (pass, fail, time) => {
+            const fgFail = fail === 0 ? fgGreen : fgRed;
+            return csiLog(`${bold}Number of tests: pass: ${fgGreen}${pass}${reset}${bold}, fail: ${fgFail}${fail}${reset}${bold}, total: ${pass + fail}${reset}`)
+                .step(() => csiLog(`${bold}Time: ${timeFormat(time)}${reset}`));
+        },
+        test: defaultTest,
+    };
 };
-export const main = test;
+export const main = options => testAll(defaultReporter(options))(options);
+export const register = o => loadModuleMap(o.env)
+    .step(m => registerModuleMap(o.engine === 'bun' ? o.bunTestContext :
+    o.engine === 'playwright' ? o.playwrightTestContext :
+        o.testContext, m))
+    .step(() => pure(0));

package/fs/dev/tf/module.js

@@ -1,54 +1,4 @@
 import { io } from "../../io/module.js";
-import { loadModuleMap2 } from "../module.f.js";
-import { isTest, parseTestSet } from "./module.f.js";
-import * as nodeTest from 'node:test';
-import { asyncImport } from "../../io/module.js";
-import { fromIo } from "../../io/module.f.js";
-const isBun = typeof Bun !== 'undefined';
-const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
-const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
-// Bun doesn't support nested tests yet.
-const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrightFramework = async () => {
-    const pwTest = (await asyncImport('@playwright/test')).test;
-    return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
-};
-const framework = isPlaywright ? await createPlaywrightFramework() :
-    isBun ? createBunFramework(nodeTest) :
-        createFramework(nodeTest);
-const parse = parseTestSet(io.sandbox);
-const scanModule = (x) => async (subTestRunner) => {
-    let subTests = [x];
-    while (true) {
-        const [first, ...rest] = subTests;
-        if (first === undefined) {
-            break;
-        }
-        subTests = rest;
-        //
-        const [name, value, throws] = first;
-        const set = parse(throws)(value);
-        if (typeof set === 'function') {
-            await subTestRunner(name, () => {
-                const r = set();
-                // The result of a function is walked as a fresh sub-tree;
-                // the parent's `throws` flag does not propagate into it.
-                subTests = [...subTests, [`${name}()`, r, false]];
-            });
-        }
-        else {
-            for (const [j, y] of set) {
-                const pr = `${name}/${j}`;
-                subTests = [...subTests, [pr, y, throws || j === 'throw']];
-            }
-        }
-    }
-};
-export const run = async () => {
-    const x = await fromIo(io)(loadModuleMap2(io.process.env));
-    for (const [i, v] of Object.entries(x)) {
-        if (isTest(i)) {
-            framework(i, scanModule(['', v.default, false]));
-        }
-    }
-};
+import { register } from "./module.f.js";
+import { runProgram } from "../../io/module.f.js";
+export const run = () => runProgram(io)([])(register);

package/fs/dev/tf/scenarios/all.d.ts

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

package/fs/dev/tf/scenarios/all.js

@@ -0,0 +1,3 @@
+import { run } from "../module.js";
+// we need `await` for Playwright.
+await run();

package/fs/dev/tf/scenarios/fail.fail.f.d.ts

@@ -0,0 +1 @@
+export declare const failing: () => never;

package/fs/dev/tf/scenarios/fail.fail.f.js

@@ -0,0 +1 @@
+export const failing = () => { throw 'intentional failure'; };

package/fs/dev/tf/scenarios/return-value.pass.f.d.ts

@@ -0,0 +1 @@
+export declare const outer: () => unknown;

package/fs/dev/tf/scenarios/return-value.pass.f.js

@@ -0,0 +1,2 @@
+const inner = () => { };
+export const outer = () => ({ inner });

package/fs/dev/tf/scenarios/throw.pass.f.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    throw: {
+        a: () => never;
+    };
+};
+export default _default;

package/fs/dev/tf/scenarios/throw.pass.f.js

@@ -0,0 +1,3 @@
+export default {
+    throw: { a: () => { throw 'expected'; } }
+};

package/fs/dev/tf/test.f.d.ts

@@ -1,21 +1,22 @@
-declare const _default: {
-    throw: () => never;
-    throwReference: {
-        throw: () => unknown;
-    };
-    throwGroup: {
-        throw: {
-            inline: () => never;
-            reference: () => unknown;
-            nested: {
-                deep: () => never;
-            };
-        };
-    };
-};
-export default _default;
-export declare const namedExportTest: () => void;
-export declare const namedExportGroup: {
-    nested: () => void;
-    throw: () => never;
+export declare const flat: () => void;
+export declare const nested: () => void;
+export declare const throwKey: () => void;
+export declare const throwKeyFail: () => void;
+export declare const mixedPassFail: () => void;
+export declare const returnValueSubTree: () => void;
+export declare const arrayKeys: () => void;
+export declare const nonTestFilesSkipped: () => void;
+export declare const multipleFiles: () => void;
+export declare const throwByFunctionName: () => void;
+export declare const namedExports: () => void;
+export declare const defaultReporterOutput: () => void;
+export declare const defaultReporterFailOutput: () => void;
+export declare const githubReporterOutput: () => void;
+export declare const helpers: {
+    isInteger: () => void;
+    isIdentifier: () => void;
+    fmtImport: () => void;
+    fmtPath: () => void;
+    fmtTerm: () => void;
+    ghEscape: () => void;
 };