functionalscript 0.0.231 → 0.0.235

package/.github/workflows/npm-publish.yml

@@ -30,7 +30,7 @@ jobs:
           node-version: 14
           registry-url: https://registry.npmjs.org/
       - run: npm ci
-      - run: node ./version
+      - run: node ./io/nodejs/version
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/commonjs/index.js

@@ -0,0 +1,11 @@
+/** @typedef {(packageName: string) => PackageMap|Package|undefined} PackageMap */
+
+/** 
+ * @typedef {readonly[
+ *  string, 
+ *  PackageMap, 
+ *  (fileName: string) => string|undefined
+ * ]} Package 
+ */
+
+module.exports = {}

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

@@ -0,0 +1,37 @@
+const json = require('../../json')
+const seq = require('../../types/sequence')
+
+/** 
+ * @typedef {{
+ *  readonly version: string
+ *  readonly dependencies?: Dependencies
+ * }} Package 
+ */
+
+/** @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 [k in string]: string
+ * }} Dependencies
+ */
+
+/** @type {(entry: json.Entry) => boolean} */
+const isDependency = ([,v]) => typeof v === 'string'
+
+/** @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 */
+    isPackage,
+}

package/commonjs/package/test.js

@@ -0,0 +1,14 @@
+const _ = require('.')
+
+{
+    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' }
+}
+
+module.exports = {}

package/commonjs/path/index.js

@@ -0,0 +1,66 @@
+const seq = require("../../types/sequence")
+const option = require("../../types/option")
+const { compose } = require("../../types/function")
+
+/** @typedef {readonly string[]} Items */
+
+/** 
+ * @typedef {{
+ *  readonly external: boolean
+ *  readonly dir: boolean
+ *  readonly items: Items
+ * }} Path 
+ */
+
+/** @type {(path: string) => readonly string[]} */
+const split = path => path.split('/')
+
+/** @type {(s: undefined|seq.Sequence<string>) => (items: string) => undefined|seq.Sequence<string>} */
+const normItemsOp = prior => item => {
+    if (prior === undefined) { return undefined }
+    switch (item) {
+        case '': case '.': { return prior }
+        case '..': {
+            const result = seq.next(prior)
+            if (result === undefined) { return undefined }
+            return result.tail
+        }
+        default: {
+            return seq.sequence(item)(prior)
+        }
+    }
+}
+
+/** @type {(items: seq.Sequence<string>) => seq.Sequence<string>|undefined} */
+const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
+
+/** @type {(local: string) => (path: string) => Path|undefined} */
+const parse = local => {
+    /** @type {(path: string) => readonly[boolean, seq.Sequence<string>]} */
+    const fSeq = path => {
+        const pathSeq = split(path)
+        switch (seq.first(undefined)(pathSeq)) {
+            case '.': case '..': { return [false, seq.flat([split(local), pathSeq])] }
+            default: { return [true, pathSeq] }
+        }
+    }
+    /** @type {(path: string) => Path|undefined} */
+    const f = path => {
+        const [external, items] = fSeq(path)
+        const n = normItems(items)
+        if (n === undefined) { return undefined }
+        return {
+            external,
+            dir: path[path.length - 1] === '/',
+            items: seq.toArray(n)
+        }
+    }
+    return f
+}
+
+module.exports = {
+    /** @readonly */
+    split,
+    /** @readonly */
+    parse,
+}

package/commonjs/path/test.js

@@ -0,0 +1,47 @@
+const _ = require('.')
+const json = require('../../json')
+const { identity, compose } = require('../../types/function')
+const seq = require('../../types/sequence')
+
+const stringify = json.stringify(identity)
+
+{
+    const result = _.parse('')('./a')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') { throw result }
+}
+
+{
+    const result = _.parse('')('./a/')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') { throw result }
+}
+
+{
+    const result = _.parse('')('..')
+    if (result !== undefined) { throw result }
+}
+
+{
+    const result = _.parse('a')('')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":true,"dir":false,"items":[]}') { throw result }
+}
+
+{
+    const result = _.parse('')('./a/b/.././c')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":false,"items":["a","c"]}') { throw result }
+}
+
+{
+    const result = _.parse('x/r')('./a/b/.././c')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":false,"items":["x","r","a","c"]}') { throw result }
+}
+
+{
+    const result = _.parse('a')('a/b/.././c')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') { throw result }
+}

