functionalscript 0.3.4 → 0.3.5

package/com/types/testlib.f.d.ts

@@ -0,0 +1,44 @@
+declare const _default: {
+    Slice: {
+        struct: {
+            Start: ["*", "u8"];
+            Size: "usize";
+        };
+    };
+    ManagedStruct: {
+        struct: {
+            M: ["IMy"];
+        };
+    };
+    IMy: {
+        guid: string;
+        interface: {
+            GetSlice: {
+                _: ["Slice"];
+            };
+            SetSlice: {
+                slice: ["Slice"];
+            };
+            GetUnsafe: {
+                _: ["*", "bool"];
+            };
+            SetUnsafe: {
+                p: ["*", ["Slice"]];
+                size: "u32";
+            };
+            Some: {
+                p: ["IMy"];
+                _: "bool";
+            };
+            GetIMy: {
+                a: "u16";
+                b: "i16";
+                _: ["IMy"];
+            };
+            SetManagedStruct: {
+                a: ["ManagedStruct"];
+            };
+        };
+    };
+};
+export default _default;

package/com/types/{testlib.f.ts → testlib.f.js}

@@ -1,5 +1,4 @@
-import * as _ from './module.f.ts'
-
+import * as _ from "./module.f.js";
 export default {
     Slice: {
         struct: {
@@ -27,4 +26,4 @@ export default {
             SetManagedStruct: { a: ['ManagedStruct'] },
         },
     }
-} satisfies _.Library
+};

package/commonjs/build/module.f.d.ts

@@ -0,0 +1,6 @@
+import * as package_ from '../package/module.f.ts';
+import { type MapInterface, type Id, type State } from '../module/module.f.ts';
+import * as function_ from '../module/function/module.f.ts';
+type Result<M> = readonly [State, M];
+export declare const getOrBuild: (compile: function_.Compile) => (packageGet: package_.Get) => <M>(moduleMapInterface: MapInterface<M>) => (moduleId: Id) => (moduleMap: M) => Result<M>;
+export {};

package/commonjs/build/module.f.js

@@ -0,0 +1,69 @@
+import * as package_ from "../package/module.f.js";
+import { idToString, dir, } from "../module/module.f.js";
+import * as function_ from "../module/function/module.f.js";
+import * as map from "../../types/map/module.f.js";
+const { empty: mapEmpty, setReplace } = map;
+import * as object from "../../types/object/module.f.js";
+const { fromMap } = object;
+import * as path from "../path/module.f.js";
+const { parseAndFind } = path;
+import * as stringSet from "../../types/string_set/module.f.js";
+const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet;
+const notFound = moduleMap => [['error', ['file not found']], moduleMap];
+export const getOrBuild = compile => packageGet => moduleMapInterface => {
+    const build = buildSet => moduleId => {
+        const moduleIdStr = idToString(moduleId);
+        const buildSet1 = setSet(moduleIdStr)(buildSet);
+        const moduleDir = dir(moduleId);
+        const require_ = p => ([requireMap, m]) => {
+            const error = e => [['error', e], [requireMap, m]];
+            if (moduleDir === null) {
+                return error('file not found');
+            }
+            const r = parseAndFind(packageGet)(moduleDir)(p);
+            if (r === null) {
+                return error('file not found');
+            }
+            const rIdStr = idToString(r.id);
+            if (setContains(rIdStr)(buildSet1)) {
+                return error('circular reference');
+            }
+            const [state, m1] = build(buildSet1)(r.id)(r.source)(m);
+            return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]];
+        };
+        return source => moduleMap => {
+            const set = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)];
+            const error = e => set(['error', e]);
+            // check compilation
+            const [kind, result] = compile(source);
+            if (kind === 'error') {
+                return error(['compilation error', result])(moduleMap);
+            }
+            // build
+            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap]);
+            const x = state === 'error' ?
+                error(['runtime error', value]) :
+                set(['ok', { exports: value, requireMap: fromMap(requireMap) }]);
+            return x(moduleMap2);
+        };
+    };
+    const f = moduleId => moduleMap => {
+        const moduleIdStr = idToString(moduleId);
+        // check moduleMap
+        {
+            const m = moduleMapInterface.at(moduleIdStr)(moduleMap);
+            if (m !== null) {
+                return [m, moduleMap];
+            }
+        }
+        // check package
+        const p = packageGet(moduleId.package);
+        if (p === null) {
+            return notFound(moduleMap);
+        }
+        // check file
+        const source = p.file(moduleId.path.join('/'));
+        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap);
+    };
+    return f;
+};

