functionalscript 0.0.319 → 0.0.323

package/commonjs/build/index.js

@@ -5,11 +5,12 @@ const { todo } = require('../../dev')
 const map = require('../../types/map')
 const object = require('../../types/object')
 const path = require('../path')
+const stringSet = require('../../types/stringSet')
 
 /**
  * @template M
  * @typedef {{
- *  readonly pagkageGet: package_.Get
+ *  readonly packageGet: package_.Get
  *  readonly moduleMapInterface: module_.MapInterface<M>
  *  readonly moduleId: module_.Id
  *  readonly moduleMap: M
@@ -35,26 +36,43 @@ const notFound = moduleMap => [['error', ['file not found']], moduleMap]
  */
 const getOrBuild = compile => packageGet => moduleMapInterface =>  {
     /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
-    /** @type {(moduleId: module_.Id) => function_.Require<[map.Map<string>, M]>} */
-    const req = moduleId => p => prior => {
-        const r = path.parseAndFind(packageGet)(moduleId)(p)
-        if (r === undefined) { return [['error', 'file not found'], prior] }
-        const requireMap = map.set(p)(module_.idToString(moduleId))(prior[0])
-        r
-        return todo()
+
+    /** @type {(buildSet: stringSet.StringSet) => (moduleId: module_.Id) => (source: string) => (moduleMap: M) => Result<M>} */
+    const build = buildSet => moduleId => {
+        const moduleIdStr = module_.idToString(moduleId)
+        const buildSet1 = stringSet.set(moduleIdStr)(buildSet)
+        const dir = module_.dir(moduleId)
+        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
+        const require_ = p => ([requireMap, m]) => {
+            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
+            const error = e => [['error', 'file not found'], [requireMap, m]]
+            if (dir === undefined) { return error('file not found') }
+            const r = path.parseAndFind(packageGet)(dir)(p)
+            if (r === undefined) { return error('file not found') }
+            const rIdStr = module_.idToString(r.id)
+            if (stringSet.contains(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], [map.set(p)(rIdStr)(requireMap), m1]]
+        }
+        return source => moduleMap => {
+            /** @type {(s: module_.State) => (m: M) => Result<M>} */
+            const set = s => m => [s, moduleMapInterface.set(moduleIdStr)(s)(m)]
+            /** @type {(e: module_.Error) => (m: M) => Result<M>} */
+            const error = e => set(['error', e])
+            // check compilation
+            const j = compile(source)
+            if (j[0] === 'error') { return error(['compilation error', j[1]])(moduleMap) }
+            // build
+            const [r, [requireMap, moduleMap2]] = j[1](require_)([undefined, moduleMap])
+            const x = r[0] === 'error' ?
+                error(['runtime error', r[1]]) :
+                set(['ok', { exports: r[1], requireMap: object.fromMap(requireMap) }])
+            return x(moduleMap2)
+        }
     }
-    /**
-     * @type {(moduleId: module_.Id) =>
-     *  (moduleMapFirst: M) =>
-     *  Result<M>
-     * }
-     */
+    /** @type {(moduleId: module_.Id) => (moduleMap: M) => Result<M>} */
     const f = moduleId => moduleMap => {
         const moduleIdStr = module_.idToString(moduleId)
-        /** @type {(s: module_.State) => (m: M) => Result<M>} */
-        const set = s => m => [s, moduleMapInterface.insert(moduleIdStr)(s)(m)]
-        /** @type {(e: module_.Error) => (m: M) => Result<M>} */
-        const error = e => set(['error', e])
         // check moduleMap
         {
             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
@@ -64,114 +82,12 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         const p = packageGet(moduleId.package)
         if (p === undefined) { return notFound(moduleMap) }
         // check file
-        const f = p.file(moduleId.path.join('/'))
-        if (f === undefined) { return notFound(moduleMap) }
-        // check compilation
-        const j = compile(f)
-        if (j[0] === 'error') { return error(['compilation error', j[1]])(moduleMap) }
-        // build
-        const [r, [requireMap, moduleMap2]] = j[1](req(moduleId))([undefined, moduleMap])
-        const x = r[0] === 'error' ?
-            error(['runtime error', r[1]]) :
-            set(['ok', { exports: r[1], requireMap: object.fromEntries(map.entries(requireMap)) }])
-        return x(moduleMap2)
+        const source = p.file(moduleId.path.join('/'))
+        return (source === undefined ? notFound : build(undefined)(moduleId)(source))(moduleMap)
     }
     return f
 }
 
-// /**
-//  * @type {(packageGet: package_.Get) =>
-//  *  <M>(moduleMapInterface: module_.MapInterface<M>) =>
-//  *  (compile: function_.Compile) =>
-//  *  (moduleId: module_.Id) =>
-//  *  (moduleMapFirst: M) =>
-//  *  Result<M>
-//  * }
-//  */
-// const getOrBuild = packageGet => moduleMapInterface => compile => moduleId => {
-
-//     /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
-
-//     const moduleIdStr = module_.idToString(moduleId)
-
-//     /** @type {(e: module_.Error) => (moduleMap: M) => Result<M>} */
-//     const error = e => moduleMap => {
-//         /** @type {module_.State} */
-//         const state = ['error', e]
-//         return [state, moduleMapInterface.insert(moduleIdStr)(state)(moduleMap)]
-//     }
-
-//     /** @type {function_.Require<readonly[M, map.Map<string>]>} */
-//     const require_ = pathStr => prior => {
-//         const pathResult = path.parseAndFind(packageGet)(moduleId.packageId)(moduleIdStr)(pathStr)
-//         if (pathResult === undefined) { return [['error', `file not found: '${pathStr}'`], prior] }
-//         const mId = { packageId: pathResult.package, path: pathResult.file.split('/') }
-//         const [state, newMap] = getOrBuild
-//             (packageGet)
-//             (moduleMapInterface)
-//             (compile)
-//             (mId)
-//             (prior[0])
-//         switch (state[0]) {
-//             case 'ok': {
-//                 const newRequireMap = map.set(pathStr)(module_.idToString(mId))(prior[1])
-//                 return [
-//                     ['ok', state[1].exports],
-//                     [newMap, newRequireMap]
-//                 ]
-//             }
-//             case 'building': {
-//                 return todo()
-//             }
-//             // 'ok'
-//             default: {
-//                 return todo()
-//             }
-//         }
-//     }
-
-//     return moduleMapFirst => {
-//         let moduleMap = moduleMapFirst
-
-//         {
-//             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-//             if (m !== undefined) { return [m, moduleMap] }
-//         }
-
-//         const p = packageGet(moduleId.packageId)
-//         if (p === undefined) { return notFound(moduleMap) }
-
-//         const source = p.file(moduleId.path.join('/'))
-//         if (source === undefined) { return notFound(moduleMap) }
-
-//         const compileResult = compile(source)
-//         if (compileResult[0] === 'error') { return error(['compilation error', compileResult[1]])(moduleMap) }
-
-//         const moduleFunction = compileResult[1]
-
-//         moduleMap = moduleMapInterface.insert(moduleIdStr)(['building'])(moduleMap)
-
-//         const [[type, exportsOrError], [newModuleMap, requireMap]] = moduleFunction(require_)([moduleMap, map.empty])
-//         moduleMap = newModuleMap
-
-//         {
-//             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-//             if (m === undefined ) { throw 'm === undefined' }
-//             if (m[0] !== 'building') { return [m, moduleMap] }
-//         }
-
-//         /** @type {module_.State} */
-//         const result = type === 'error' ?
-//             ['error', ['runtime error', exportsOrError]] :
-//             ['ok', {
-//                 exports: exportsOrError,
-//                 requireMap: object.fromMap(requireMap)
-//             }]
-
-//         return [result, moduleMapInterface.insert(moduleIdStr)(result)(moduleMap)]
-//     }
-// }
-
 module.exports = {
     /** @readonly */
     getOrBuild,

package/commonjs/build/test.js

@@ -0,0 +1,77 @@
+const _ = require('.')
+const map = require('../../types/map')
+const module_ = require('../module')
+const function_ = require('../module/function')
+const result = require('../../types/result')
+const package_ = require('../package')
+
+/** @type {{ readonly [k in string]?: result.Result<function_.Function_, unknown> }} */
+const compileMap = {
+    ':index.js': [
+        'ok',
+        require_ => m0 => {
+            const [r1, m1] = require_('./b')(m0);
+            if (r1[0] === 'error') { throw r1 }
+            const [r2, m2] = require_('./a/')(m1);
+            if (r2[0] === 'error') { throw r2 }
+            const [r3, m3] = require_('x/r')(m2);
+            if (r3[0] === 'error') { throw r3 }
+            return [['ok', ':index.js'], m3]
+        }],
+    ':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 {function_.Compile} */
+const compile = source => compileMap[source] ?? ['error', 'invalid source']
+
+/** @type {{ readonly [k in string]?: { readonly dependencies: { readonly [k in string]?: string }, files:{ readonly [k in string]?: string } }}} */
+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 = packageMap[packageId]
+    return p === undefined ? undefined :
+        {
+            dependency: dependency => p.dependencies[dependency],
+            file: file => p.files[file]
+        }
+}
+
+const getOrBuild = _.getOrBuild
+    (compile)
+    (packageGet)
+    (/** @type {module_.MapInterface<map.Map<module_.State>>} */(map))
+
+{
+    const [r] = getOrBuild({ package: '', path: ['index.js'] })(undefined)
+    if (JSON.stringify(r) !==
+        '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]'
+    ) {
+        throw r
+    }
+}

package/commonjs/module/index.js

@@ -4,7 +4,7 @@ const object = require('../../types/object')
  * @template M
  * @typedef {{
  *  readonly at: (moduleId: string) => (moduleMap: M) => State | undefined
- *  readonly insert: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ *  readonly set: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
  * }} MapInterface
  */
 
@@ -38,10 +38,22 @@ const object = require('../../types/object')
  * }} Id
  */
 
+/** @type {(id: Id) => Id | undefined} */
+const dir = id => {
+    const len = id.path.length
+    if (len < 1) { return undefined }
+    return {
+        package: id.package,
+        path: id.path.slice(0, len - 1)
+    }
+}
+
 /** @type {(id: Id) => string} */
 const idToString = id => `${id.package}/${id.path.join('/')}`
 
 module.exports = {
+    /** @readonly */
+    dir,
     /** @readonly */
     idToString,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.319",
+  "version": "0.0.323",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -12,6 +12,7 @@ require('./commonjs/package/test')
 require('./commonjs/path/test')
 require('./types/function/compare/test')
 require('./types/stringSet/test')
+require('./commonjs/build/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }