functionalscript 0.2.0 → 0.2.2

package/out/commonjs/path/test.f.mjs

@@ -0,0 +1,231 @@
+import * as _ from './module.f.mjs';
+import * as dev from '../../dev/module.f.mjs';
+const { todo } = dev;
+import * as json from '../../json/module.f.mjs';
+import * as f from '../../types/function/module.f.mjs';
+const { identity } = f;
+import * as object from '../../types/object/module.f.mjs';
+const { at } = object;
+import * as Package from '../package/module.f.mjs';
+/** @type {<T>(o: object.Map<T>) => (s: string) => T|null} */
+const i = o => s => at(s)(o);
+/** @type {(g: json.Unknown) => string} */
+const stringify = json.stringify(identity);
+export default {
+    0: () => {
+        const result = _.parseLocal('')('./a');
+        if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') {
+            throw result;
+        }
+    },
+    1: () => {
+        const result = _.parseLocal('')('./a/');
+        if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') {
+            throw result;
+        }
+    },
+    2: () => {
+        const result = _.parseLocal('')('..');
+        if (result !== null) {
+            throw result;
+        }
+    },
+    3: () => {
+        const result = _.parseLocal('a')('');
+        if (stringify(result) !== '{"external":true,"dir":true,"items":[]}') {
+            throw result;
+        }
+    },
+    4: () => {
+        const result = _.parseLocal('')('./a/b/.././c');
+        if (stringify(result) !== '{"external":false,"dir":false,"items":["a","c"]}') {
+            throw result;
+        }
+    },
+    5: () => {
+        const result = _.parseLocal('x/r')('./a/b/.././c');
+        if (stringify(result) !== '{"external":false,"dir":false,"items":["x","r","a","c"]}') {
+            throw result;
+        }
+    },
+    6: () => {
+        const result = _.parseLocal('a')('a/b/.././c');
+        if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') {
+            throw result;
+        }
+    },
+    7: () => {
+        const result = _.parseLocal('')('./x/..');
+        if (stringify(result) !== '{"external":false,"dir":true,"items":[]}') {
+            throw result;
+        }
+    },
+    8: {
+        0: () => { if (_.parseGlobal(() => null)(false)(['a', 'b']) !== null) {
+            throw 'error';
+        } },
+        1: () => { if (_.parseGlobal(() => null)(false)(['b']) !== null) {
+            throw 'error';
+        } },
+        2: () => { if (_.parseGlobal(i({ b: 'x' }))(false)(['d']) !== null) {
+            throw 'error';
+        } },
+        3: () => {
+            const result = stringify(_.parseGlobal(i({ b: 'x' }))(false)(['b']));
+            if (result !== '{"package":"x","items":[],"dir":false}') {
+                throw result;
+            }
+        },
+        4: () => { if (_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b']) !== null) {
+            throw 'error';
+        } },
+        5: () => {
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b', 'r']));
+            if (result !== '{"package":"x","items":[],"dir":false}') {
+                throw result;
+            }
+        },
+        6: () => {
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']));
+            if (result !== '{"package":"x","items":["d","t"],"dir":false}') {
+                throw result;
+            }
+        },
+        7: () => {
+            const result = stringify(_.parseGlobal(i({ 'b/r': 'x' }))(true)(['b', 'r', 'd', 't']));
+            if (result !== '{"package":"x","items":["d","t"],"dir":true}') {
+                throw result;
+            }
+        },
+    },
+    9: () => {
+        /** @type {object.Map<Package.Package>} */
+        const packages = {
+            '': {
+                dependency: () => todo(),
+                file: i({ 'a/c': 'return "a/c"' }),
+            }
+        };
+        const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('../c'));
+        if (result !== '{"id":{"package":"","path":["a","c"]},"source":"return \\"a/c\\""}') {
+            throw result;
+        }
+    },
+    10: () => {
+        /** @type {object.Map<Package.Package>} */
+        const packages = {
+            '': {
+                dependency: x => {
+                    const path = `node_modules/${x}`;
+                    return at(path)(packages) !== null ? path : null;
+                },
+                file: i({
+                    'index.js': 'return "index.js"',
+                    'x/index.js': 'return "x/index.js"',
+                    'x.js': 'return "x.js"',
+                })
+            },
+            'node_modules/z': {
+                dependency: () => todo(),
+                file: i({ 'a/c/index.js': 'return "a/c"' }),
+            }
+        };
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'));
+            if (result !== '{"id":{"package":"node_modules/z","path":["a","c","index.js"]},"source":"return \\"a/c\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('../..'));
+            if (result !== '{"id":{"package":"","path":["index.js"]},"source":"return \\"index.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x'));
+            if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x.js'));
+            if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: [] })('./x/'));
+            if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['x', 'a'] })('../'));
+            if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['x', 'a'] })('..'));
+            if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') {
+                throw result;
+            }
+        }
+    },
+    11: () => {
+        /** @type {object.Map<Package.Package>} */
+        const packages = {
+            '': {
+                dependency: x => {
+                    const path = `node_modules/${x}`;
+                    return at(path)(packages) !== null ? path : null;
+                },
+                file: todo
+            },
+            'node_modules/z/a': {
+                dependency: () => todo(),
+                file: i({
+                    'c/index.js': 'return "c/index.js"',
+                    'c.js': 'return "c.js"'
+                }),
+            }
+        };
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'));
+            if (result !== '{"id":{"package":"node_modules/z/a","path":["c.js"]},"source":"return \\"c.js\\""}') {
+                throw result;
+            }
+        }
+        {
+            const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c/'));
+            if (result !== '{"id":{"package":"node_modules/z/a","path":["c","index.js"]},"source":"return \\"c/index.js\\""}') {
+                throw result;
+            }
+        }
+    },
+    12: () => {
+        /** @type {object.Map<Package.Package>} */
+        const packages = {
+            '': {
+                dependency: x => {
+                    const path = `node_modules/${x}`;
+                    return at(path)(packages) !== null ? path : null;
+                },
+                file: todo
+            },
+            'node_modules/z/a/c': {
+                dependency: () => todo(),
+                file: i({
+                    '': 'throw',
+                    '.js': 'throw',
+                    'index.js': 'return "a/c"'
+                }),
+            }
+        };
+        const result = stringify(_.parseAndFind(i(packages))({ package: '', path: ['a', 'b'] })('z/a/c'));
+        if (result !== '{"id":{"package":"node_modules/z/a/c","path":["index.js"]},"source":"return \\"a/c\\""}') {
+            throw result;
+        }
+    }
+};

