functionalscript 0.1.609 → 0.2.1

package/out/dev/module.mjs

@@ -0,0 +1,167 @@
+import { readdir, writeFile, readFile } from 'node:fs/promises';
+/**
+ * @typedef {{
+ *  readonly withFileTypes: true
+ * }} Options
+ */
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly isDirectory: () => boolean
+ * }} Dirent
+ */
+/**
+ * @typedef {{
+ *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
+ *  readonly readFile: (path: string, options: 'utf8') => Promise<string>
+ * }} FsPromises
+ */
+/**
+ * @typedef {{
+ *  readonly default?: unknown
+ * }} Module
+ */
+/** @typedef {(name: string) => unknown} Require */
+/**
+ * @typedef {{
+ *  readonly[k in string]: unknown
+ * }} UnknownMap
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/** @type {(a: Entry<unknown>, b: Entry<unknown>) => number} */
+const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
+/**
+ * @typedef {{
+ *  [k in string]: Module
+ * }} MutableModuleMap
+ */
+/**
+ * @typedef {{
+ *  readonly[k in string]: Module
+ * }} ModuleMap
+ */
+/** @type {(v: readonly string[]) => (dif: number) => readonly string[]} */
+const remove_tail = v => dif => v.slice(0, v.length - dif);
+/** @type {any} */
+const self = globalThis;
+/** @type {(code: number) => never} */
+export const exit = self.Deno ? self.Deno.exit : process.exit;
+/** @type {(v: string) => string|undefined} */
+export const env = self.Deno ? self.Deno.env.get :
+    a => {
+        const r = Object.getOwnPropertyDescriptor(process.env, a);
+        return r === void 0 ? void 0 :
+            typeof r.get === 'function' ? r.get() :
+                r.value;
+    };
+export const loadModuleMap = async () => {
+    /** @type {() => Promise<UnknownMap>} */
+    const load = async () => {
+        /** @type {(readonly[string, unknown])[]} */
+        const map = [];
+        /** @type {(path: string) => Promise<void>} */
+        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);
+                    }
+                    else if (name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
+                        const source = await import(`../${file}`);
+                        map.push([file, source.default]);
+                    }
+                }
+            }
+        };
+        await f('.');
+        map.sort(cmp);
+        return Object.fromEntries(map);
+    };
+    const map = await load();
+    /** @type {() => ModuleMap} */
+    const build = () => {
+        /** @type {MutableModuleMap} */
+        const d = {};
+        /** @type {(base: readonly string[]) => (k: string) => readonly[string, Module]} */
+        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];
+                }
+            }
+            {
+                /** @type {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();
+};
+/**
+ * @typedef {{
+ *  readonly[k in string]: string | FolderMap
+ * }} FolderMap
+ */
+/** @type {(m: FolderMap) => (s: readonly string[]) => FolderMap } */
+const folderMapAdd = m => s => {
+    const [first, ...rest] = s;
+    const firstResult = m[first];
+    return typeof firstResult === 'string'
+        ? m
+        : {
+            ...m,
+            [first]: rest.length === 1
+                ? rest[0]
+                : folderMapAdd(firstResult === undefined ? {} : firstResult)(rest)
+        };
+};
+const indent = '  ';
+/** @type {(i: string) => (p: string) => (m: FolderMap) => readonly[string,string]} */
+const codeAdd = i => p => m => {
+    let result = '';
+    let im = '';
+    for (const [k, v] of Object.entries(m)) {
+        const np = `${p}${k}`;
+        if (typeof v === 'string') {
+            result += `${i}${k}: ${np},\n`;
+            im += `import ${np} from './${np.replaceAll('$', '/')}/${v}'\n`;
+        }
+        else {
+            const [r, x] = codeAdd(i + indent)(`${np}\$`)(v);
+            result += `${i}${k}: \{\n`;
+            result += r;
+            result += `${i}\},\n`;
+            im += x;
+        }
+    }
+    return [result, im];
+};
+export const index = async () => {
+    const jj = './jsr.json';
+    const n = '/module.f.mjs';
+    const jsr_json = JSON.parse(await readFile(jj, { encoding: 'utf8' }));
+    const list = Object.keys(await loadModuleMap()).filter(v => v.endsWith(n));
+    const exportsA = list.filter(v => !v.startsWith('./out')).map(v => [v.replace(n, ''), `./out/${v}`]);
+    const exports = Object.fromEntries(exportsA);
+    await writeFile(jj, JSON.stringify({ ...jsr_json, exports }, null, 2));
+};

package/{dev → out/dev}/test/module.f.d.mts

@@ -1,4 +1,5 @@
-export default main;
+declare const _default: <T>(input: Input<T>) => readonly [number, T];
+export default _default;
 export type DependencyMap = { readonly [k in string]?: Module; };
 export type Module = {
     readonly default?: unknown;
@@ -21,6 +22,4 @@ export type TestState = {
     readonly fail: number;
 };
 export type FullState<T> = readonly [TestState, T];
-/** @type {<T>(input: Input<T>) => readonly[number, T]} */
-declare const main: <T>(input: Input<T>) => readonly [number, T];
 import * as Result from '../../types/result/module.f.mjs';

package/out/dev/test/module.f.mjs

@@ -0,0 +1,134 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+const { fold } = list;
+import * as sgr from '../../text/sgr/module.f.mjs';
+const { reset, fgGreen, fgRed, bold } = sgr.codes;
+import * as Result from '../../types/result/module.f.mjs';
+/**
+ * @typedef {{
+ *  readonly[k in string]?: Module
+ * }} DependencyMap
+ */
+/**
+ * @typedef {{
+ *  readonly default?: unknown
+ * }} Module
+ */
+/**
+ * @typedef {{
+ *  readonly[k in string]: Module
+ * }} ModuleMap
+ */
+/**
+ * @template T
+ * @typedef {(v: string) => (state: T) => T} Log
+ */
+/**
+ * @template T
+ * @typedef {<R>(f: () => R) => (state: T) => readonly[R, number, T]} Measure
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly moduleMap: ModuleMap,
+ *  readonly log: Log<T>,
+ *  readonly error: Log<T>,
+ *  readonly measure: Measure<T>,
+ *  readonly state: T,
+ *  readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>,
+ *  readonly env: (n: string) => string|undefined
+ * }} Input
+ */
+/** @type {(s: string) => boolean} */
+const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js');
+/**
+ * @typedef {{
+ *  readonly time: number,
+ *  readonly pass: number,
+ *  readonly fail: number,
+ * }} TestState
+ */
+/** @type {(time: number) => (testState: TestState) => TestState} */
+const addPass = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
+/** @type {(time: number) => (testState: TestState) => TestState} */
+const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
+/**
+ * @template T
+ * @typedef {readonly[TestState, T]} FullState
+ */
+/** @type {(a: number) => string} */
+const timeFormat = a => {
+    const y = Math.round(a * 10_000).toString();
+    const yl = 5 - y.length;
+    const x = '0'.repeat(yl > 0 ? yl : 0) + y;
+    const s = x.length - 4;
+    const b = x.substring(0, s);
+    const e = x.substring(s);
+    return `${b}.${e} ms`;
+};
+/** @type {<T>(input: Input<T>) => readonly[number, T]} */
+export default input => {
+    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
+    const isGitHub = env('GITHUB_ACTION') !== void 0;
+    /** @typedef {input extends Input<infer T> ? T : never} T */
+    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
+    const f = ([k, v]) => {
+        /** @type {(i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>} */
+        const test = i => v => ([ts, state]) => {
+            const next = test(`${i}| `);
+            switch (typeof v) {
+                case 'function': {
+                    if (v.length === 0) {
+                        const [[s, r], delta, state0] = measure(() => tryCatch(/** @type {() => unknown} */ (v)))(state);
+                        state = state0;
+                        if (s === 'error') {
+                            ts = addFail(delta)(ts);
+                            if (isGitHub) {
+                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state);
+                            }
+                            else {
+                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state);
+                                state = error(`${fgRed}${r}${reset}`)(state);
+                            }
+                        }
+                        else {
+                            ts = addPass(delta)(ts);
+                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state);
+                        }
+                        [ts, state] = next(r)([ts, state]);
+                    }
+                    break;
+                }
+                case 'object': {
+                    if (v !== null) {
+                        /** @type {(k: readonly[string|number, unknown]) => (fs: FullState<T>) => FullState<T>} */
+                        const f = ([k, v]) => ([time, state]) => {
+                            state = log(`${i}${k}:`)(state);
+                            [time, state] = next(v)([time, state]);
+                            return [time, state];
+                        };
+                        [ts, state] = fold(f)([ts, state])(v instanceof Array ? list.entries(v) : Object.entries(v));
+                    }
+                    break;
+                }
+            }
+            return [ts, state];
+        };
+        return ([ts, state]) => {
+            if (isTest(k)) {
+                state = log(`testing ${k}`)(state);
+                [ts, state] = test('| ')(v.default)([ts, state]);
+            }
+            return [ts, state];
+        };
+    };
+    /** @type {TestState} */
+    let ts = { time: 0, pass: 0, fail: 0 };
+    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
+    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
+    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state);
+    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
+    return [ts.fail !== 0 ? 1 : 0, state];
+};

