functionalscript 0.0.232 → 0.0.233

package/commonjs/package/index.js

@@ -0,0 +1,72 @@
+const { todo } = require('../../dev')
+const json = require('../../json')
+const { isObject } = json
+const seq = require('../../types/sequence')
+const { split } = require('../path')
+const map = require('../../types/map')
+
+/** @typedef {(directoryName: string) => undefined|string|Directory} Directory */
+
+const empty = () => undefined
+
+/** 
+ * @typedef {{
+ *  readonly get: (dir: string) => Item|undefined
+ *  readonly set: (dir: string) => (item: Item) => Map
+ * }} Map
+ */
+
+/** @typedef {Map|string} Item */
+
+/** @typedef {readonly[string, Map]} Pair */
+
+/** @type {(prior: seq.Sequence<Pair>) => (dir: string) => seq.Sequence<Pair>} */
+const get = prior => dir => {
+    const result = seq.next(prior)
+    if (result === undefined) { throw 'panic' }
+    const { first: [,m] } = result
+    const child = m.get(dir)
+    const childMap = child === undefined || typeof child === 'string' ? map.empty : child
+    /** @type {Pair} */
+    const pair = [dir, childMap]
+    return seq.sequence(pair)(prior)
+}
+
+/** @typedef {readonly[string, Item]} Result */
+
+/** @type {(a: Result) => (b: Pair) => Result} */
+const set = ([aDir, item]) => ([bDir, bMap]) => [bDir, bMap.set(aDir)(item)]
+
+/** @type {(prior: Map) => (entry: json.Entry) => Map} */
+const addDirectory = prior => ([directory, id]) => {
+    if (typeof id !== 'string') { return prior }
+    const path = split(directory)
+    const rev = seq.reduce(get)([['', prior]])(path)
+    const result = seq.next(rev)
+    if (result === undefined) { throw 'panic' }
+    const { first: [dir], tail } = result
+    const [, m] = seq.reduce(set)([dir, id])(tail)
+    if (typeof m === 'string') { return prior }
+    return m
+}
+
+/** @type {(m: Map) => Directory} */
+const func = m => dir => {
+    const r = m.get(dir)
+    if (typeof r !== 'object') { return r }
+    return func(r)
+}
+
+/** @type {(packageJson: json.Unknown) => Directory} */
+const dependencies = packageJson => {
+    if (!isObject(packageJson)) { return empty }
+    const dependencies = packageJson['dependencies']
+    if (dependencies === undefined || !isObject(dependencies)) { return empty }
+    const result = seq.reduce(addDirectory)(map.empty)(Object.entries(dependencies))
+    return func(result)
+}
+
+module.exports = {
+    /** @readonly */
+    dependencies,
+}

package/commonjs/package/test.js

@@ -0,0 +1,33 @@
+const _ = require('.')
+
+{
+    const packageJson = { dependencies: {} }
+    const dir = _.dependencies(packageJson)
+    const r = dir('x')
+    if (r !== undefined) { throw r }
+}
+
+{
+    const packageJson = { dependencies: { 'x': 'e' } }
+    const dir = _.dependencies(packageJson)
+    const r = dir('x')
+    if (r !== 'e') { throw r }
+}
+
+{
+    const packageJson = { 
+        dependencies: { 
+            'x/a': 'xa',
+            'x/b': 'xb'
+        } 
+    }
+    const dir = _.dependencies(packageJson)
+    const x = dir('x')
+    if (typeof x !== 'function') { throw x }
+    const xa = x('a')
+    if (xa !== 'xa') { throw xa }
+    const xb = x('b')
+    if (xb !== 'xb') { throw xb }
+    const xc = x('c')
+    if (xc !== undefined) { throw xc }
+}

package/commonjs/path/index.js

@@ -12,7 +12,7 @@ const { compose } = require("../../types/function")
  * }} Path 
  */
 
