functionalscript 0.2.0 → 0.2.1

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

@@ -0,0 +1,102 @@
+import * as _ from './module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+import * as Module from '../module/module.f.mjs';
+import * as ModuleFunction from '../module/function/module.f.mjs';
+import * as Result from '../../types/result/module.f.mjs';
+import * as Package from '../package/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { at } = o;
+/** @type {{ readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }} */
+const compileMap = {
+    ':index.js': [
+        'ok',
+        require_ => m0 => {
+            let [r, m] = require_('./b')(m0);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            [r, m] = require_('./a/')(m);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            [r, m] = require_('x/r')(m);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            return [['ok', ':index.js'], m];
+        }
+    ],
+    ':b.js': [
+        'ok',
+        () => m0 => [['ok', ':b.js'], m0]
+    ],
+    ':a/index.js': [
+        'ok',
+        () => m0 => [['ok', ':a/index.js'], m0]
+    ],
+    'x:r.js': [
+        'ok',
+        () => m0 => [['ok', 'x:r.js'], m0]
+    ],
+};
+/** @type {ModuleFunction.Compile} */
+const compile = source => compileMap[source] ?? ['error', 'invalid source'];
+/** @typedef {{ readonly [k in string]: string }} StringMap */
+/** @type {{ readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}} */
+const packageMap = {
+    '': {
+        dependencies: {
+            'x': '/node_modules/x'
+        },
+        files: {
+            'index.js': ':index.js',
+            'b.js': ':b.js',
+            'a/index.js': ':a/index.js',
+        }
+    },
+    '/node_modules/x': {
+        dependencies: {},
+        files: {
+            'r.js': 'x:r.js'
+        }
+    },
+};
+/** @type {Package.Get} */
+const packageGet = packageId => {
+    const p = at(packageId)(packageMap);
+    return p === null ? null :
+        {
+            dependency: dependency => at(dependency)(p.dependencies),
+            file: file => at(file)(p.files),
+        };
+};
+const getOrBuild = _.getOrBuild(compile)(packageGet)(/** @type {Module.MapInterface<map.Map<Module.State>>} */ (map));
+export default () => {
+    let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty);
+    {
+        if (r === null) {
+            throw 'r === null';
+        }
+        const x = JSON.stringify(r);
+        if (x !==
+            '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]') {
+            throw `0:${x}`;
+        }
+    }
+    {
+        [r, m] = getOrBuild({ package: '', path: ['b.js'] })(m);
+        const x = JSON.stringify(r);
+        if (x !==
+            '["ok",{"exports":":b.js","requireMap":{}}]') {
+            throw x;
+        }
+    }
+    {
+        [r, m] = getOrBuild({ package: '', path: ['c.js'] })(m);
+        const x = JSON.stringify(r);
+        if (x !==
+            '["error",["file not found"]]') {
+            throw x;
+        }
+    }
+};

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

@@ -0,0 +1,15 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * An IO interface for creating and running module functions.
+ */
+import * as TypesResult from '../../../types/result/module.f.mjs';
+/** @typedef {<M>(require: Require<M>) => (prior: M) => Result<M>} Function_ */
+/**
+ * @template M
+ * @typedef {readonly[TypesResult.Result<unknown, unknown>, M]} Result
+ */
+/**
+ * @template M
+ * @typedef {(path: string) => (prior: M) => Result<M>} Require
+ */
+/** @typedef {(source: string) => TypesResult.Result<Function_, unknown>} Compile */

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

@@ -0,0 +1,48 @@
+// @ts-self-types="./module.f.d.mts"
+import * as O from '../../types/object/module.f.mjs';
+/**
+ * @template M
+ * @typedef {{
+ *  readonly at: (moduleId: string) => (moduleMap: M) => State | null
+ *  readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ * }} MapInterface
+ */
+/**
+ * @typedef {|
+ *  readonly['ok', Module] |
+ *  readonly['error', Error]
+ * } State
+ */
+/**
+ * @typedef {{
+ *  readonly exports: unknown
+ *  readonly requireMap: O.Map<string>
+ * }} Module
+ */
+/**
+ * @typedef {|
+ *  ['file not found'] |
+ *  ['compilation error', unknown] |
+ *  ['runtime error', unknown] |
+ *  ['circular reference']
+ * } Error
+ */
+/**
+ * @typedef {{
+ *  readonly package: string
+ *  readonly path: readonly string[]
+ * }} Id
+ */
+/** @type {(id: Id) => Id | null} */
+export const dir = id => {
+    const len = id.path.length;
+    if (len < 1) {
+        return null;
+    }
+    return {
+        package: id.package,
+        path: id.path.slice(0, len - 1)
+    };
+};
+/** @type {(id: Id) => string} */
+export const idToString = id => `${id.package}/${id.path.join('/')}`;