package/commonjs/build/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/commonjs/build/test.f.js

@@ -0,0 +1,96 @@
+import * as _ from "./module.f.js";
+import * as map from "../../types/map/module.f.js";
+import * as Module from "../module/module.f.js";
+import * as ModuleFunction from "../module/function/module.f.js";
+import * as Result from "../../types/result/module.f.js";
+import * as Package from "../package/module.f.js";
+import { at } from "../../types/object/module.f.js";
+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]
+    ],
+};
+const compile = source => compileMap[source] ?? ['error', 'invalid source'];
+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'
+        }
+    },
+};
+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)(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/commonjs/module/function/{module.f.ts → module.f.d.ts}

@@ -1,13 +1,8 @@
 /**
  * An IO interface for creating and running module functions.
  */
-
-import * as TypesResult from '../../../types/result/module.f.ts'
-
-export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>
-
-export type Result<M> = readonly[TypesResult.Result<unknown, unknown>, M]
-
-export type Require<M> = (path: string) => (prior: M) => Result<M>
-
-export type Compile = (source: string) => TypesResult.Result<Function_, unknown>
+import * as TypesResult from '../../../types/result/module.f.ts';
+export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>;
+export type Result<M> = readonly [TypesResult.Result<unknown, unknown>, M];
+export type Require<M> = (path: string) => (prior: M) => Result<M>;
+export type Compile = (source: string) => TypesResult.Result<Function_, unknown>;

package/commonjs/module/function/module.f.js

@@ -0,0 +1,4 @@
+/**
+ * An IO interface for creating and running module functions.
+ */
+import * as TypesResult from "../../../types/result/module.f.js";

package/commonjs/module/module.f.d.ts

@@ -0,0 +1,18 @@
+import * as O from '../../types/object/module.f.ts';
+export type MapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => State | null;
+    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;
+};
+export type State = readonly ['ok', Module] | readonly ['error', Error];
+type Module = {
+    readonly exports: unknown;
+    readonly requireMap: O.Map<string>;
+};
+export type Error = ['file not found'] | ['compilation error', unknown] | ['runtime error', unknown] | ['circular reference'];
+export type Id = {
+    readonly package: string;
+    readonly path: readonly string[];
+};
+export declare const dir: (id: Id) => Id | null;
+export declare const idToString: (id: Id) => string;
+export {};

package/commonjs/module/module.f.js

@@ -0,0 +1,12 @@
+import * as O from "../../types/object/module.f.js";
+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)
+    };
+};
+export const idToString = id => `${id.package}/${id.path.join('/')}`;

package/commonjs/module.f.d.ts

@@ -0,0 +1,6 @@
+type PackageMap = (packageName: string) => PackageMap | Package | null;
+type Package = readonly [
+    string,
+    PackageMap,
+    (fileName: string) => string | null
+];

package/commonjs/module.f.js

@@ -0,0 +1 @@
+"use strict";

package/commonjs/package/dependencies/module.f.d.ts

@@ -0,0 +1,7 @@
+import { type Unknown } from '../../../json/module.f.ts';
+type DependencyMapJson = {
+    readonly [k in string]: string;
+};
+export type DependenciesJson = DependencyMapJson | null;
+export declare const isDependenciesJson: (j: Unknown) => j is DependenciesJson;
+export {};

package/commonjs/package/dependencies/module.f.js

@@ -0,0 +1,13 @@
+import { isObject } from "../../../json/module.f.js";
+import { map, every } from "../../../types/list/module.f.js";
+const { entries } = Object;
+const isDependencyJson = ([, v]) => typeof v === 'string';
+export const isDependenciesJson = (j) => {
+    if (j === null) {
+        return true;
+    }
+    if (!isObject(j)) {
+        return false;
+    }
+    return every(map(isDependencyJson)(entries(j)));
+};