-/** @type {(path: string) => seq.Sequence<string>} */
+/** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
 /** @type {(s: undefined|seq.Sequence<string>) => (items: string) => undefined|seq.Sequence<string>} */
@@ -59,6 +59,8 @@ const parse = local => {
 }
 
 module.exports = {
+    /** @readonly */
+    split,
     /** @readonly */
     parse,
 }

package/io/commonjs/index.js

@@ -1,34 +1,28 @@
-const { ok, error } = require('../../types/result')
+const { tryCatch } = require('../result')
+const { unwrap } = require('../../types/result')
 const run = require('../../commonjs/run')
 
 /** @type {(f: Function) => run.Module} */
-const runModule = f => req => info => {
+const createModule = f => req => mutableInfo => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
-        const [result, newInfo] = req(info)(path)
-        info = newInfo
-        if (result[0] === 'error') { throw result[1] }
-        return result[1]
+        const [result, info] = req(mutableInfo)(path)
+        mutableInfo = info
+        return unwrap(result)
     }
-    const mutableModule = { exports: {} }
-    try {
+    const result = tryCatch(() => {
+        const mutableModule = { exports: {} }
         f(mutableModule, mutableRequire)
-    } catch (e) {
-        return [error(e), info]
-    }
-    return [ok(mutableModule.exports), info]
+        return mutableModule.exports
+    })
+    return [result, mutableInfo]
 }
 
 /** @type {run.Compile} */
-const compile = source => {
-    try {
-        return ok(runModule(Function('module', 'require', `"use strict";${source}`)))
-    } catch (e) {
-        return error(e)
-    }
-}
+const compile = source => 
+    tryCatch(() => createModule(Function('module', 'require', `"use strict";${source}`)))
 
 module.exports = {
     /** @readonly */
     compile,
-}
+}

package/io/result/index.js

@@ -0,0 +1,15 @@
+const result = require('../../types/result')
+
+/** @type {<T>(f: () => T) => result.Result<T, unknown>} */
+const tryCatch = f => {
+    try {
+        return result.ok(f())
+    } catch (e) {
+        return result.error(e)
+    }
+}
+
+module.exports = {
+    /** @readonly */
+    tryCatch,
+}

package/json/index.js

@@ -1,6 +1,7 @@
 const seq = require('../types/sequence')
 const object = require('../types/object')
 const array = require('../types/array')
+const { todo } = require('../dev')
 
 /** 
  * @typedef {{
@@ -104,8 +105,6 @@ const serialize = sort => {
 }
 
 /**
- * A version of `JSON.stringify` with an alphabeticly ordered `keys`.
- * 
  * The standard `JSON.stringify` rules determined by 
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *  
@@ -119,6 +118,9 @@ const stringify = sort => value => {
 /** @type {(value: string) => Unknown} */
 const parse = value => JSON.parse(value)
 
+/** @type {(value: Unknown) => value is Object} */
+const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array)
+
 module.exports = {
     /** @readonly */
     setProperty,
@@ -128,4 +130,6 @@ module.exports = {
     serialize,
     /** @readonly */
     parse,
-}
+    /** @readonly */
+    isObject,
+}

package/package.json

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

package/test.js

@@ -5,6 +5,7 @@ require('./types/btree/test')
 require('./json/test')
 require('./types/object/test')
 require('./io/commonjs/test')
+require('./commonjs/package/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/types/result/index.js

@@ -20,9 +20,17 @@ const ok = value => ['ok', value]
 /** @type {<E>(e: E) => Error<E>} */
 const error = e => ['error', e]
 
+/** @type {<T, E>(r: Result<T, E>) => T} */
+const unwrap = result => {
+    if (result[0] === 'error') { throw result[1] }
+    return result[1]
+}
+
 module.exports = {
     /** @readonly */
     ok,
     /** @readonly */
     error,
+    /** @readonly */
+    unwrap,
 }