package/out/commonjs/test.mjs

@@ -0,0 +1,87 @@
+import * as _ from './module.mjs';
+import * as Run from './module/function/module.f.mjs';
+export default {
+    ok: () => {
+        const source = 'module.exports = "Hello world!"';
+        const m = _.compile(source);
+        if (m[0] !== 'ok') {
+            throw m;
+        }
+        const [result] = m[1](() => { throw 0; })(null);
+        if (result[0] !== 'ok') {
+            throw result;
+        }
+        if (result[1] !== 'Hello world!') {
+            throw result;
+        }
+    },
+    compilationError: () => {
+        const source = '+';
+        const m = _.compile(source);
+        if (m[0] !== 'error') {
+            throw m;
+        }
+    },
+    compilationErrorStrict: () => {
+        const source = 'const x = 04';
+        const m = _.compile(source);
+        if (m[0] !== 'error') {
+            throw m;
+        }
+    },
+    runtimeError: () => {
+        const source = 'a = 5';
+        const m = _.compile(source);
+        if (m[0] !== 'ok') {
+            throw m;
+        }
+        const [result] = m[1](() => { throw 0; })(null);
+        if (result[0] !== 'error') {
+            throw result;
+        }
+    },
+    test: () => {
+        const depSource = 'module.exports = 137';
+        const d = _.compile(depSource);
+        if (d[0] !== 'ok') {
+            throw d;
+        }
+        /** @type {Run.Require<number>} */
+        const req = path => prior => {
+            if (path !== 'm') {
+                throw path;
+            }
+            return d[1](req)(prior + 1);
+        };
+        let info = 0;
+        {
+            const source = 'module.exports = require("m") + 42';
+            const m = _.compile(source);
+            if (m[0] !== 'ok') {
+                throw m;
+            }
+            const [result, newInfo] = m[1](req)(info);
+            if (result[0] !== 'ok') {
+                throw result;
+            }
+            if (result[1] !== 179) {
+                throw result;
+            }
+            info = newInfo;
+        }
+        {
+            const source = 'module.exports = require("x") + 42';
+            const m = _.compile(source);
+            if (m[0] !== 'ok') {
+                throw m;
+            }
+            const [result, infox] = m[1](req)(info);
+            if (result[0] !== 'error') {
+                throw result;
+            }
+            if (infox !== 1) {
+                throw info;
+            }
+        }
+    }
+};

package/out/dev/index.mjs

@@ -0,0 +1,2 @@
+import { index } from "./module.mjs";
+index();

package/out/dev/module.f.mjs

@@ -0,0 +1,2 @@
+// @ts-self-types="./module.f.d.mts"
+export const todo = () => { throw 'not implemented'; };

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.substring(2)}`]);
+    const exports = Object.fromEntries(exportsA);
+    await writeFile(jj, JSON.stringify({ ...jsr_json, exports }, null, 2));
+};

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');
+    }
+};