functionalscript 0.1.609 → 0.2.1

package/{commonjs → out/commonjs}/path/module.f.d.mts

@@ -1,30 +1,5 @@
-declare namespace _default {
-    export { parseLocal };
-    export { parseGlobal };
-    export { parse };
-    export { parseAndFind };
-}
-export default _default;
-export type Items = readonly string[];
-export type LocalPath = {
-    readonly external: boolean;
-    readonly dir: boolean;
-    readonly items: Items;
-};
-export type OptionList = readonly [List.List<string>] | null;
-export type IdPath = readonly [string, List.List<string>];
-export type Path = {
-    readonly package: string;
-    readonly items: Items;
-    readonly dir: boolean;
-};
-export type FoundResult = {
-    readonly id: Module.Id;
-    readonly source: string;
-};
-export type Result = FoundResult | null;
 /** @type {(local: string) => (path: string) => LocalPath|null} */
-declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
+export const parseLocal: (local: string) => (path: string) => LocalPath | null;
 /**
  * @typedef {{
  *  readonly package: string,
@@ -35,10 +10,10 @@ declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
 /**
  * @type {(d: (local: string) => string|null) =>
  *  (dir: boolean) =>
- *  (items: List.List<string>) =>
+ *  (items: list.List<string>) =>
  *  Path|null}
  */
-declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: List.List<string>) => Path | null;
+export const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: list.List<string>) => Path | null;
 /**
  * @type {(packageId: string) =>
  *  (dependencies: (local: string) => string|null) =>
@@ -46,7 +21,7 @@ declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolea
  *  (path: string) =>
  *  Path|null }
  */
-declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
+export const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
 /**
  * @typedef {{
  *  readonly id: Module.Id
@@ -61,7 +36,25 @@ declare const parse: (packageId: string) => (dependencies: (local: string) => st
  *  Result
  * }
  */
-declare const parseAndFind: (packageGet: Package.Get) => (moduleId: Module.Id) => (path: string) => Result;
-import * as List from '../../types/list/module.f.mjs';
-import * as Module from '../module/module.f.mjs';
+export const parseAndFind: (packageGet: Package.Get) => (moduleId: Module.Id) => (path: string) => Result;
+export type Items = readonly string[];
+export type LocalPath = {
+    readonly external: boolean;
+    readonly dir: boolean;
+    readonly items: Items;
+};
+export type OptionList = readonly [list.List<string>] | null;
+export type IdPath = readonly [string, list.List<string>];
+export type Path = {
+    readonly package: string;
+    readonly items: Items;
+    readonly dir: boolean;
+};
+export type FoundResult = {
+    readonly id: Module.Id;
+    readonly source: string;
+};
+export type Result = FoundResult | null;
+import * as list from '../../types/list/module.f.mjs';
 import * as Package from '../package/module.f.mjs';
+import * as Module from '../module/module.f.mjs';

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