package/out/commonjs/module.f.mjs

@@ -0,0 +1,10 @@
+// @ts-self-types="./module.f.d.mts"
+export {};
+/** @typedef {(packageName: string) => PackageMap|Package|null} PackageMap */
+/**
+ * @typedef {readonly[
+ *  string,
+ *  PackageMap,
+ *  (fileName: string) => string|null
+ * ]} Package
+ */

package/out/commonjs/module.mjs

@@ -0,0 +1,26 @@
+import unsafeResult from '../types/result/module.mjs';
+const { tryCatch } = unsafeResult;
+import * as result from '../types/result/module.f.mjs';
+const { unwrap } = result;
+import * as ModuleFunction from './module/function/module.f.mjs';
+/** @type {(f: Function) => ModuleFunction.Function_} */
+const build = f => immutableRequire => mutableData => {
+    /** @type {(path: string) => unknown} */
+    const mutableRequire = path => {
+        const [result, data] = immutableRequire(path)(mutableData);
+        // Side effect: setting a variable from a nested function (closure)
+        // is not allowed in FunctionalScript.
+        mutableData = data;
+        return unwrap(result);
+    };
+    const result = tryCatch(() => {
+        const mutableModule = { exports: {} };
+        f(mutableModule, mutableRequire);
+        return mutableModule.exports;
+    });
+    return [result, mutableData];
+};
+/** @type {ModuleFunction.Compile} */
+export const compile = source => 
+// Side effect: a `Function` constructor is not allowed in FunctionalScript.
+tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)));

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

@@ -0,0 +1,21 @@
+// @ts-self-types="./module.f.d.mts"
+import * as json from '../../../json/module.f.mjs';
+const { isObject } = json;
+import * as list from '../../../types/list/module.f.mjs';
+const { map, every } = list;
+const { entries } = Object;
+/** @typedef {readonly[string, string]} DependencyJson */
+/** @typedef {{readonly[k in string]: string}} DependencyMapJson */
+/** @typedef {DependencyMapJson|null} DependenciesJson */
+/** @type {(entry: json.Entry) => boolean} */
+const isDependencyJson = ([, v]) => typeof v === 'string';
+/** @type {(j: json.Unknown) => j is DependenciesJson} */
+export const isDependenciesJson = j => {
+    if (j === null) {
+        return true;
+    }
+    if (!isObject(j)) {
+        return false;
+    }
+    return every(map(isDependencyJson)(entries(j)));
+};

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

@@ -0,0 +1,15 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    if (!_.isDependenciesJson(null)) {
+        throw 'error';
+    }
+    if (!_.isDependenciesJson({})) {
+        throw 'error';
+    }
+    if (!_.isDependenciesJson({ 'a': 'b' })) {
+        throw 'error';
+    }
+    if (_.isDependenciesJson({ 'a': 12 })) {
+        throw 'error';
+    }
+};

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

@@ -0,0 +1,40 @@
+// @ts-self-types="./module.f.d.mts"
+import * as json from '../../json/module.f.mjs';
+const { isObject } = json;
+import * as dependencies from './dependencies/module.f.mjs';
+const { isDependenciesJson } = dependencies;
+import * as o from '../../types/object/module.f.mjs';
+const { at } = o;
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly version: string
+ *  readonly dependencies?: dependencies.DependenciesJson
+ * }} PackageJson
+ */
+/** @type {(j: json.Unknown) => j is PackageJson} */
+export const isPackageJson = j => {
+    if (!isObject(j)) {
+        return false;
+    }
+    if (typeof j.name !== 'string') {
+        return false;
+    }
+    if (typeof j.version !== 'string') {
+        return false;
+    }
+    if (!isDependenciesJson(at('dependencies')(j))) {
+        return false;
+    }
+    return true;
+};
+/**
+ * @typedef {{
+ *  readonly dependency: (localPackageId: string) => string | null
+ *  readonly file: (localFileId: string) => string | null
+ * }} Package
+ */
+/**
+ * @note Current package has an empty string '' as a packageId.
+ * @typedef {(packageId: string) => Package | null} Get
+ */

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

@@ -0,0 +1,27 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    if (_.isPackageJson(null)) {
+        throw 'error';
+    }
+    if (_.isPackageJson({})) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ name: 'x', version: 12 })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'x', version: "12" })) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ version: "", dependencies: [] })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'a', version: "", dependencies: {} })) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ name: 'b', version: "", dependencies: { x: 12 } })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'c', version: "", dependencies: { x: "12" } })) {
+        throw 'error';
+    }
+};

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