package/out/dev/test.f.mjs

@@ -0,0 +1,58 @@
+/** @type {() => never} */
+const assert = () => { throw 'assert'; };
+/** @type {(_: boolean) => void} */
+const assert_if = c => { if (c) {
+    throw 'assert_if';
+} };
+export default {
+    ctor: () => {
+        const c = (() => { })['constructor'];
+        const f = c('return 5');
+        const result = f();
+        if (result !== 5) {
+            throw 'function';
+        }
+    },
+    ctorEmpty: () => {
+        /** @type {any} */
+        const o = {};
+        const c = o['constructor'];
+        // console.log(c)
+        // console.log(c(()=>{}))
+    },
+    ctorUndefined: () => {
+        /** @type {any} */
+        const o = {
+            constructor: void 0
+        };
+        const c = o['constructor'];
+        //console.log(c)
+    },
+    number: () => {
+        /** @type {any} */
+        const b = '42';
+        const r = Number(b);
+        //console.log(r)
+    },
+    properties: () => {
+        /** @type {any} */
+        const o = {};
+        //const c = o['constructor']
+        //const c = o['__proto__']
+        //const c = o['__defineGetter__']
+        //const c = o['__defineSetter__']
+        //const c = o['__lookupGetter__']
+        //const c = o['__lookupSetter__']
+        //const c = o['hasOwnProperty']
+        //const c = o['isPrototypeOf']
+        //const c = o['propertyIsEnumerable']
+        //const c = o['toString']
+        const c = o['valueOf'];
+        //console.log(c)
+    },
+    getOwnPropertyDescriptor: () => {
+        const x = { 'a': 12 };
+        const c = Object.getOwnPropertyDescriptor(x, 'constructor');
+        const a = Object.getOwnPropertyDescriptor(x, 'a');
+    }
+};

