functionalscript 0.4.4 → 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

@@ -1,3 +1,4 @@
+import type { Io } from '../io/module.f.ts';
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
@@ -5,3 +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 compile: ({ console: { error }, fs, process: { argv } }: Io) => Promise<number>;

package/djs/module.f.js

@@ -1 +1,26 @@
-export {};
+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 compile = ({ console: { error }, fs, process: { argv } }) => {
+    const args = argv.slice(2);
+    if (args.length < 2) {
+        error('Error: Requires 2 or more arguments');
+        return Promise.resolve(1);
+    }
+    const inputFileName = args[0];
+    const outputFileName = args[1];
+    const result = transpile(fs)(inputFileName);
+    switch (result[0]) {
+        case 'ok': {
+            const output = stringifyUnknown(result[1]);
+            fs.writeFileSync(outputFileName, output);
+            break;
+        }
+        case 'error': {
+            error(`Parse error: ${result[1]}`);
+            break;
+        }
+    }
+    return Promise.resolve(0);
+};

package/djs/transpiler/module.f.js

@@ -15,7 +15,8 @@ const mapDjs = context => path => {
 };
 const transpileWithImports = path => parseModuleResult => context => {
     if (parseModuleResult[0] === 'ok') {
-        const pathsCombine = listMap(pathConcat(path))(parseModuleResult[1][0]);
+        const dir = pathConcat(path)('..');
+        const pathsCombine = listMap(pathConcat(dir))(parseModuleResult[1][0]);
         const contextWithImports = fold(foldNextModuleOp)({ ...context, stack: { first: path, tail: context.stack } })(pathsCombine);
         if (contextWithImports.error !== null) {
             return contextWithImports;

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;
 };
@@ -20,10 +20,10 @@ export default {
         }
     },
     parseWithSubModule: () => {
-        const map = setReplace('a')('import b from "b"\nexport default b')(null);
-        const map2 = setReplace('a/b')('export default 2')(map);
+        const map = setReplace('a/b')('import c from "c"\nexport default c')(null);
+        const map2 = setReplace('a/c')('export default 2')(map);
         const fs = virtualFs(map2);
-        const result = transpile(fs)('a');
+        const result = transpile(fs)('a/b');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -34,9 +34,9 @@ export default {
     },
     parseWithSubModules: () => {
         const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
-        const map2 = setReplace('a/b')('import d from "../d"\nexport default [0,d]')(map);
-        const map3 = setReplace('a/c')('import d from "../d"\nexport default [1,d]')(map2);
-        const map4 = setReplace('a/d')('export default 2')(map3);
+        const map2 = setReplace('b')('import d from "d"\nexport default [0,d]')(map);
+        const map3 = setReplace('c')('import d from "d"\nexport default [1,d]')(map2);
+        const map4 = setReplace('d')('export default 2')(map3);
         const fs = virtualFs(map4);
         const result = transpile(fs)('a');
         if (result[0] === 'error') {
@@ -60,8 +60,8 @@ export default {
     },
     parseWithCycleError: () => {
         const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
-        const map2 = setReplace('a/b')('import c from "../c"\nexport default c')(map);
-        const map3 = setReplace('a/c')('import b from "../b"\nexport default b')(map2);
+        const map2 = setReplace('b')('import c from "c"\nexport default c')(map);
+        const map3 = setReplace('c')('import b from "b"\nexport default b')(map2);
         const fs = virtualFs(map3);
         const result = transpile(fs)('a');
         if (result[0] !== 'error') {

package/fsc.js

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

package/io/module.f.d.ts

@@ -1,12 +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,22 +1,31 @@
 {
   "name": "functionalscript",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "type": "module",
   "files": [
+    "fsc.js",
+    "io/node-io.js",
     "**/*.f.d.ts",
     "**/*.f.js"
   ],
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
     "tsc-emit": "tsc --NoEmit false",
+    "n": "node --frozen-intrinsics --trace-uncaught",
     "prepack": "npm run tsc-emit",
-    "test20": "npm run prepack && node --trace-uncaught ./dev/test.js",
-    "test22": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
-    "test": "tsc && node --trace-uncaught ./dev/test.ts",
-    "index": "node ./dev/index.ts",
-    "version": "node ./nodejs/version/main.ts",
-    "fsc": "node ./main.ts",
-    "update": "npm run version && npm run index && npm install"
+    "git-clean": "git clean -xf",
+    "test20": "npm run tsc-emit && npm run n ./dev/test.js",
+    "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",
+    "fsc": "npm run n ./fsc.ts",
+    "update": "npm run index && npm install"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "bin": {
+    "fsc": "fsc.js"
   },
   "repository": {
     "type": "git",
@@ -38,7 +47,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.13.4",
-    "typescript": "^5.7.3"
+    "@types/node": "^22.13.14",
+    "typescript": "^5.8.2"
   }
 }

package/path/module.f.js

@@ -1,4 +1,3 @@
-import {} from "../types/function/operator/module.f.js";
 import { fold, last, take, length, concat as listConcat } from "../types/list/module.f.js";
 import { join } from "../types/string/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
@@ -13,10 +12,8 @@ const foldNormalizeOp = input => state => {
                 case '..': {
                     return listConcat(state)([input]);
                 }
-                default: {
-                    return take(length(state) - 1)(state);
-                }
             }
+            return take(length(state) - 1)(state);
         }
         default: {
             return listConcat(state)([input]);
@@ -24,7 +21,7 @@ const foldNormalizeOp = input => state => {
     }
 };
 export const normalize = path => {
-    const split = path.split('/');
+    const split = path.replaceAll('\\', '/').split('/');
     const foldResult = fold(foldNormalizeOp)([])(split);
     return join('/')(foldResult);
 };

package/io/virtual-io.f.js

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