functionalscript 0.14.4 → 0.14.6

package/fs/ci/bun/module.f.d.ts

@@ -1,2 +1,2 @@
 import { type Architecture, type MetaStep, type Os } from '../common/module.f.ts';
-export declare const bunSteps: (v: Os, a: Architecture) => readonly MetaStep[];
+export declare const bunSteps: (extra: readonly MetaStep[]) => (v: Os, a: Architecture) => readonly MetaStep[];

package/fs/ci/bun/module.f.js

@@ -13,8 +13,8 @@ const installBun = installOnWindowsArm({
     name: 'bun',
     path: 'bun.sh',
 });
-export const bunSteps = (v, a) => clean([
+export const bunSteps = (extra) => (v, a) => clean([
     installBun(v)(a),
     test({ run: 'bun test --timeout 20000' }),
-    test({ run: 'bun ./fs/fjs/module.ts t' }),
+    ...extra,
 ]);

package/fs/ci/common/module.f.d.ts

@@ -41,3 +41,4 @@ export declare const test: (step: Step) => MetaStep;
 export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
+export declare const findTgz: (v: Os) => "(Get-ChildItem *.tgz).FullName" | "./*.tgz";

package/fs/ci/common/module.f.js

@@ -30,3 +30,4 @@ export const ubuntu = (ms) => ({
     'runs-on': images.ubuntu.intel,
     steps: toSteps(ms)
 });
+export const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';

package/fs/ci/deno/module.f.d.ts

@@ -1,2 +1,2 @@
 import { type MetaStep } from '../common/module.f.ts';
-export declare const denoSteps: readonly MetaStep[];
+export declare const denoSteps: (extra: readonly MetaStep[]) => readonly MetaStep[];

package/fs/ci/deno/module.f.js

@@ -1,13 +1,12 @@
 import { deno } from "../config/module.f.js";
 import { clean, install, test } from "../common/module.f.js";
-export const denoSteps = clean([
+export const denoSteps = (extra) => clean([
     install({
         uses: 'denoland/setup-deno@v2',
         with: { 'deno-version': deno },
     }),
     test({ run: 'deno install' }),
     test({ run: 'deno task test' }),
-    test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
-    test({ run: 'deno task fjs t' }),
+    ...extra,
     test({ run: 'deno publish --dry-run' }),
 ]);

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

@@ -1,5 +1,12 @@
 import { type Effect } from '../types/effects/module.f.ts';
 import { type NodeOp } from '../types/effects/node/module.f.ts';
-export declare const ci: (rust: boolean) => Effect<NodeOp, number>;
+import { type MetaStep, type Os } from './common/module.f.ts';
+export type Setup = {
+    readonly rust: boolean;
+    readonly nodeExtra: (os: Os) => readonly MetaStep[];
+    readonly denoExtra: readonly MetaStep[];
+    readonly bunExtra: readonly MetaStep[];
+};
+export declare const ci: ({ rust, nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
 declare const _default: () => Effect<NodeOp, number>;
 export default _default;

package/fs/ci/module.f.js

@@ -7,26 +7,26 @@ import { utf8 } from "../text/module.f.js";
 import { begin, pure } from "../types/effects/module.f.js";
 import { writeFile } from "../types/effects/node/module.f.js";
 import { images } from "./config/module.f.js";
-import { architecture, os, toSteps } from "./common/module.f.js";
+import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";
 import { nodeMainSteps, nodeVersions } from "./node/module.f.js";
 import { playwrightJob } from "./playwright/module.f.js";
 import { bunSteps } from "./bun/module.f.js";
 import { denoSteps } from "./deno/module.f.js";
-const job = (rust) => (o) => (a) => {
+const job = (rust, nodeExtra, denoExtra, bunExtra) => (o) => (a) => {
     const id = `${o}-${a}`;
     const image = images[o][a];
     const result = [
         ...(rust ? rustSteps(o, a) : []),
-        ...nodeMainSteps(o),
-        ...denoSteps,
-        ...bunSteps(o, a),
+        ...nodeMainSteps(nodeExtra),
+        ...denoSteps(denoExtra),
+        ...bunSteps(bunExtra)(o, a),
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
-export const ci = (rust) => {
+export const ci = ({ rust, nodeExtra, denoExtra, bunExtra }) => {
     const jobs = {
-        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust)(o)))),
+        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o), denoExtra, bunExtra)(o)))),
         ...nodeVersions,
         playwright: playwrightJob,
     };
@@ -39,5 +39,21 @@ export const ci = (rust) => {
         .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
         .step(() => pure(0));
 };
-const defaultEffect = ci(true);
+const defaultEffect = ci({
+    rust: true,
+    nodeExtra: o => [
+        test({ run: 'npm pack' }),
+        test({ run: `npm install -g ${findTgz(o)}` }),
+        test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
+        test({ run: 'fjs t' }),
+        test({ run: 'npm uninstall functionalscript -g' }),
+    ],
+    denoExtra: [
+        test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
+        test({ run: 'deno task fjs t' }),
+    ],
+    bunExtra: [
+        test({ run: 'bun ./fs/fjs/module.ts t' }),
+    ]
+});
 export default () => defaultEffect;

package/fs/ci/node/module.f.d.ts

@@ -1,6 +1,6 @@
-import { type Jobs, type MetaStep, type Os } from '../common/module.f.ts';
+import { type Jobs, type MetaStep } from '../common/module.f.ts';
 export declare const major: (v: string) => string;
 export declare const basicNode: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
 export declare const nodeTests: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
 export declare const nodeVersions: Jobs;
-export declare const nodeMainSteps: (v: Os) => readonly MetaStep[];
+export declare const nodeMainSteps: (extra: readonly MetaStep[]) => readonly MetaStep[];

package/fs/ci/node/module.f.js

@@ -1,5 +1,5 @@
 import { node, tsgo } from "../config/module.f.js";
-import { clean, install, test, ubuntu } from "../common/module.f.js";
+import { clean, findTgz, install, test, ubuntu } from "../common/module.f.js";
 export const major = (v) => v.split('.')[0];
 const installNode = (version) => ({ uses: 'actions/setup-node@v6', with: { 'node-version': version } });
 export const basicNode = (version) => (extra) => clean([
@@ -12,8 +12,6 @@ export const nodeTests = (version) => (extra) => basicNode(version)([
     test({ run: 'npm run fst' }),
     ...extra,
 ]);
-const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
-// const nodeTest = (v: string) => major(v) === '20' ? 'run test20' : 'test'
 const nodeSteps = (v) => [
     install(installNode(v)),
     test({ run: 'npm ci' }),
@@ -23,14 +21,10 @@ export const nodeVersions = Object.fromEntries(node.others.map(v => [
     `node${major(v)}`,
     ubuntu(nodeSteps(v))
 ]));
-export const nodeMainSteps = (v) => nodeTests(node.default)([
+export const nodeMainSteps = (extra) => nodeTests(node.default)([
     // TypeScript Preview
     install({ run: `npm install -g @typescript/native-preview@${tsgo}` }),
     test({ run: 'tsgo' }),
-    // publishing
-    test({ run: 'npm pack' }),
-    test({ run: `npm install -g ${findTgz(v)}` }),
-    test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
-    test({ run: 'fjs t' }),
-    test({ run: 'npm uninstall functionalscript -g' }),
+    // extra
+    ...extra,
 ]);

package/fs/ci/test.f.d.ts

@@ -1,5 +1,9 @@
 declare const _default: {
     rust: () => void;
     noRust: () => void;
+    extra: {
+        allOs: () => void;
+        osSpecific: () => void;
+    };
 };
 export default _default;

package/fs/ci/test.f.js

@@ -1,40 +1,50 @@
 import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
+import { test } from "./common/module.f.js";
+import { assert } from "../dev/module.f.js";
 import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
-const hasCargo = (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes('cargo')));
+const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
+const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
 const githubState = {
     ...emptyState,
     root: { '.github': { workflows: {} } },
 };
-const run = (rust) => {
-    const [state, result] = virtual(githubState)(ci(rust));
-    if (result !== 0) {
-        throw result;
-    }
+const run = (rust, nodeExtra = () => []) => {
+    const [state, result] = virtual(githubState)(ci({ rust, nodeExtra, denoExtra: [], bunExtra: [] }));
+    assert(result === 0, result);
     const dotGithub = state.root['.github'];
-    if (dotGithub === undefined || isVec(dotGithub)) {
-        throw dotGithub;
-    }
+    assert(dotGithub !== undefined && !isVec(dotGithub), dotGithub);
     const workflows = dotGithub['workflows'];
-    if (workflows === undefined || isVec(workflows)) {
-        throw workflows;
-    }
+    assert(workflows !== undefined && !isVec(workflows), workflows);
     const file = workflows['ci.yml'];
-    if (!isVec(file)) {
-        throw file;
-    }
+    assert(isVec(file), file);
     return JSON.parse(utf8ToString(file));
 };
 export default {
     rust: () => {
-        if (!hasCargo(run(true))) {
-            throw 'expected Rust steps';
-        }
+        assert(hasRun('cargo')(run(true)), 'expected Rust steps');
     },
     noRust: () => {
-        if (hasCargo(run(false))) {
-            throw 'unexpected Rust steps';
-        }
+        assert(!hasRun('cargo')(run(false)), 'unexpected Rust steps');
+    },
+    extra: {
+        allOs: () => {
+            const cmd = 'echo hello';
+            const gha = run(false, () => [test({ run: cmd })]);
+            for (const o of ['ubuntu', 'macos', 'windows']) {
+                for (const a of ['intel', 'arm']) {
+                    assert(hasRunInJob(`${o}-${a}`, cmd)(gha), `missing extra step in ${o}-${a}`);
+                }
+            }
+        },
+        osSpecific: () => {
+            const gha = run(false, o => o === 'ubuntu' ? [test({ run: 'echo ubuntu-only' })] : []);
+            for (const a of ['intel', 'arm']) {
+                assert(hasRunInJob(`ubuntu-${a}`, 'echo ubuntu-only')(gha), `missing step in ubuntu-${a}`);
+                assert(!hasRunInJob(`macos-${a}`, 'echo ubuntu-only')(gha), `unexpected step in macos-${a}`);
+                assert(!hasRunInJob(`windows-${a}`, 'echo ubuntu-only')(gha), `unexpected step in windows-${a}`);
+            }
+        },
     },
 };

package/fs/dev/tf/module.js

@@ -1,23 +1,15 @@
-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 { io } from "../../io/module.js";
 import { loadModuleMap } from "../module.f.js";
 import { isTest, parseTestSet } from "./module.f.js";
 import * as nodeTest from 'node:test';
-import { playwright } from "../../ci/config/module.f.js";
+import { asyncImport } from "../../io/module.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 import(__rewriteRelativeImportExtension(`@playwright/test@${playwright}`))).test;
+    const pwTest = (await asyncImport('@playwright/test')).test;
     return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
 };
 const framework = isPlaywright ? await createPlaywrightFramework() :

package/fs/io/module.d.ts

@@ -1,5 +1,6 @@
-import { type Io, type Run } from './module.f.ts';
+import { type Io, type Module, type Run } from './module.f.ts';
 import type { NodeProgram } from '../types/effects/node/module.f.ts';
+export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const io: Io;
 export declare const legacyRun: Run;
 export type NodeRun = (p: NodeProgram) => Promise<number>;

package/fs/io/module.js

@@ -14,6 +14,7 @@ import { fromIo, run } from "./module.f.js";
 import { concat } from "../path/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 const prefix = 'file:///';
+export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
 export const io = {
     console,
     fs,
@@ -21,7 +22,7 @@ export const io = {
     asyncImport: (v) => {
         const s0 = v.includes(':') || v.startsWith('/') ? v : concat(process.cwd())(v);
         const s1 = s0.startsWith(prefix) ? s0 : `${prefix}${s0}`;
-        return import(__rewriteRelativeImportExtension(s1));
+        return asyncImport(s1);
     },
     performance,
     fetch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "type": "module",
   "files": [
     "**/*.js",