package/out/dev/test.mjs

@@ -0,0 +1,52 @@
+import { loadModuleMap, exit, env } from './module.mjs';
+import test from './test/module.f.mjs';
+/** @type {(f: (s: string) => void) => (s: string) => <T>(_: T) => T} */
+const anyLog = f => s => state => {
+    f(s);
+    return state;
+};
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+/** @type {<T>(f: () => T) => Result<T, unknown>} */
+const tryCatch = f => {
+    // `try catch` is not allowed in FunctionalScript.
+    try {
+        return ['ok', f()];
+    }
+    catch (e) {
+        return ['error', e];
+    }
+};
+/** @type {<R>(f: () => R) => <T>(state: T) => readonly[R, number, T]} Measure} */
+const measure = f => state => {
+    const b = performance.now();
+    const r = f();
+    const e = performance.now();
+    return [r, e - b, state];
+};
+// test runner.
+const main = async () => {
+    const moduleMap = await loadModuleMap();
+    const r = test({
+        moduleMap,
+        log: anyLog(console.log),
+        error: anyLog(console.error),
+        measure,
+        tryCatch,
+        env,
+        state: void 0,
+    });
+    exit(r[0]);
+};
+main();

package/{djs → out/djs}/module.f.d.mts

@@ -1,25 +1,20 @@
-declare namespace _default {
-    export { stringify };
-    export { serialize };
-}
-export default _default;
-export type Object = { readonly [k in string]: Unknown; };
-export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array | bigint;
-export type Entry = O.Entry<Unknown>;
-export type Entries = (List.List<Entry>);
-export type MapEntries = (entries: Entries) => Entries;
+/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export 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
  *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-/** @typedef {O.Entry<Unknown>} Entry*/