@@ -0,0 +1,171 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+const { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat } = list;
+import * as string from '../../types/string/module.f.mjs';
+const { join } = string;
+import * as Package from '../package/module.f.mjs';
+import * as Module from '../module/module.f.mjs';
+/** @typedef {readonly string[]} Items */
+/**
+ * @typedef {{
+ *  readonly external: boolean
+ *  readonly dir: boolean
+ *  readonly items: Items
+ * }} LocalPath
+ */
+/** @type {(path: string) => readonly string[]} */
+const split = path => path.split('/');
+/** @typedef {readonly[list.List<string>] | null} OptionList */
+/** @type {(items: string) => (prior: OptionList) => OptionList} */
+const normItemsOp = first => prior => {
+    if (prior === null) {
+        return null;
+    }
+    const tail = prior[0];
+    switch (first) {
+        case '':
+        case '.': {
+            return prior;
+        }
+        case '..': {
+            const result = next(tail);
+            if (result === null) {
+                return null;
+            }
+            return [result.tail];
+        }
+        default: {
+            return [{ first, tail }];
+        }
+    }
+};
+/** @type {(items: list.List<string>) => OptionList} */
+const normItems = items => {
+    const result = fold(normItemsOp)([list.empty])(items);
+    return result === null ? result : [reverse(result[0])];
+};
+const firstNull = first(null);
+/** @type {(local: string) => (path: string) => LocalPath|null} */
+export const parseLocal = local => {
+    /** @type {(path: string) => readonly[boolean, boolean, list.List<string>]} */
+    const fSeq = path => {
+        const pathSeq = split(path);
+        const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1]);
+        return /** @type {readonly (string|null)[]} */ (['.', '..']).includes(firstNull(pathSeq)) ?
+            [false, dir, flat([split(local), pathSeq])] :
+            [true, dir, pathSeq];
+    };
+    // /** @type {(path: string) => LocalPath|null} */
+    return path => {
+        const [external, dir, items] = fSeq(path);
+        const n = normItems(items);
+        if (n === null) {
+            return null;
+        }
+        return {
+            external,
+            dir,
+            items: toArray(n[0])
+        };
+    };
+};
+/** @typedef {readonly[string, list.List<string>]} IdPath */
+/** @type {(prior: readonly[string|null, list.List<string>]) => list.Thunk<IdPath>} */
+const variants = prior => () => {
+    const [a, b] = prior;
+    const r = next(b);
+    if (r === list.empty) {
+        return list.empty;
+    }
+    const { first, tail } = r;
+    /** @type {IdPath} */
+    const n = [a === null ? first : `${a}/${first}`, tail];
+    return { first: n, tail: variants(n) };
+};
+/** @type {(d: (local: string) => string|null) => (p: IdPath) => IdPath|null} */
+const mapDependency = d => ([external, internal]) => {
+    const id = d(external);
+    return id === null ? null : [id, internal];
+};
+/**
+ * @typedef {{
+ *  readonly package: string,
+ *  readonly items: Items,
+ *  readonly dir: boolean,
+ * }} Path
+ */
+/**
+ * @type {(d: (local: string) => string|null) =>
+ *  (dir: boolean) =>
+ *  (items: list.List<string>) =>
+ *  Path|null}
+ */
+export const parseGlobal = dependencies => {
+    const fMap = filterMap(mapDependency(dependencies));
+    return dir => items => {
+        const v = variants([null, items]);
+        const r = firstNull(fMap(v));
+        if (r === null) {
+            return null;
+        }
+        return { package: r[0], items: toArray(r[1]), dir };
+    };
+};
+/**
+ * @type {(packageId: string) =>
+ *  (dependencies: (local: string) => string|null) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Path|null }
+ */
+export const parse = packageId => dependencies => {
+    const pg = parseGlobal(dependencies);
+    return local => path => {
+        const parsed = parseLocal(local)(path);
+        if (parsed === null) {
+            return null;
+        }
+        const { external, dir, items } = parsed;
+        if (!external) {
+            return { package: packageId, items, dir };
+        }
+        return pg(dir)(items);
+    };
+};
+/**
+ * @typedef {{
+ *  readonly id: Module.Id
+ *  readonly source: string
+ * }} FoundResult
+ */
+/** @typedef {FoundResult| null} Result */
+/**
+ * @type {(packageGet: Package.Get) =>
+ *  (moduleId: Module.Id) =>
+ *  (path: string) =>
+ *  Result
+ * }
+ */
+export const parseAndFind = packageGet => moduleId => path => {
+    const currentPack = packageGet(moduleId.package);
+    if (currentPack === null) {
+        return null;
+    }
+    const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path);
+    if (p === null) {
+        return null;
+    }
+    const pack = packageGet(p.package);
+    if (pack === null) {
+        return null;
+    }
+    /** @type {(file: string) => FoundResult | null } */
+    const tryFile = file => {
+        const source = pack.file(file);
+        return source === null ? null : { id: { package: p.package, path: file.split('/') }, source };
+    };
+    const file = p.items.join('/');
+    const indexJs = join('/')(concat(p.items)(['index.js']));
+    const fileList = p.dir || isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs];
+    return firstNull(filterMap(tryFile)(fileList));
+};

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.d.mts

@@ -0,0 +1 @@
+export function todo(): never;

package/out/dev/module.f.mjs

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