package/commonjs/package/dependencies/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/commonjs/package/dependencies/test.f.js

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

package/commonjs/package/module.f.d.ts

@@ -0,0 +1,17 @@
+import { type Unknown } from '../../json/module.f.ts';
+import { type DependenciesJson } from './dependencies/module.f.ts';
+type PackageJson = {
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies?: DependenciesJson;
+};
+export declare const isPackageJson: (j: Unknown) => j is PackageJson;
+export type Package = {
+    readonly dependency: (localPackageId: string) => string | null;
+    readonly file: (localFileId: string) => string | null;
+};
+/**
+ * @note Current package has an empty string '' as a packageId.
+ */
+export type Get = (packageId: string) => Package | null;
+export {};

package/commonjs/package/module.f.js

@@ -0,0 +1,18 @@
+import { isObject } from "../../json/module.f.js";
+import { isDependenciesJson } from "./dependencies/module.f.js";
+import { at } from "../../types/object/module.f.js";
+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;
+};

package/commonjs/package/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/commonjs/package/test.f.js

@@ -0,0 +1,27 @@
+import * as _ from "./module.f.js";
+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/commonjs/path/module.f.d.ts

@@ -0,0 +1,24 @@
+import { type List } from '../../types/list/module.f.ts';
+import * as Package from '../package/module.f.ts';
+import * as Module from '../module/module.f.ts';
+type Items = readonly string[];
+type LocalPath = {
+    readonly external: boolean;
+    readonly dir: boolean;
+    readonly items: Items;
+};
+export declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
+type Path = {
+    readonly package: string;
+    readonly items: Items;
+    readonly dir: boolean;
+};
+export declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: List<string>) => Path | null;
+export declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
+type FoundResult = {
+    readonly id: Module.Id;
+    readonly source: string;
+};
+type Result = FoundResult | null;
+export declare const parseAndFind: (packageGet: Package.Get) => (moduleId: Module.Id) => (path: string) => Result;
+export {};

package/commonjs/path/module.f.js

@@ -0,0 +1,114 @@
+import { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat, empty } from "../../types/list/module.f.js";
+import { join } from "../../types/string/module.f.js";
+import * as Package from "../package/module.f.js";
+import * as Module from "../module/module.f.js";
+const split = path => path.split('/');
+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 }];
+        }
+    }
+};
+const normItems = items => {
+    const result = fold(normItemsOp)([empty])(items);
+    return result === null ? result : [reverse(result[0])];
+};
+const firstNull = first(null);
+export const parseLocal = local => {
+    const fSeq = path => {
+        const pathSeq = split(path);
+        const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1]);
+        return ['.', '..'].includes(firstNull(pathSeq)) ?
+            [false, dir, flat([split(local), pathSeq])] :
+            [true, dir, pathSeq];
+    };
+    return path => {
+        const [external, dir, items] = fSeq(path);
+        const n = normItems(items);
+        if (n === null) {
+            return null;
+        }
+        return {
+            external,
+            dir,
+            items: toArray(n[0])
+        };
+    };
+};
+const variants = prior => () => {
+    const [a, b] = prior;
+    const r = next(b);
+    if (r === empty) {
+        return empty;
+    }
+    const { first, tail } = r;
+    const n = [a === null ? first : `${a}/${first}`, tail];
+    return { first: n, tail: variants(n) };
+};
+const mapDependency = d => ([external, internal]) => {
+    const id = d(external);
+    return id === null ? null : [id, internal];
+};
+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 };
+    };
+};
+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);
+    };
+};
+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;
+    }
+    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/commonjs/path/test.f.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    0: () => void;
+    1: () => void;
+    2: () => void;
+    3: () => void;
+    4: () => void;
+    5: () => void;
+    6: () => void;
+    7: () => void;
+    8: {
+        0: () => void;
+        1: () => void;
+        2: () => void;
+        3: () => void;
+        4: () => void;
+        5: () => void;
+        6: () => void;
+        7: () => void;
+    };
+    9: () => void;
+    10: () => void;
+    11: () => void;
+    12: () => void;
+};
+export default _default;