functionalscript 0.5.0 → 0.5.1

package/README.md

@@ -31,7 +31,7 @@ FunctionalScript code can be used:
 
 - safely in any JavaScript/TypeScript application or library;
 - as a JSON with expressions, see [DJS](https://medium.com/@sasha.gil/bridging-the-gap-from-json-to-javascript-without-dsls-fee273573f1b);
-- as a query language,
+- as a query language;
 - as a smart contract programming language in DeFi.
 
 ## Design Principles

package/dev/module.f.d.ts

@@ -1 +1,22 @@
+import type { Io } from '../io/module.f.ts';
+import type { Sign } from '../types/function/compare/module.f.ts';
 export declare const todo: () => never;
+export type Module = {
+    readonly default?: unknown;
+};
+export type UnknownMap = {
+    readonly [k in string]: unknown;
+};
+type Entry<T> = readonly [string, T];
+export declare const cmp: ([a]: Entry<unknown>, [b]: Entry<unknown>) => Sign;
+export type ModuleMap = {
+    readonly [k in string]: Module;
+};
+export declare const remove_tail: (v: readonly string[]) => (dif: number) => string[];
+export type MutableModuleMap = {
+    [k in string]: Module;
+};
+export declare const env: (io: Io) => (v: string) => string | undefined;
+export declare const loadModuleMap: ({ fs: { promises: { readdir }, existsSync }, asyncImport }: Io) => Promise<ModuleMap>;
+export declare const index: (io: Io) => Promise<number>;
+export {};

package/dev/module.f.js

@@ -1 +1,82 @@
+import { updateVersion } from "./version/module.f.js";
 export const todo = () => { throw 'not implemented'; };
+export const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
+export const remove_tail = (v) => (dif) => v.slice(0, v.length - dif);
+export const env = ({ process: { env } }) => a => {
+    const r = Object.getOwnPropertyDescriptor(env, a);
+    return r === undefined ? undefined :
+        typeof r.get === 'function' ? r.get() :
+            r.value;
+};
+export const loadModuleMap = async ({ fs: { promises: { readdir }, existsSync }, asyncImport }) => {
+    const load = async () => {
+        const map = [];
+        const f = async (p) => {
+            for (const i of await readdir(p, { withFileTypes: true })) {
+                const { name } = i;
+                if (!name.startsWith('.')) {
+                    const file = `${p}/${name}`;
+                    if (i.isDirectory()) {
+                        await f(file);
+                        continue;
+                    }
+                    if (name.endsWith('.f.mjs') ||
+                        name.endsWith('.f.js') ||
+                        (name.endsWith('.f.ts') && !existsSync(file.substring(0, file.length - 3) + '.js'))) {
+                        const source = await asyncImport(`../${file}`);
+                        map.push([file, source.default]);
+                    }
+                }
+            }
+        };
+        await f('.');
+        map.sort(cmp);
+        return Object.fromEntries(map);
+    };
+    const map = await load();
+    const build = () => {
+        const d = {};
+        const getModule = (base) => (k) => {
+            const relativePath = k.split('/');
+            const dif = relativePath.filter(v => v === '..').length;
+            const path = [remove_tail(base)(dif), relativePath.filter(v => !['..', '.'].includes(v))]
+                .flat();
+            const pathStr = path.join('/');
+            {
+                const module = d[pathStr];
+                if (module !== void 0) {
+                    return [pathStr, module];
+                }
+            }
+            {
+                const module = { default: map[pathStr] };
+                d[pathStr] = module;
+                return [pathStr, module];
+            }
+        };
+        {
+            const get = getModule(['.']);
+            for (const k of Object.keys(map)) {
+                get(k);
+            }
+        }
+        return d;
+    };
+    return build();
+};
+export const index = async (io) => {
+    updateVersion(io);
+    const jj = './deno.json';
+    const n = '/module.f.ts';
+    const jsr_json = JSON.parse(await io.fs.promises.readFile(jj, 'utf8'));
+    const list = Object.keys(await loadModuleMap(io)).filter(v => v.endsWith(n));
+    //console.log(list)
+    const exportsA = list.filter(v => !v.startsWith('./out')).map(v => [v.replace(n, ''), `./${v.substring(2)}`]);
+    // console.log(exportsA)
+    const exports = Object.fromEntries(exportsA);
+    // console.log(exports)
+    const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
+    // console.log(json)
+    await io.fs.promises.writeFile(jj, json, 'utf8');
+    return 0;
+};

package/dev/test/module.f.d.ts

@@ -1,4 +1,5 @@
 import type * as Result from '../../types/result/module.f.ts';
+import type { Io, Performance } from '../../io/module.f.ts';
 type Module = {
     readonly default?: unknown;
 };
@@ -16,5 +17,8 @@ type Input<T> = {
     readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
     readonly env: (n: string) => string | undefined;
 };
-declare const _default: <T>(input: Input<T>) => readonly [number, T];
-export default _default;
+export declare const test: <T>(input: Input<T>) => readonly [number, T];
+export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
+export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];
+export declare const main: (io: Io) => Promise<number>;
+export {};

package/dev/test/module.f.js

