functionalscript 0.4.3 → 0.5.0

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

@@ -1,9 +1,13 @@
 import * as list from '../../types/list/module.f.ts';
 import type * as O from '../../types/object/module.f.ts';
-import type * as DjsParser from '../parser/module.f.ts';
-export declare const undefinedSerialize: string[];
-type Entry = O.Entry<DjsParser.DjsConst>;
+import type { Unknown } from '../module.f.ts';
+type Entry = O.Entry<Unknown>;
 type Entries = list.List<Entry>;
 type MapEntries = (entries: Entries) => Entries;
-export declare const djsModuleStringify: (mapEntries: MapEntries) => (djsModule: DjsParser.DjsModule) => string;
+export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ */
+export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 export {};

package/djs/serializer/module.f.js

@@ -1,5 +1,5 @@
 import * as list from "../../types/list/module.f.js";
-const { flat, map, entries: listEntries, concat: listConcat, flatMap } = list;
+const { flat, map } = list;
 import * as string from "../../types/string/module.f.js";
 const { concat } = string;
 import * as f from "../../types/function/module.f.js";
@@ -10,8 +10,8 @@ const { serialize: bigintSerialize } = bi;
 import * as j from "../../json/serializer/module.f.js";
 const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
 const colon = [':'];
-export const undefinedSerialize = ['undefined'];
-const djsConstSerialize = sort => {
+const undefinedSerialize = ['undefined'];
+export const serialize = sort => {
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
@@ -45,17 +45,7 @@ const djsConstSerialize = sort => {
                     return undefinedSerialize;
                 }
                 if (value instanceof Array) {
-                    switch (value[0]) {
-                        case 'aref': {
-                            return [`a${value[1]}`];
-                        }
-                        case 'cref': {
-                            return [`c${value[1]}`];
-                        }
-                        case 'array': {
-                            return arraySerialize(value[1]);
-                        }
-                    }
+                    return arraySerialize(value);
                 }
                 return objectSerialize(value);
             }
@@ -64,16 +54,8 @@ const djsConstSerialize = sort => {
     const arraySerialize = compose(map(f))(arrayWrap);
     return f;
 };
-export const djsModuleStringify = sort => djsModule => {
-    const importEntries = listEntries(djsModule[0]);
-    const importSerialize = entry => flat([['import a'], numberSerialize(entry[0]), [' from "', entry[1], '"\n']]);
-    const len = djsModule[1].length;
-    const constEntries = listEntries(djsModule[1]);
-    const moduleEntrySerialize = entry => {
-        if (entry[0] === len - 1) {
-            return listConcat(['export default '])(djsConstSerialize(sort)(entry[1]));
-        }
-        return flat([['const c'], numberSerialize(entry[0]), [' = '], djsConstSerialize(sort)(entry[1]), ['\n']]);
-    };
-    return concat(listConcat(flatMap(importSerialize)(importEntries))(flatMap(moduleEntrySerialize)(constEntries)));
-};
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ */
+export const stringify = sort => compose(serialize(sort))(concat);

package/djs/{test.f.d.ts → serializer/test.f.d.ts}

@@ -2,11 +2,11 @@ declare const _default: {
     stringify: ({
         sort: () => void;
         identity: () => void;
-        stringify?: undefined;
+        stringify?: never;
     } | {
         stringify: () => void;
-        sort?: undefined;
-        identity?: undefined;
+        sort?: never;
+        identity?: never;
     })[];
 };
 export default _default;

package/djs/{test.f.js → serializer/test.f.js}

@@ -1,21 +1,21 @@
-import * as json from "../json/module.f.js";
-import * as list from "../types/object/module.f.js";
+import * as json from "../../json/module.f.js";
+import * as list from "../../types/object/module.f.js";
 const { sort } = list;
-import * as f from "../types/function/module.f.js";
+import * as f from "../../types/function/module.f.js";
 const { identity } = f;
-import * as djs from "./module.f.js";
+import * as serializer from "./module.f.js";
 export default {
     stringify: [
         {
             sort: () => {
                 const r = json.setProperty("Hello")(['a'])({});
-                const x = djs.stringify(sort)(r);
+                const x = serializer.stringify(sort)(r);
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = djs.stringify(identity)(json.setProperty("Hello")(['a'])({}));
+                const x = serializer.stringify(identity)(json.setProperty("Hello")(['a'])({}));
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
@@ -23,13 +23,13 @@ export default {
         },
         {
             sort: () => {
-                const x = djs.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = serializer.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"a":"Hello","b":12,"c":[]}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = djs.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = serializer.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"c":[],"b":12,"a":"Hello"}') {
                     throw x;
                 }
@@ -39,7 +39,7 @@ export default {
             sort: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
                 const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = djs.stringify(sort)(_1);
+                const _2 = serializer.stringify(sort)(_1);
                 if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
                     throw _2;
                 }
@@ -47,7 +47,7 @@ export default {
             identity: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
                 const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = djs.stringify(identity)(_1);
+                const _2 = serializer.stringify(identity)(_1);
                 if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
                     throw _2;
                 }
@@ -56,7 +56,7 @@ export default {
         {
             stringify: () => {
                 const bi = 1234567890n;
-                const result = djs.stringify(sort)(bi);
+                const result = serializer.stringify(sort)(bi);
                 if (result !== '1234567890n') {
                     throw result;
                 }
@@ -65,7 +65,7 @@ export default {
         {
             stringify: () => {
                 const arr = [0n, 1, 2n];
-                const result = djs.stringify(sort)(arr);
+                const result = serializer.stringify(sort)(arr);
                 if (result !== '[0n,1,2n]') {
                     throw result;
                 }
@@ -74,7 +74,7 @@ export default {
         {
             stringify: () => {
                 const obj = { "a": 0n, "b": 1, "c": 2n };
-                const result = djs.stringify(sort)(obj);
+                const result = serializer.stringify(sort)(obj);
                 if (result !== '{"a":0n,"b":1,"c":2n}') {
                     throw result;
                 }

package/djs/tokenizer/test.f.js

@@ -1,12 +1,12 @@
 import * as tokenizer from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
-import * as djs from "../module.f.js";
+import * as serializer from "../serializer/module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = djs.stringify(sort);
+const stringify = serializer.stringify(sort);
 export default {
     djs: [
         () => {

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

@@ -0,0 +1,15 @@
+import type * as djs from '../module.f.ts';
+import { type Result } from '../../types/result/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
+import { type Map } from '../../types/map/module.f.ts';
+import type { Fs } from '../../io/module.f.ts';
+export type ParseContext = {
+    readonly fs: Fs;
+    readonly complete: Map<djsResult>;
+    readonly stack: List<string>;
+    readonly error: string | null;
+};
+export type djsResult = {
+    djs: djs.Unknown;
+};
+export declare const transpile: (fs: Fs) => (path: string) => Result<djs.Unknown, string>;

package/djs/transpiler/module.f.js

@@ -0,0 +1,58 @@
+import { error, ok } from "../../types/result/module.f.js";
+import { fold, drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
+import { tokenize } from "../tokenizer/module.f.js";
+import { setReplace, at } from "../../types/map/module.f.js";
+import { stringToList } from "../../text/utf16/module.f.js";
+import { concat as pathConcat } from "../../path/module.f.js";
+import { parseFromTokens } from "../parser/module.f.js";
+import { run } from "../ast/module.f.js";
+const mapDjs = context => path => {
+    const res = at(path)(context.complete);
+    if (res === null) {
+        throw 'unexpected behaviour';
+    }
+    return res.djs;
+};
+const transpileWithImports = path => parseModuleResult => context => {
+    if (parseModuleResult[0] === 'ok') {
+        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;
+        }
+        const args = toArray(listMap(mapDjs(contextWithImports))(pathsCombine));
+        const djs = { djs: run(parseModuleResult[1][1])(args) };
+        return { ...contextWithImports, stack: drop(1)(contextWithImports.stack), complete: setReplace(path)(djs)(contextWithImports.complete) };
+    }
+    return { ...context, error: parseModuleResult[1] };
+};
+const parseModule = path => context => {
+    const content = context.fs.readFileSync(path, 'utf8');
+    if (content === null) {
+        return error('file not found');
+    }
+    const tokens = tokenize(stringToList(content));
+    return parseFromTokens(tokens);
+};
+const foldNextModuleOp = path => context => {
+    if (context.error !== null) {
+        return context;
+    }
+    if (includes(path)(context.stack)) {
+        return { ...context, error: 'circular dependency' };
+    }
+    if (at(path)(context.complete) !== null) {
+        return context;
+    }
+    const parseModuleResult = parseModule(path)(context);
+    return transpileWithImports(path)(parseModuleResult)(context);
+};
+export const transpile = fs => path => {
+    const context = foldNextModuleOp(path)({ fs, stack: null, complete: null, error: null });
+    if (context.error !== null) {
+        return error(context.error);
+    }
+    const result = at(path)(context.complete)?.djs;
+    return ok(result);
+};

package/djs/transpiler/test.f.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    parse: () => void;
+    parseWithSubModule: () => void;
+    parseWithSubModules: () => void;
+    parseWithFileNotFoundError: () => void;
+    parseWithCycleError: () => void;
+};
+export default _default;

package/djs/transpiler/test.f.js

@@ -0,0 +1,74 @@
+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";
+const virtualFs = map => {
+    return createVirtualIo(map).fs;
+};
+export default {
+    parse: () => {
+        const map = setReplace('a')('export default 1')(null);
+        const fs = virtualFs(map);
+        const result = transpile(fs)('a');
+        if (result[0] === 'error') {
+            throw result[1];
+        }
+        const s = stringify(sort)(result[1]);
+        if (s !== '1') {
+            throw s;
+        }
+    },
+    parseWithSubModule: () => {
+        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/b');
+        if (result[0] === 'error') {
+            throw result[1];
+        }
+        const s = stringify(sort)(result[1]);
+        if (s !== '2') {
+            throw s;
+        }
+    },
+    parseWithSubModules: () => {
+        const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
+        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') {
+            throw result[1];
+        }
+        const s = stringify(sort)(result[1]);
+        if (s !== '[[0,2],[1,2],[0,2]]') {
+            throw s;
+        }
+    },
+    parseWithFileNotFoundError: () => {
+        const map = setReplace('a')('import b from "b"\nexport default b')(null);
+        const fs = virtualFs(map);
+        const result = transpile(fs)('a');
+        if (result[0] !== 'error') {
+            throw result;
+        }
+        if (result[1] !== 'file not found') {
+            throw result;
+        }
+    },
+    parseWithCycleError: () => {
+        const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
+        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') {
+            throw result;
+        }
+        if (result[1] !== 'circular dependency') {
+            throw result;
+        }
+    },
+};

package/fsc.js

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

package/io/module.f.d.ts

@@ -0,0 +1,17 @@
+export type BufferEncoding = 'utf8';
+export type Fs = {
+    readonly writeFileSync: (file: string, data: string) => void;
+    readonly readFileSync: (path: string, options: BufferEncoding) => string | null;
+};
+export type Console = {
+    readonly log: (...d: unknown[]) => void;
+    readonly error: (...d: unknown[]) => void;
+};
+export type Io = {
+    readonly console: Console;
+    readonly fs: Fs;
+    readonly process: Process;
+};
+export type Process = {
+    readonly argv: string[];
+};

package/io/node-io.js

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

package/io/virtual-io.f.d.ts

@@ -0,0 +1,3 @@
+import type { Io } from './module.f.ts';
+import { type Map } from '../types/map/module.f.ts';
+export declare const createVirtualIo: (files: Map<string>) => Io;

package/io/virtual-io.f.js

@@ -0,0 +1,14 @@
+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: []
+    }
+});

package/js/tokenizer/test.f.js

@@ -1,12 +1,12 @@
 import * as tokenizer from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
-import * as djs from "../../djs/module.f.js";
+import * as serializer from "../../djs/serializer/module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = djs.stringify(sort);
+const stringify = serializer.stringify(sort);
 export default {
     djs: [
         () => {

package/json/module.f.d.ts

@@ -4,7 +4,8 @@ type Object = {
     readonly [k in string]: Unknown;
 };
 type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array;
+export type Primitive = boolean | string | number | null;
+export type Unknown = Primitive | Object | Array;
 export declare const setProperty: (value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown;
 export type Entry = object.Entry<Unknown>;
 type Entries = list.List<Entry>;

package/json/tokenizer/test.f.js

@@ -1,12 +1,12 @@
 import * as tokenizer from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
-import * as djs from "../../djs/module.f.js";
+import * as serializer from "../../djs/serializer/module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = djs.stringify(sort);
+const stringify = serializer.stringify(sort);
 export default {
     json: [
         () => {

package/nanvm-lib/tests/test.f.js

@@ -1,17 +1,17 @@
-const e = a => b => {
+const e = (a) => (b) => {
     if (a === b) { }
     else {
         throw [a, '===', b];
     }
 };
-const n = a => b => {
+const n = (a) => (b) => {
     if (a !== b) { }
     else {
         throw [a, '!==', b];
     }
 };
-const nan_res = op => n => {
-    let result = op(n);
+const nan_res = (op) => (n) => {
+    const result = op(n);
     if (!Number.isNaN(result)) {
         throw result;
     }

package/package.json

@@ -1,23 +1,30 @@
 {
   "name": "functionalscript",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "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",
+    "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",
+    "version": "npm run n ./nodejs/version/main.ts",
+    "fsc": "npm run n ./fsc.ts",
     "update": "npm run version && npm run index && npm install"
   },
+  "bin": {
+    "fsc": "fsc.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/functionalscript/functionalscript.git"
@@ -38,7 +45,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.10.5",
-    "typescript": "^5.7.3"
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2"
   }
 }

package/path/module.f.d.ts

@@ -0,0 +1,2 @@
+export declare const normalize: (path: string) => string;
+export declare const concat: (a: string) => (b: string) => string;

package/path/module.f.js

@@ -0,0 +1,31 @@
+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";
+const foldNormalizeOp = input => state => {
+    switch (input) {
+        case '': {
+            return state;
+        }
+        case '..': {
+            switch (last(undefined)(state)) {
+                case undefined:
+                case '..': {
+                    return listConcat(state)([input]);
+                }
+            }
+            return take(length(state) - 1)(state);
+        }
+        default: {
+            return listConcat(state)([input]);
+        }
+    }
+};
+export const normalize = path => {
+    const split = path.replaceAll('\\', '/').split('/');
+    const foldResult = fold(foldNormalizeOp)([])(split);
+    return join('/')(foldResult);
+};
+export const concat = a => b => {
+    const s = stringConcat([a, '/', b]);
+    return normalize(s);
+};

package/path/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    normalize: (() => void)[];
+    concat: (() => void)[];
+};
+export default _default;

package/path/test.f.js

@@ -0,0 +1,49 @@
+import { concat, normalize } from "./module.f.js";
+export default {
+    normalize: [
+        () => {
+            const norm = normalize("dir/file.json");
+            if (norm !== "dir/file.json") {
+                throw norm;
+            }
+        },
+        () => {
+            const norm = normalize("dir//file.json");
+            if (norm !== "dir/file.json") {
+                throw norm;
+            }
+        },
+        () => {
+            const norm = normalize("../../dir/file.json");
+            if (norm !== "../../dir/file.json") {
+                throw norm;
+            }
+        },
+        () => {
+            const norm = normalize("../../dir/../file.json");
+            if (norm !== "../../file.json") {
+                throw norm;
+            }
+        },
+    ],
+    concat: [
+        () => {
+            const c = concat("a")("b");
+            if (c !== "a/b") {
+                throw c;
+            }
+        },
+        () => {
+            const c = concat("a///b/")("c");
+            if (c !== "a/b/c") {
+                throw c;
+            }
+        },
+        () => {
+            const c = concat("a/../b/..")("c");
+            if (c !== "c") {
+                throw c;
+            }
+        },
+    ]
+};

package/text/sgr/module.f.d.ts

@@ -1,8 +1,26 @@
+export declare const backspace: string;
+type End = 'm';
+type Csi = (code: number | string) => string;
 /**
+ * Control Sequence Introducer (CSI) escape sequence.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#Control_Sequence_Introducer_commands
+ *
+ * @param end - The final character that indicates the type of sequence.
+ * @returns A function that takes a code (number or string) and returns the complete ANSI escape sequence.
+ */
+export declare const csi: (end: End) => Csi;
+/**
+ * Specialization of CSI for Select Graphic Rendition (SGR) sequences.
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  */
-export declare const sgr: (c: number) => string;
+export declare const sgr: Csi;
 export declare const reset: string;
 export declare const bold: string;
 export declare const fgRed: string;
 export declare const fgGreen: string;
+export type Stdout = {
+    readonly write: (s: string) => void;
+};
+export type WriteText = (text: string) => WriteText;
+export declare const createConsoleText: (stdout: Stdout) => WriteText;
+export {};