-/** @typedef {(List.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
-declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List.List<string>;
+export const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+export type Object = { readonly [k in string]: Unknown; };
+export type Array = readonly Unknown[];
+export type Unknown = Object | boolean | string | number | null | Array | bigint;
+export type Entry = O.Entry<Unknown>;
+export type Entries = (list.List<Entry>);
+export type MapEntries = (entries: Entries) => Entries;
+import * as list from '../types/list/module.f.mjs';
 import * as O from '../types/object/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';

package/out/djs/module.f.mjs

@@ -0,0 +1,75 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { flat, map } = list;
+import * as string from '../types/string/module.f.mjs';
+const { concat } = string;
+import * as O from '../types/object/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';
+const { compose, fn } = f;
+const { entries } = Object;
+import * as bi from '../types/bigint/module.f.mjs';
+const { serialize: bigintSerialize } = bi;
+import * as j from '../json/serializer/module.f.mjs';
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+/** @typedef {readonly Unknown[]} Array */
+/** @typedef {Object|boolean|string|number|null|Array|bigint} Unknown */
+const colon = [':'];
+/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize = sort => {
+    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ]);
+    const mapPropertySerialize = map(propertySerialize);
+    /** @type {(object: Object) => list.List<string>} */
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result;
+    /** @type {(value: Unknown) => list.List<string>} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': {
+                return boolSerialize(value);
+            }
+            case 'number': {
+                return numberSerialize(value);
+            }
+            case 'string': {
+                return stringSerialize(value);
+            }
+            case 'bigint': {
+                return [bigintSerialize(value)];
+            }
+            default: {
+                if (value === null) {
+                    return nullSerialize;
+                }
+                if (value instanceof Array) {
+                    return arraySerialize(value);
+                }
+                return objectSerialize(value);
+            }
+        }
+    };
+    const arraySerialize = compose(map(f))(arrayWrap);
+    return f;
+};
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+export const stringify = sort => compose(serialize(sort))(concat);

package/{djs → out/djs}/parser/module.f.d.mts

@@ -1,21 +1,19 @@
-declare namespace _default {
-    export { parse };
-}
-export default _default;
+/** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
+export const parse: (tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
 export type DjsModule = [readonly string[], readonly DjsConst[]];
 export type DjsConst = boolean | string | number | null | bigint | DjsModuleRef | DjsArray | DjsObject;
 export type DjsModuleRef = ["aref" | "cref", number];
 export type DjsArray = ["array", readonly DjsConst[]];
 export type DjsObject = { readonly [k in string]: DjsConst; };
-export type DjsStackArray = ["array", List.List<DjsConst>];
-export type DjsStackObject = ["object", Map.Map<DjsConst>, string];
+export type DjsStackArray = ["array", list.List<DjsConst>];
+export type DjsStackObject = ["object", map.Map<DjsConst>, string];
 export type DjsStackElement = DjsStackArray | DjsStackObject;
-export type DjsStack = List.List<DjsStackElement>;
+export type DjsStack = list.List<DjsStackElement>;
 export type ParserState = InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState;
 export type ModuleState = {
-    readonly refs: Map.Map<DjsModuleRef>;
-    readonly modules: List.List<string>;
-    readonly consts: List.List<DjsConst>;
+    readonly refs: map.Map<DjsModuleRef>;
+    readonly modules: list.List<string>;
+    readonly consts: list.List<DjsConst>;
 };
 export type InitialState = {
     readonly state: "";
@@ -52,9 +50,7 @@ export type ErrorState = {
     readonly state: "error";
     readonly message: string;
 };
-/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<DjsModule, string>} */
-declare const parse: (tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<DjsModule, string>;
-import * as List from '../../types/list/module.f.mjs';
-import * as Map from '../../types/map/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
 import * as tokenizerT from '../tokenizer/module.f.mjs';
-import * as Result from '../../types/result/module.f.mjs';
+import * as result from '../../types/result/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';