@@ -1,5 +1,6 @@
 import { entries, fold } from "../../types/list/module.f.js";
 import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
+import { env, loadModuleMap } from "../module.f.js";
 const isTest = (s) => s.endsWith('test.f.mjs') || 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 });
@@ -12,7 +13,7 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export default (input) => {
+export const test = (input) => {
     let { moduleMap, log, error, measure, tryCatch, env, state } = input;
     const isGitHub = env('GITHUB_ACTION') !== void 0;
     const f = ([k, v]) => {
@@ -73,3 +74,22 @@ export default (input) => {
     state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
     return [ts.fail !== 0 ? 1 : 0, state];
 };
+export const anyLog = (f) => (s) => (state) => {
+    f(s);
+    return state;
+};
+export const measure = (p) => (f) => (state) => {
+    const b = p.now();
+    const r = f();
+    const e = p.now();
+    return [r, e - b, state];
+};
+export const main = async (io) => test({
+    moduleMap: await loadModuleMap(io),
+    log: anyLog(io.console.log),
+    error: anyLog(io.console.error),
+    measure: measure(io.performance),
+    tryCatch: io.tryCatch,
+    env: env(io),
+    state: void 0,
+})[0];

package/dev/test.f.d.ts

@@ -5,5 +5,6 @@ declare const _default: {
     number: () => void;
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
+    throw: () => void;
 };
 export default _default;

package/dev/test.f.js

@@ -1,3 +1,4 @@
+import { todo } from "./module.f.js";
 export default {
     ctor: () => {
         const c = (() => { })['constructor'];
@@ -48,5 +49,8 @@ export default {
         const x = { 'a': 12 };
         const c = Object.getOwnPropertyDescriptor(x, 'constructor');
         const a = Object.getOwnPropertyDescriptor(x, 'a');
+    },
+    throw: () => {
+        todo();
     }
 };

package/{nodejs → dev}/version/module.f.d.ts

@@ -1,6 +1,6 @@
 export type Buffer = object;
 type Fs<T> = {
-    readonly readFileSync: (name: string) => Buffer;
+    readonly readFileSync: (name: string, encoding: 'utf8') => string;
     readonly writeFileSync: (name: string, content: string) => T;
 };
 export type Node<T> = {

package/{nodejs → dev}/version/module.f.js

@@ -1,7 +1,7 @@
 const { stringify, parse } = JSON;
 export const getVersion = fs => readJson(fs)('package').version;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = fs => name => parse(fs.readFileSync(jsonFile(name)).toString());
+const readJson = fs => name => parse(fs.readFileSync(jsonFile(name), 'utf8'));
 export const updateVersion = ({ fs }) => {
     const f = (name) => {
         return fs.writeFileSync(jsonFile(name), stringify({

package/{nodejs → dev}/version/test.f.js

@@ -73,13 +73,10 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-const buffer = s => ({
-    toString: () => s
-});
 export default () => {
     const node = {
         fs: {
-            readFileSync: n => buffer(JSON.stringify(x[n])),
+            readFileSync: n => JSON.stringify(x[n]),
             writeFileSync: (_, content) => content
         }
     };

package/djs/module.f.d.ts

@@ -6,4 +6,4 @@ export type Object = {
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;
 export type Unknown = Primitive | Object | Array;
-export declare const run: ({ console: { error }, fs, process: { argv } }: Io) => void;
+export declare const compile: ({ console: { error }, fs, process: { argv } }: Io) => Promise<number>;

package/djs/module.f.js

@@ -2,11 +2,11 @@ import { transpile } from "./transpiler/module.f.js";
 import { stringify } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
 const stringifyUnknown = stringify(sort);
-export const run = ({ console: { error }, fs, process: { argv } }) => {
+export const compile = ({ console: { error }, fs, process: { argv } }) => {
     const args = argv.slice(2);
     if (args.length < 2) {
         error('Error: Requires 2 or more arguments');
-        return;
+        return Promise.resolve(1);
     }
     const inputFileName = args[0];
     const outputFileName = args[1];
@@ -22,4 +22,5 @@ export const run = ({ console: { error }, fs, process: { argv } }) => {
             break;
         }
     }
+    return Promise.resolve(0);
 };

package/djs/transpiler/test.f.js

@@ -2,7 +2,7 @@ import { sort } from "../../types/object/module.f.js";
 import { setReplace } from "../../types/map/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringify } from "../serializer/module.f.js";
-import { createVirtualIo } from "../../io/virtual-io.f.js";
+import { createVirtualIo } from "../../io/virtual.f.js";
 const virtualFs = map => {
     return createVirtualIo(map).fs;
 };

package/fsc.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import io from "./io/node-io.js";
-import { run } from "./djs/module.f.js";
-run(io);
+import node from "./io/node.js";
+import { compile } from "./djs/module.f.js";
+await node(compile);

package/io/module.f.d.ts

@@ -1,17 +1,85 @@
+import type { Result } from '../types/result/module.f.ts';
+/**
+ * Standard Node.js buffer encoding type
+ * @see https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
+ */
 export type BufferEncoding = 'utf8';
+/**
+ * Represents a directory entry (file or directory) in the filesystem
+ * @see https://nodejs.org/api/fs.html#class-fsdirent
+ */
+export type Dirent = {
+    readonly name: string;
+    readonly isDirectory: () => boolean;
+    readonly isFile: () => boolean;
+};
+/**
+ * File system operations interface
+ * @see https://nodejs.org/api/fs.html
+ */
 export type Fs = {
     readonly writeFileSync: (file: string, data: string) => void;
     readonly readFileSync: (path: string, options: BufferEncoding) => string | null;
+    readonly existsSync: (path: string) => boolean;
+    readonly promises: {
+        readonly readFile: (path: string, options: BufferEncoding) => Promise<string>;
+        readonly writeFile: (path: string, data: string, options: BufferEncoding) => Promise<void>;
+        readonly readdir: (path: string, options: {
+            withFileTypes: true;
+        }) => Promise<Dirent[]>;
+    };
 };
+/**
+ * Console operations interface
+ * @see https://nodejs.org/api/console.html
+ */
 export type Console = {
     readonly log: (...d: unknown[]) => void;
     readonly error: (...d: unknown[]) => void;
 };
+/**
+ * Represents an ES module with a default export
+ */
+export type Module = {
+    readonly default: unknown;
+};
+/**
+ * High-resolution time measurement interface
+ * @see https://nodejs.org/api/perf_hooks.html#performance-now
+ */
+export type Performance = {
+    readonly now: () => number;
+};
+/**
+ * Core IO operations interface providing access to system resources
+ */
 export type Io = {
     readonly console: Console;
     readonly fs: Fs;
     readonly process: Process;
+    readonly asyncImport: (s: string) => Promise<Module>;
+    readonly performance: Performance;
+    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
+    readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
 };
+/**
+ * Node.js Process interface
+ * @see https://nodejs.org/api/process.html
+ */
 export type Process = {
     readonly argv: string[];
+    readonly env: Env;
+    readonly exit: (code: number) => never;
+};
+/**
+ * The environment variables.
+ */
+export type Env = {
+    readonly [k: string]: string | undefined;
 };
+export type Run = (f: (io: Io) => Promise<number>) => Promise<never>;
+/**
+ * Runs a function and exits the process with the returned code
+ * Handles errors by exiting with code 1
+ */
+export declare const run: (io: Io) => Run;

package/io/module.f.js

@@ -1 +1,16 @@
-export {};
+/**
+ * Runs a function and exits the process with the returned code
+ * Handles errors by exiting with code 1
+ */
+export const run = (io) => {
+    const code = ([x, b]) => {
+        if (x === 'error') {
+            io.console.error(x[1]);
+            return 1;
+        }
+        else {
+            return b;
+        }
+    };
+    return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
+};

package/io/virtual.f.js

@@ -0,0 +1,28 @@
+import { at } from "../types/map/module.f.js";
+export const createVirtualIo = (files) => ({
+    console: {
+        log: (..._d) => { },
+        error: (..._d) => { }
+    },
+    fs: {
+        writeFileSync: (_file, _data) => { },
+        readFileSync: (path, _options) => { return at(path)(files); },
+        existsSync: (path) => { return at(path)(files) !== null; },
+        promises: {
+            readdir: (_path) => Promise.resolve([]),
+            readFile: (_path, _options) => Promise.resolve(''),
+            writeFile: (_path, _data, _options) => Promise.resolve(),
+        }
+    },
+    process: {
+        argv: [],
+        env: {},
+        exit: n => { throw n; },
+    },
+    asyncImport: () => Promise.reject(),
+    performance: {
+        now: () => 0,
+    },
+    tryCatch: f => ['ok', f()],
+    asyncTryCatch: async (f) => ['ok', await f()],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "files": [
     "fsc.js",
@@ -18,9 +18,11 @@
     "test22": "tsc && npm run n -- --experimental-strip-types ./dev/test.ts",
     "test": "tsc && npm run n ./dev/test.ts",
     "index": "npm run n ./dev/index.ts",
-    "version": "npm run n ./nodejs/version/main.ts",
     "fsc": "npm run n ./fsc.ts",
-    "update": "npm run version && npm run index && npm install"
+    "update": "npm run index && npm install"
+  },
+  "engines": {
+    "node": ">=16"
   },
   "bin": {
     "fsc": "fsc.js"
@@ -45,7 +47,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.13.10",
+    "@types/node": "^22.13.14",
     "typescript": "^5.8.2"
   }
 }

package/io/node-io.js

@@ -1,7 +0,0 @@
-import fs from 'node:fs';
-import process from "node:process";
-export default {
-    console,
-    fs,
-    process
-};

package/io/virtual-io.f.js

@@ -1,14 +0,0 @@
-import { at } from "../types/map/module.f.js";
-export const createVirtualIo = (files) => ({
-    console: {
-        log: (..._d) => { },
-        error: (..._d) => { }
-    },
-    fs: {
-        writeFileSync: (_file, _data) => { },
-        readFileSync: (path, _options) => { return at(path)(files); }
-    },
-    process: {
-        argv: []
-    }
-});