functionalscript 0.0.233 → 0.0.234

package/commonjs/package/dependencies/index.js

@@ -0,0 +1,71 @@
+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 getDirectory = packageJson => {
+    if (!isObject(packageJson)) { return empty }
+    const dep = packageJson['dependencies']
+    if (dep === undefined || !isObject(dep)) { return empty }
+    const result = seq.reduce(addDirectory)(map.empty)(Object.entries(dep))
+    return func(result)
+}
+
+module.exports = {
+    /** @readonly */
+    getDirectory,
+}

package/commonjs/package/dependencies/test.js

@@ -0,0 +1,33 @@
+const _ = require('.')
+
+{
+    const packageJson = { dependencies: {} }
+    const dir = _.getDirectory(packageJson)
+    const r = dir('x')
+    if (r !== undefined) { throw r }
+}
+
+{
+    const packageJson = { dependencies: { 'x': 'e' } }
+    const dir = _.getDirectory(packageJson)
+    const r = dir('x')
+    if (r !== 'e') { throw r }
+}
+
+{
+    const packageJson = { 
+        dependencies: { 
+            'x/a': 'xa',
+            'x/b': 'xb'
+        } 
+    }
+    const dir = _.getDirectory(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/package/index.js

@@ -1,72 +1,37 @@
-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
+ *  readonly version: string
+ *  readonly dependencies?: Dependencies
+ * }} Package 
  */
 
-/** @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)
+/** @type {(j: json.Unknown) => j is Package} */
+const isPackage = j => {
+    if (!json.isObject(j)) { return false }
+    if (typeof j.version !== 'string') { return false }
+    if (j.dependencies !== undefined && !isDependencies(j.dependencies)) { return false }
+    return true
 }
 
-/** @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
-}
+/**
+ * @typedef {{
+ *  readonly [k in string]: string
+ * }} Dependencies
+ */
 
-/** @type {(m: Map) => Directory} */
-const func = m => dir => {
-    const r = m.get(dir)
-    if (typeof r !== 'object') { return r }
-    return func(r)
-}
+/** @type {(entry: json.Entry) => boolean} */
+const isDependency = ([,v]) => typeof v === 'string'
 
-/** @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)
+/** @type {(j: json.Unknown) => j is Dependencies} */
+const isDependencies = j => {
+    if (!json.isObject(j)) { return false }
+    return seq.every(seq.map(isDependency)(Object.entries(j)))
 }
 
 module.exports = {
     /** @readonly */
-    dependencies,
+    isPackage,
 }

package/commonjs/package/test.js

@@ -1,33 +1,14 @@
 const _ = require('.')
 
 {
-    const packageJson = { dependencies: {} }
-    const dir = _.dependencies(packageJson)
-    const r = dir('x')
-    if (r !== undefined) { throw r }
+    if (_.isPackage(null)) { throw 'error' }
+    if (_.isPackage({})) { throw 'error' }
+    if (_.isPackage({version:12})) { throw 'error' }
+    if (!_.isPackage({version:"12"})) { throw 'error' }
+    if (_.isPackage({version:"",dependencies:[]})) { throw 'error' }
+    if (!_.isPackage({ version: "", dependencies: {} })) { throw 'error' }
+    if (_.isPackage({ version: "", dependencies: { x: 12} })) { throw 'error' }
+    if (!_.isPackage({ version: "", dependencies: { x: "12" } })) { throw 'error' }
 }
 
-{
-    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 }
-}
+module.exports = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.233",
+  "version": "0.0.234",
   "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/dependencies/test')
 require('./commonjs/package/test')
 
 /** @type {() => never} */

package/version.js

@@ -1,6 +1,7 @@
 const cp = require('child_process')
 const fs = require('fs')
 const json = require('./json')
+const { isPackage } = require('./commonjs/package')
 
 const b =cp.execSync('git log --oneline')
 
@@ -10,8 +11,10 @@ const v = `0.0.${r}`
 
 console.log(`version: ${v}`)
 
-let package_json = json.parse(fs.readFileSync('package.json').toString())
+const package_json = json.parse(fs.readFileSync('package.json').toString())
 
-package_json = json.setProperty(v)(['version'])(package_json)
+if (!isPackage(package_json)) { throw 'error' }
 
-fs.writeFileSync('package.json', JSON.stringify(package_json, null, 2))
+const x = { ...package_json, version: v }
+
+fs.writeFileSync('package.json', JSON.stringify(x, null, 2))