functionalscript 0.17.0 → 0.18.0

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;
 };

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

@@ -1,36 +1,254 @@
-// A helper whose own `name` is not `'throw'`. The test framework should still
-// treat it as a pass-on-throw test when the enclosing key is `throw`.
-const helperThrows = () => { throw 'helper failure'; };
-export default {
-    throw: () => {
-        throw [() => { }, () => { }];
+import { pure } from "../../types/effects/module.f.js";
+import { emptyState } from "../../types/effects/node/virtual/module.f.js";
+import { virtual } from "../../types/effects/node/virtual/module.f.js";
+import { assert, assertEq } from "../module.f.js";
+import { test, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, defaultTest, } from "./module.f.js";
+const makeReporter = () => {
+    const events = [];
+    const reporter = {
+        result: (file, path, r) => { events.push(['result', file, [...path], r]); return pure(undefined); },
+        summary: (pass, fail, time) => { events.push(['summary', pass, fail, time]); return pure(undefined); },
+        test: defaultTest,
+    };
+    return [reporter, () => events];
+};
+const options = (initCwd, github = false) => ({
+    args: [],
+    env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTION: 'true' } : {}) },
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+});
+const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
+const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });
+const ok1 = () => ({ result: ['ok', undefined], duration: 1 });
+const run = (dir, initCwd = '.') => {
+    const [reporter, getEvents] = makeReporter();
+    const state = { ...emptyState, root: dir };
+    const [, exitCode] = virtual(state)(test(reporter)(options(initCwd)));
+    return [getEvents(), exitCode];
+};
+// Runs the real `defaultReporter` and returns its captured stdout/stderr so the
+// terminal and GitHub output formats can be asserted directly.
+const runMain = (dir, github = false) => {
+    const state = { ...emptyState, root: dir };
+    const opts = options('.', github);
+    const [finalState, exitCode] = virtual(state)(test(defaultReporter(opts))(opts));
+    return [finalState.stdout, finalState.stderr, exitCode];
+};
+// flat object: two passing tests
+export const flat = () => {
+    const [events, exit] = run({
+        'a.test.f.ts': () => ({ a: ok0, b: ok1 }),
+    });
+    assertEq(exit, 0);
+    const [e0, e1, e2] = events;
+    assert(e0[0] === 'result' && e0[2][0] === 'a');
+    assert(e1[0] === 'result' && e1[2][0] === 'b');
+    assertEq(e2[0], 'summary');
+    const [, pass, fail] = e2;
+    assertEq(pass, 2);
+    assertEq(fail, 0);
+};
+// nested object: leaf tests carry the full path including the sub-tree key
+export const nested = () => {
+    const [events, exit] = run({
+        'n.test.f.ts': () => ({ math: { add: ok0, sub: ok0 } }),
+    });
+    assertEq(exit, 0);
+    const [e0, e1, e2] = events;
+    assert(e0[0] === 'result' && e0[2][1] === 'add');
+    assert(e1[0] === 'result' && e1[2][1] === 'sub');
+    assertEq(e2[0], 'summary');
+    const [, pass, fail] = e2;
+    assertEq(pass, 2);
+    assertEq(fail, 0);
+};
+// throw key: tests inside 'throw' pass on error result
+export const throwKey = () => {
+    const [events, exit] = run({
+        't.test.f.ts': () => ({ throw: { a: fail0 } }),
+    });
+    assertEq(exit, 0);
+    const [e0, e1] = events;
+    assert(e0[0] === 'result' && e0[2][0] === 'throw' && e0[2][1] === 'a');
+    assertEq(e1[0], 'summary');
+    const [, pass, fail] = e1;
+    assertEq(pass, 1);
+    assertEq(fail, 0);
+};
+// throw key fails when test does not throw (returns ok in throw context)
+export const throwKeyFail = () => {
+    const [events, exit] = run({
+        't.test.f.ts': () => ({ throw: { a: ok0 } }),
+    });
+    assertEq(exit, 1);
+    const [e0, e1] = events;
+    assertEq(e0[0], 'result');
+    const [, pass, fail] = e1;
+    assertEq(pass, 0);
+    assertEq(fail, 1);
+};
+// mixed pass/fail updates summary counts
+export const mixedPassFail = () => {
+    const [events, exit] = run({
+        'm.test.f.ts': () => ({ good: ok0, bad: fail0 }),
+    });
+    assertEq(exit, 1);
+    const summary = events[events.length - 1];
+    assertEq(summary[0], 'summary');
+    const [, pass, fail] = summary;
+    assertEq(pass, 1);
+    assertEq(fail, 1);
+};
+// return-value sub-tree: passing test's return value is walked
+export const returnValueSubTree = () => {
+    const inner = () => ({ result: ['ok', undefined], duration: 0 });
+    const [events, exit] = run({
+        'r.test.f.ts': () => ({
+            outer: () => ({
+                result: ['ok', { inner }],
+                duration: 0,
+            }),
+        }),
+    });
+    // outer passes, then inner (from return value) also passes
+    assertEq(exit, 0);
+    const passEvents = events.filter(e => e[0] === 'result');
+    assertEq(passEvents.length, 2);
+    const [p0, p1] = passEvents;
+    assertEq(p0[2][0], 'outer');
+    assertEq(p1[2][2], 'inner');
+};
+// integer-indexed array keys appear as numeric path segments
+export const arrayKeys = () => {
+    const [events, exit] = run({
+        'a.test.f.ts': () => ({ arr: [ok0, ok0] }),
+    });
+    assertEq(exit, 0);
+    const passEvents = events.filter(e => e[0] === 'result');
+    assertEq(passEvents.length, 2);
+    assertEq(passEvents[0][2][1], '0');
+    assertEq(passEvents[1][2][1], '1');
+};
+// non-test files are skipped (only files ending in test.f.ts/js are loaded)
+export const nonTestFilesSkipped = () => {
+    const [events, exit] = run({
+        'helper.ts': () => ({ a: ok0 }),
+        'b.test.f.ts': () => ({ x: ok0 }),
+    });
+    assertEq(exit, 0);
+    const results = events.filter(e => e[0] === 'result');
+    assertEq(results.length, 1);
+    assertEq(results[0][1], './b.test.f.ts');
+};
+// multiple test files each produce result events
+export const multipleFiles = () => {
+    const [events, exit] = run({
+        'a.test.f.ts': () => ({ x: ok0 }),
+        'b.test.f.ts': () => ({ y: ok0 }),
+    });
+    assertEq(exit, 0);
+    const results = events.filter(e => e[0] === 'result');
+    assertEq(results.length, 2);
+    const [, pass, fail] = events[events.length - 1];
+    assertEq(pass, 2);
+    assertEq(fail, 0);
+};
+// a function literally named `throw` is a throwing test even when its key is not `throw`
+export const throwByFunctionName = () => {
+    // // `bun` calls the function `named` instead of `throw`
+    // const named = ({ throw: () => fail0() }).throw
+    const x = { throw: () => fail0() };
+    const [events, exit] = run({
+        't.test.f.ts': () => ({ here: x.throw }),
+    });
+    assertEq(exit, 0);
+    const passEvents = events.filter(e => e[0] === 'result');
+    assertEq(passEvents.length, 1);
+    assertEq(passEvents[0][2][0], 'here');
+};
+// every module export — `default` and named — becomes a top-level path segment
+export const namedExports = () => {
+    const [events, exit] = run({
+        'e.test.f.ts': () => ({ default: ok0, helper: ok0 }),
+    });
+    assertEq(exit, 0);
+    const passEvents = events.filter(e => e[0] === 'result');
+    assertEq(passEvents.length, 2);
+    assertEq(passEvents[0][2][0], 'default');
+    assertEq(passEvents[1][2][0], 'helper');
+};
+// the default (non-GitHub) reporter formats module/pass/summary lines on stdout
+export const defaultReporterOutput = () => {
+    const [stdout, stderr, exit] = runMain({
+        'a.test.f.ts': () => ({ x: ok0 }),
+    });
+    assertEq(exit, 0);
+    assertEq(stderr, '');
+    assertEq(stdout, 'import("./a.test.f.ts").x(): ok, 0.0000 ms\n'
+        + 'Number of tests: pass: 1, fail: 0, total: 1\n'
+        + 'Time: 0.0000 ms\n');
+};
+// a failure on the non-GitHub reporter writes the error to stderr, not stdout
+export const defaultReporterFailOutput = () => {
+    const [, stderr, exit] = runMain({
+        'a.test.f.ts': () => ({ bad: fail0 }),
+    });
+    assertEq(exit, 1);
+    assertEq(stderr, 'import("./a.test.f.ts").bad(): error, 0.0000 ms\noops\n');
+};
+// the GitHub reporter emits an `::error` annotation with a percent-encoded
+// title (the JSON path) and message
+export const githubReporterOutput = () => {
+    const [, stderr, exit] = runMain({
+        's.test.f.ts': () => ({ 'a:b,c%d': fail0 }),
+    }, true);
+    assertEq(exit, 1);
+    assertEq(stderr, '::error file=./s.test.f.ts,line=1,title=import("./s.test.f.ts")["a%3Ab%2Cc%25d"]()::oops\n');
+};
+// direct unit tests for the pure path-format helpers
+export const helpers = {
+    isInteger: () => {
+        assert(isInteger('0'));
+        assert(isInteger('123'));
+        assert(!isInteger(''));
+        assert(!isInteger('01'));
+        assert(!isInteger('1a'));
+        assert(!isInteger('-1'));
     },
-    // `throw` key with a function reference (function name is `helperThrows`).
-    throwReference: {
-        throw: helperThrows,
+    isIdentifier: () => {
+        assert(isIdentifier('abc'));
+        assert(isIdentifier('_x'));
+        assert(isIdentifier('$y'));
+        assert(isIdentifier('a1'));
+        assert(!isIdentifier(''));
+        assert(!isIdentifier('1a'));
+        assert(!isIdentifier('a-b'));
     },
-    // `throw` key with a group: every leaf function under it must throw to pass.
-    throwGroup: {
-        throw: {
-            inline: () => { throw 'inline failure'; },
-            reference: helperThrows,
-            nested: {
-                deep: () => { throw 'deep failure'; },
-            },
-        },
+    fmtImport: () => {
+        assertEq(fmtImport('./a.test.f.ts', []), 'import("./a.test.f.ts")()');
+        assertEq(fmtImport('./a.test.f.ts', ['math', 'add']), 'import("./a.test.f.ts").math.add()');
+        assertEq(fmtImport('./a.test.f.ts', ['users', '3']), 'import("./a.test.f.ts").users[3]()');
+        assertEq(fmtImport('./a.test.f.ts', ['x', 'hello world']), 'import("./a.test.f.ts").x["hello world"]()');
+        assertEq(fmtImport('./a.test.f.ts', ['outer', null, 'inner']), 'import("./a.test.f.ts").outer().inner()');
     },
-};
-// Non-default exports are walked as a sibling test group (see issue 27).
-export const namedExportTest = () => {
-    if (2 + 2 !== 4) {
-        throw 'arithmetic broken';
-    }
-};
-export const namedExportGroup = {
-    nested: () => {
-        if ('a' + 'b' !== 'ab') {
-            throw 'string concat broken';
-        }
+    fmtPath: () => {
+        assertEq(fmtPath([]), '');
+        assertEq(fmtPath(['math', 'add']), '.math.add');
+        assertEq(fmtPath(['users', '3', 'name']), '.users[3].name');
+        assertEq(fmtPath(['x', 'hello world']), '.x["hello world"]');
+        assertEq(fmtPath(['outer', null, 'inner']), '.outer().inner');
+    },
+    fmtTerm: () => {
+        assertEq(fmtTerm([]), '()');
+        assertEq(fmtTerm(['math', 'add']), '| | add');
+        assertEq(fmtTerm(['a', '0']), '| | 0');
+        assertEq(fmtTerm(['x', 'hello world']), '| | "hello world"');
+    },
+    ghEscape: () => {
+        assertEq(ghEscape('a%b'), 'a%25b');
+        assertEq(ghEscape('a:b'), 'a%3Ab');
+        assertEq(ghEscape('a,b'), 'a%2Cb');
+        assertEq(ghEscape('a\r\nb'), 'a%0D%0Ab');
+        assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
     },
-    throw: () => { throw 'expected to throw'; },
 };

package/fs/djs/module.f.d.ts

@@ -5,13 +5,13 @@
  */
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
-import { type Error, type WriteFile, type ReadFile } from '../types/effects/node/module.f.ts';
+import { type WriteFile, type ReadFile, type Write } from '../types/effects/node/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
 };
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;
 export type Unknown = Primitive | Object | Array;
-type CompileOp = ReadFile | WriteFile | Error;
+type CompileOp = ReadFile | WriteFile | Write;
 export declare const compile: (args: readonly string[]) => Effect<CompileOp, number>;
 export {};

package/fs/djs/module.f.js

@@ -1,23 +1,26 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-import { encodeUtf8, toVec } from "../types/uint8array/module.f.js";
 import { pure } from "../types/effects/module.f.js";
-import { error, writeFile, } from "../types/effects/node/module.f.js";
+import { writeFile, error, } from "../types/effects/node/module.f.js";
+import { utf8 } from "../text/module.f.js";
 export const compile = args => {
     if (args.length < 2) {
-        return error('Error: Requires 2 or more arguments').step(() => pure(1));
+        return error('Error: Requires 2 or more arguments')
+            .step(() => pure(1));
     }
     const inputFileName = args[0];
     const outputFileName = args[1];
     return transpile(inputFileName).step((result) => {
         if (result[0] === 'error') {
             const metadata = result[1].metadata;
-            return error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`).step(() => pure(0));
+            return error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`)
+                .step(() => pure(0));
         }
         const content = outputFileName.endsWith('.json')
             ? stringifyAsTree(sort)(result[1])
             : stringify(sort)(result[1]);
-        return writeFile(outputFileName, toVec(encodeUtf8(content))).step(() => pure(0));
+        return writeFile(outputFileName, utf8(content))
+            .step(() => pure(0));
     });
 };

package/fs/djs/test.f.js

@@ -1,14 +1,13 @@
 import { compile } from "./module.f.js";
 import { virtual, emptyState } from "../types/effects/node/virtual/module.f.js";
-import { encodeUtf8, toVec, fromVec, decodeUtf8 } from "../types/uint8array/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
-const fileVec = (s) => toVec(encodeUtf8(s));
+import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {
     const file = root[path];
     if (!isVec(file)) {
         throw `${path} is not a file`;
     }
-    return decodeUtf8(fromVec(file));
+    return utf8ToString(file);
 };
 export default {
     tooFewArgs: {
@@ -32,7 +31,7 @@ export default {
         },
     },
     success: () => {
-        const root = { 'input.f.js': fileVec('export default 42') };
+        const root = { 'input.f.js': utf8('export default 42') };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;
@@ -43,7 +42,7 @@ export default {
         }
     },
     jsonOutput: () => {
-        const root = { 'input.f.js': fileVec('export default 42') };
+        const root = { 'input.f.js': utf8('export default 42') };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.json']));
         if (code !== 0) {
             throw code;
@@ -63,7 +62,7 @@ export default {
         }
     },
     parseError: () => {
-        const root = { 'bad.f.js': fileVec('export default @') };
+        const root = { 'bad.f.js': utf8('export default @') };
         const [state, code] = virtual({ ...emptyState, root })(compile(['bad.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;