functionalscript 0.13.1 → 0.14.1

package/{dev → fs/dev}/tf/module.f.js

@@ -18,16 +18,17 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (t) => (x) => {
+export const parseTestSet = (t) => (throws) => (x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
                 const xt = x;
-                if (xt.name !== 'throw') {
+                if (!throws && xt.name !== 'throw') {
                     return xt;
                 }
-                // Usual tests throw on error, but if the function name is 'throw',
-                // then the test passes if it throws.
+                // 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 [tag, value] = t(xt);
                     if (tag === 'ok') {
@@ -52,9 +53,9 @@ export const test = (input) => {
     const isGitHub = env('GITHUB_ACTION') !== undefined;
     const parse = parseTestSet(tryCatch);
     const f = ([k, v]) => {
-        const test = i => v => ([ts, state]) => {
+        const test = i => throws => v => ([ts, state]) => {
             const next = test(`${i}| `);
-            const set = parse(v);
+            const set = parse(throws)(v);
             if (typeof set === 'function') {
                 const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
                 state = state0;
@@ -73,13 +74,15 @@ export const test = (input) => {
                 else {
                     ts = addPass(delta)(ts);
                     log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                    [ts, state] = next(r)([ts, state]);
+                    // The result of a function is walked as a fresh sub-tree;
+                    // the parent's `throws` flag does not propagate into it.
+                    [ts, state] = next(false)(r)([ts, state]);
                 }
             }
             else {
                 const f = ([k, v]) => ([time, state]) => {
                     log(`${i}${k}:`);
-                    [time, state] = next(v)([time, state]);
+                    [time, state] = next(throws || k === 'throw')(v)([time, state]);
                     return [time, state];
                 };
                 [ts, state] = fold(f)([ts, state])(set);
@@ -89,7 +92,7 @@ export const test = (input) => {
         return ([ts, state]) => {
             if (isTest(k)) {
                 log(`testing ${k}`);
-                [ts, state] = test('| ')(v.default)([ts, state]);
+                [ts, state] = test('| ')(false)(v.default)([ts, state]);
             }
             return [ts, state];
         };

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

@@ -0,0 +1,16 @@
+declare const _default: {
+    throw: () => never;
+    throwReference: {
+        throw: () => unknown;
+    };
+    throwGroup: {
+        throw: {
+            inline: () => never;
+            reference: () => unknown;
+            nested: {
+                deep: () => never;
+            };
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,22 @@
+// 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 [() => { }, () => { }];
+    },
+    // `throw` key with a function reference (function name is `helperThrows`).
+    throwReference: {
+        throw: helperThrows,
+    },
+    // `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'; },
+            },
+        },
+    },
+};

package/fs/dev/version/module.f.d.ts

@@ -0,0 +1,3 @@
+import { type Effect } from '../../types/effects/module.f.ts';
+import { type All, type ReadFile, type WriteFile } from '../../types/effects/node/module.f.ts';
+export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;

package/{djs → fs/djs}/tokenizer/module.f.js

@@ -44,15 +44,15 @@ const parseMinusState = input => {
         default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input) }, { kind: 'def' }];
     }
 };
-const scanToken = state => input => {
+const scanToken = (input, state) => {
     switch (state.kind) {
         case '-': return parseMinusState(input);
         default: return parseDefaultState(input);
     }
 };
 const mapTokenWithMetadata = metadata => token => { return { token, metadata }; };
-const scanTokenWithMetadata = state => (input) => {
-    const [djsTokens, newState] = scanToken(state)(input.token);
+const scanTokenWithMetadata = (input, state) => {
+    const [djsTokens, newState] = scanToken(input.token, state);
     const djsTokensWithMetadata = map(mapTokenWithMetadata(input.metadata))(djsTokens);
     return [djsTokensWithMetadata, newState];
 };

package/{djs/parser-new → fs/djs/tokenizer-new}/test.f.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     isValid: (() => void)[];
-    parser: (() => void)[];
+    tokenizer: (() => void)[];
+    djs: (() => void)[];
 };
 export default _default;