package/commonjs/run/index.js

@@ -0,0 +1,17 @@
+const result = require('../../types/result')
+
+/** @typedef {<T>(req: Require<T>) => (prior: T) => ModuleResult<T>} Module*/
+
+/**
+ * @template T 
+ * @typedef {readonly[result.Result<unknown, unknown>, T]} ModuleResult 
+ */
+
+/**
+ * @template T 
+ * @typedef {(prior: T) => (path: string) => ModuleResult<T>} Require 
+ */
+
+/** @typedef {(source: string) => result.Result<Module, unknown>} Compile */
+
+module.exports = {}

package/io/commonjs/index.js

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

package/io/commonjs/test.js

@@ -0,0 +1,72 @@
+const _ = require('.')
+const run = require('../../commonjs/run')
+
+// ok:
+{
+    const source = 'module.exports = "Hello world!"'
+    const m = _.compile(source)
+    if (m[0] !== 'ok') { throw m }
+    const [result] = m[1](() => { throw 0 })(undefined)
+    if (result[0] !== 'ok') { throw result }
+    if (result[1] !== 'Hello world!') { throw result }
+}
+
+// compilation error:
+{
+    const source = '+'
+    const m = _.compile(source)
+    if (m[0] !== 'error') { throw m }
+}
+
+// compilation error with "use strict;":
+{
+    const source = 'const x = 04'
+    const m = _.compile(source)
+    if (m[0] !== 'error') { throw m }
+}
+
+// runtime error:
+{
+    const source = 'a = 5'
+    const m = _.compile(source)
+    if (m[0] !== 'ok') { throw m }
+    const [result] = m[1](() => { throw 0 })(undefined)
+    if (result[0] !== 'error') { throw result }
+}
+
+//
+{
+    const depSource = 'module.exports = 137'
+    const d = _.compile(depSource)
+    if (d[0] !== 'ok') { throw d }
+
+    /** @type {run.Require<number>} */
+    const req = prior => path => {
+        if (path !== 'm') { throw path }
+        return d[1](req)(prior + 1)
+    }
+
+    let info = 0
+    {
+        const source = 'module.exports = require("m") + 42'
+        const m = _.compile(source)
+        if (m[0] !== 'ok') { throw m }
+
+        const [result, newInfo] = m[1](req)(info)
+        if (result[0] !== 'ok') { throw result }
+        if (result[1] !== 179) { throw result }
+        info = newInfo
+    }
+
+    {
+        const source = 'module.exports = require("x") + 42'
+        const m = _.compile(source)
+        if (m[0] !== 'ok') { throw m }
+
+        const [result, infox] = m[1](req)(info)
+        if (result[0] !== 'error') { throw result }
+        if (infox !== 1) { throw info }
+    }
+}
+
+module.exports = {}

package/io/nodejs/version/index.js

@@ -0,0 +1,20 @@
+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')
+
+const r = b.toString().split('\n').length
+
+const v = `0.0.${r}`
+
+console.log(`version: ${v}`)
+
+const package_json = json.parse(fs.readFileSync('package.json').toString())
+
+if (!isPackage(package_json)) { throw 'error' }
+
+const x = { ...package_json, version: v }
+
+fs.writeFileSync('package.json', JSON.stringify(x, null, 2))

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,22 +1,21 @@
-const seq = require('../sequence')
-const op = require('../sequence/operator')
-const object = require('../object')
-const array = require('../sequence/array')
-const { compose } = require('../function')
+const seq = require('../types/sequence')
+const object = require('../types/object')
+const array = require('../types/array')
+const { todo } = require('../dev')
 
 /** 
  * @typedef {{
- *  readonly [k in string]: Json
+ *  readonly [k in string]: Unknown
  * }} Object 
  */
 
-/** @typedef {readonly Json[]} Array */
+/** @typedef {readonly Unknown[]} Array */
 
-/** @typedef {Object|boolean|string|number|null|Array} Json */
+/** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Json) => (path: seq.Sequence<string>) => (src: Json|undefined) => Json} */
-const addProperty = value => {
-    /** @type {(path: seq.Sequence<string>) => (src: Json|undefined) => Json} */
+/** @type {(value: Unknown) => (path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+const setProperty = value => {
+    /** @type {(path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
     const f = path => src => {
         const result = seq.next(path)
         if (result === undefined) { return value }
@@ -45,11 +44,8 @@ const boolSerialize = value => value ? trueSerialize : falseSerialize
 const colon = [':']
 const comma = [',']
 
-/** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
-const commaValue = a => [seq.concat(comma, a), commaValue]
-
 /** @type {seq.FoldOperator<seq.Sequence<string>>} */
-const joinOp = a => b => seq.concat(a, comma, b)
+const joinOp = a => b => seq.flat([a, comma, b])
 
 /** @type {(input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
 const join = seq.fold(joinOp)([])
@@ -58,26 +54,27 @@ const join = seq.fold(joinOp)([])
 const list = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
-    return input => seq.concat(seqOpen, join(input), seqClose)
+    return input => seq.flat([seqOpen, join(input), seqClose])
 }
 
 const objectList = list('{')('}')
 
 const arrayList = list('[')(']')
 
-/** @typedef {object.Entry<Json>} Entry*/
+/** @typedef {object.Entry<Unknown>} Entry*/
 
 /** @typedef {(seq.Sequence<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Json) => seq.Sequence<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.Sequence<string>} */
 const serialize = sort => {
-    /** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
-    const propertySerialize = ([k, v]) => seq.concat(
+    /** @type {(kv: readonly[string, Unknown]) => seq.Sequence<string>} */
+    const propertySerialize = ([k, v]) => seq.flat([
         stringSerialize(k),
         colon,
-        f(v))
+        f(v)
+    ])
     /** @type {(object: Object) => seq.Sequence<string>} */
     const objectSerialize = input => {
         const entries = Object.entries(input)
@@ -91,7 +88,7 @@ const serialize = sort => {
         const serializedEntries = seq.map(f)(input)
         return arrayList(serializedEntries)
     }
-    /** @type {(value: Json) => seq.Sequence < string >} */
+    /** @type {(value: Unknown) => seq.Sequence < string >} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }
@@ -108,28 +105,31 @@ const serialize = sort => {
 }
 
 /**
- * A version of `JSON.stringify` with an alphabeticly ordered `keys`.
- * 
- * The standard `JSON.stringify` rules determines by 
+ * The standard `JSON.stringify` rules determined by 
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *  
- * @type {(mapEntries: MapEntries) => (value: Json) => string}
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
 const stringify = sort => value => {
     const _s = serialize(sort)(value)
     return seq.join('')(_s)
 }
 
-/** @type {(value: string) => Json} */
+/** @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 */
-    addProperty,
+    setProperty,
     /** @readonly */
     stringify,
     /** @readonly */
     serialize,
     /** @readonly */
     parse,
-}
+    /** @readonly */
+    isObject,
+}

package/json/test.js

@@ -1,40 +1,40 @@
 const json = require('.')
-const { sort } = require('../object')
-const { identity } = require('../function')
+const { sort } = require('../types/object')
+const { identity } = require('../types/function')
 
-if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
+if (json.setProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 
 {
-    const r = json.addProperty("Hello")(['a'])({})
+    const r = json.setProperty("Hello")(['a'])({})
     const x = json.stringify(sort)(r)
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
 {
-    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({}))
+    const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({}))
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
 {
-    const x = json.stringify(sort)(json.addProperty("Hello")(['a'])({c:[],b:12}))
+    const x = json.stringify(sort)(json.setProperty("Hello")(['a'])({c:[],b:12}))
     if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
 }
 
 {
-    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({ c: [], b: 12 }))
+    const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
     if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
 }
 
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
-    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
     const _2 = json.stringify(sort)(_1)
     if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
 }
 
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
-    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
     const _2 = json.stringify(identity)(_1)
     if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
 }