functionalscript 0.0.231 → 0.0.232

package/module-manager/node/test.js

@@ -1,75 +0,0 @@
-const mm = require('..')
-const i = require('.')
-
-/** @type {{ readonly [_ in string]: string}} */
-const files = {
-    'index.js': './index.js',
-    'a/index.js': './a/index.js',
-    'a/b/x.js': './a/b/x.js',
-    'c/t.js': './c/t.js',
-    'node_modules/@functionalscript/functionalscript/package.json': '',
-    'node_modules/@functionalscript/functionalscript/index.js': '@functionalscript/functionalscript ./index.js',
-    'node_modules/my/package.json': '',
-    'node_modules/my/src/x.js': 'my ./src/x.js',
-    'node_modules/my/b/index.js': 'my ./b/index.js',
-}
-
-/** @type {(_: string) => string|undefined} */
-const readFile = path => files[path]
-
-const root = i(readFile)
-
-{
-    const index = mm.getModule(root)('.')
-    if (index === undefined) { throw 'no module' }
-    if (index.fileName !== 'index.js') { throw 'fileName' }
-    if (index.source !== './index.js') { throw 'source' }
-    if (index.location.local.join('/') !== '') { throw 'location' }
-    if (index.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(index) !== 'index.js') { throw 'moduleId' }
-    const a = mm.getModule(index.location)('./a')   
-    if (a === undefined) { throw 'no module' }
-    if (a.fileName !== 'index.js') { throw 'fileName' }
-    if (a.source !== './a/index.js') { throw 'source' }
-    if (a.location.local.join('/') !== 'a') { throw 'location' }
-    if (a.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(a) !== 'a/index.js') { throw 'moduleId' }
-    const abx = mm.getModule(a.location)('./b/x')
-    if (abx === undefined) { throw 'no module' }
-    if (abx.fileName !== 'x.js') { throw 'fileName' }
-    if (abx.source !== './a/b/x.js') { throw 'source' }
-    if (abx.location.local.join('/') !== 'a/b') { throw 'location' }
-    if (abx.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(abx) !== 'a/b/x.js') { throw 'moduleId' }
-    const ct = mm.getModule(abx.location)('../../c/t.js')
-    if (ct === undefined) { throw 'no module' }
-    if (ct.fileName !== 't.js') { throw 'fileName' }
-    if (ct.source !== './c/t.js') { throw 'source' }
-    if (ct.location.local.join('/') !== 'c') { throw 'location' }
-    if (ct.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.getModule(ct.location)('./d') !== undefined) { throw 'no module' }
-    if (mm.getModule(ct.location)('@functionalscript') !== undefined) { throw 'no module' }
-    if (mm.moduleId(ct) !== 'c/t.js') { throw 'moduleId' }
-    const fs = mm.getModule(ct.location)('@functionalscript/functionalscript')
-    if (fs === undefined) { throw 'no module' }    
-    if (fs.source !== '@functionalscript/functionalscript ./index.js') { throw 'source' }
-    if (fs.fileName !== 'index.js') { throw 'fileName' }
-    if (fs.location.local.join('/') !== '') { throw 'location' }
-    if (fs.location.pack.id.join('/') !== 'node_modules/@functionalscript/functionalscript') { throw 'pack.id' }
-    if (mm.getModule(fs.location)('my/src/x/') !== undefined) { throw 'no module '}
-    if (mm.moduleId(fs) !== 'node_modules/@functionalscript/functionalscript/index.js') { throw 'moduleId' }
-    const mySrcX = mm.getModule(fs.location)('my/src/x')
-    if (mySrcX === undefined) { throw 'no module' }
-    if (mySrcX.fileName !== 'x.js') { throw 'fileName' }
-    if (mySrcX.source !== 'my ./src/x.js') { throw 'source' }
-    if (mySrcX.location.local.join('/') !== 'src') { throw 'location' }
-    if (mySrcX.location.pack.id.join('/') !== 'node_modules/my') { throw 'pack.id' }
-    if (mm.moduleId(mySrcX) !== 'node_modules/my/src/x.js') { throw 'moduleId' }
-    const myB = mm.getModule(mySrcX.location)('../b/')
-    if (myB === undefined) { throw 'no module' }
-    if (myB.fileName !== 'index.js') { throw 'fileName' }
-    if (myB.source !== 'my ./b/index.js') { throw 'source' }
-    if (myB.location.local.join('/') !== 'b') { throw 'location' }
-    if (myB.location.pack.id.join('/') !== 'node_modules/my') { throw 'pack.id' }
-    if (mm.moduleId(myB) !== 'node_modules/my/b/index.js') { throw 'moduleId' }
-}

package/module-manager/test.js

@@ -1,120 +0,0 @@
-const i = require('.')
-
-require('./node/test')
-
-/** @type {<T>(_: T | undefined) => T} */
-const cast = x => {
-    if (x === undefined) { throw 'x' } 
-    return x
-}
-
-if (i.isRelative('a/b/c'.split('/'))) { throw 'error '}
-if (!i.isRelative('./a/b/c'.split('/'))) { throw 'error ' }
-if (cast(i.pathNorm('a/../b'.split('/'))).join('/') !== 'b') { throw 'error ' }
-if (cast(i.pathNorm('a/../b/../c'.split('/'))).join('/') !== 'c') { throw 'error ' }
-if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { throw 'error ' }
-
-{
-    /** @type {i.Package} */
-    const a = { 
-        dependencies: () => undefined,
-        file: path => {
-            /** @type {{ [_ in string]?: string}} */
-            const f = {
-                'index.js': 'a ./index.js',
-            }
-            return f[path]
-        },
-        id: ['a']
-    }
-    /** @type {i.Package} */
-    const c = { 
-        dependencies: () => undefined,
-        file: path => {
-            /** @type {{ readonly [_ in string]?: string}} */
-            const f = {
-                'index.js': 'b/c ./index.js',
-                'x/index.js': 'b/c ./x/index.js',
-            }
-            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
-            return f[path]
-        },
-        id: ['c']
-    }
-    /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
-    const packages = {
-        a,
-        b: s => {
-            /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
-            const p = { c }
-            return p[s]
-        }
-    }
-    /** @type {i.Package} */
-    const pack = {
-        dependencies: s => packages[s],
-        file: path => {
-            /** @type {{ readonly [_ in string]?: string}} */
-            const f = {
-                'index.js': './index.js',
-                'index/index.js': './index/index.js',
-                'a/index.js': './a/index.js',
-                'a/index.js.js': './a/index.js.js',
-            }
-            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
-            return  f[path] 
-        },
-        id: ['']
-    }
-    /** @type {(_: i.Module|undefined) => (_: i.Module) => void} */
-    const expect = a => b => {            
-        if (a === undefined) { throw 'undefined' }
-        if (a.location.local.join('/') !== b.location.local.join('/')) { throw 'local'}
-        if (a.location.pack !== b.location.pack) { throw 'pack' }
-        if (a.source !== b.source) { throw 'source' }
-    }
-    {        
-        const g = i.getModule({pack, local: []})
-        if (g('') !== undefined) { throw 'error' }
-        if (g('..') !== undefined) { throw 'error' }
-        expect(g('.'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index/'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('./a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('./a/index.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        if (g('./x') !== undefined) { throw 'error' }
-        expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        if (g('b') !== undefined) { throw 'error' }
-        expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/x'))({ fileName: 'index.js', location: { pack: c, local: ['x']}, source: 'b/c ./x/index.js'})
-        expect(g('b/c/r/..'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-    }
-    {
-        const g = i.getModule({pack, local: ['index']})
-        if (g('') !== undefined) { throw 'error' }
-        expect(g('..'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('.'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./index'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        if (g('./index/') !== undefined) { throw 'error' }
-        if (g('./a') !== undefined) { throw 'error' }
-        expect(g('../a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index.js'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index.js.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js.js'})
-        if (g('./x') !== undefined) { throw 'error' }
-        expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        if (g('b') !== undefined) { throw 'error' }
-        expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/x'))({ fileName: 'index.js', location: { pack: c, local: ['x']}, source: 'b/c ./x/index.js'})
-        expect(g('b/c/r/..'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-    }    
-}

package/result/index.js

@@ -1,17 +0,0 @@
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-
-module.exports = {}

package/sequence/asyncIterable/index.js

@@ -1,111 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/**
- * @template T 
- * @typedef {Promise<T>|T} PromiseOrValue 
- */
-
-/**
- * @template T
- * @typedef {Iterable<T> | AsyncIterable<T>} AsyncOrSyncIterable
- */
-
-/** @type {<T>(c: AsyncOrSyncIterable<AsyncOrSyncIterable<T>>) => AsyncIterable<T>} */
-const flat = c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* i
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => AsyncOrSyncIterable<R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* await f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncOrSyncIterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(a: AsyncOrSyncIterable<T>) => (b: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const concat = a => b => ({
-    async *[Symbol.asyncIterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const scan = s => c => ({
-    async *[Symbol.asyncIterator]() {
-        let next = s
-        for await (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(is: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
-const reduce = ([first, s]) => async c => {
-    let next = first
-    for await (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const sum = reduce(seq.sum)
-
-const join = compose(seq.join)(reduce)
-
-const length = reduce(seq.length)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const takeWhile = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-module.exports = {
-    /** @readonly */
-    concat,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    join,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    takeWhile,
-}

package/sequence/asyncIterable/test.js

@@ -1,24 +0,0 @@
-const { map, filter, flatMap, sum } = require('.')
-
-const test = async () => {
-    {
-        const a = [1, 2, 3]
-        const m = map(x => x * x)(a)
-        const result = await sum(m)
-        if (result !== 14) { throw 'filter' }
-    }
-    {
-        const a = [1, 2, 3, 4]
-        const f = filter(x => x !== 2)(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-    {
-        const a = [1, 2]
-        const f = flatMap(x => [x, x * x])(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-}
-
-test()

package/sequence/iterable/index.js

@@ -1,109 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
-const concat = a => b => ({
-    *[Symbol.iterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const scan = s => c => ({
-    *[Symbol.iterator]() {
-        let next = s
-        for (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => R} */
-const reduce = ([first, s]) => c => {
-    let next = first
-    for (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const entries = scan(seq.entries)
-
-const sum = reduce(seq.sum)
-
-const length = reduce(seq.length)
-
-const join = compose(seq.join)(reduce)
-
-/** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
-const flatMap = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            yield* f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(c: Iterable<Iterable<T>>) => Iterable<T>} */
-const flat = flatMap(x => x)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const takeWhile = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
-const find = f => c => {
-    for (const i of c) {
-        if (f(i)) {
-            return i
-        }
-    }
-    return undefined
-}
-
-module.exports = {
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    find,
-}

package/sequence/iterable/test.js

@@ -1,51 +0,0 @@
-const i = require('.')
-const { compose } = require('../../function')
-
-{
-    const r = i.sum([120, 300, 42])
-    if (r !== 462) { throw 'error' }
-}
-
-{
-    if (i.sum([1, 2]) !== 3) { throw 'error' }
-    if (i.sum([1, 2]) !== 3) { throw 'error' }
-}
-
-{
-    const x = Array.from(i.map(a => a ** 2)([1, 2, 3]))
-    if (x.length !== 3) { throw 'error' }
-    if (x[0] !== 1) { throw 'error' }
-    if (x[1] !== 4) { throw 'error' }
-    if (x[2] !== 9) { throw 'error' }
-}
-
-{
-    if (i.join('/')([]) !== '') { throw 'error' }
-    if (i.join('/')(['a']) !== 'a') { throw 'error' }
-    if (i.join('/')(['a', 'b']) !== 'a/b') { throw 'error'}
-}
-
-{
-    if (i.find(x => x === 'c')(['a', 'b', 'c']) !== 'c') { throw 'error' }
-}
-
-{
-    /** @type {(_: string) => string|undefined} */
-    const file = _ => 'x'
-    /** @type {(_: string) => string|undefined} */
-    const x = p => compose
-        (i.map(x => file(x())))
-        (i.find(x => x !== undefined))                
-        ([() => p, () => `${p}.js`, () => `${p}/index.js`])
-    if (x('index.js') !== 'x') { throw 'error' }
-}
-
-{
-    const x = JSON.stringify(Array.from(i.entries(['a', 'b', 'c'])))
-    if (x !== '[[0,"a"],[1,"b"],[2,"c"]]') { throw x }
-}
-
-{
-    const x = JSON.stringify(Array.from(i.entries([])))
-    if (x !== '[]') { throw x }
-}

package/sequence/operator/index.js

@@ -1,92 +0,0 @@
-const op = require('../../function/operator')
-
-/**
- * @template T0
- * @template T1
- * @typedef {import('../array').Tuple2<T0, T1>} Tuple2
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ScanResult
- */
-
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => ScanResult<T, R>} Scan
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ExclusiveScan
- */
-
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (prior: R) => Scan<T, R>} */
-const scan = operator => {
-    /** @typedef {typeof operator extends op.ReduceOperator<infer R, infer T> ? [R, T] : never} RT */
-    /** @typedef {RT[0]} R */
-    /** @typedef {RT[1]} T */
-    /** @type {(prior: R) => Scan<T, R>} */
-    const f = prior => value => {
-        const result = operator(prior)(value)
-        return [result, f(result)]
-    }
-    return f
-}
-
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (first: R) => ExclusiveScan<T, R>} */
-const exclusiveScan = operator => first => [first, scan(operator)(first)]
-
-/** 
- * @template T
- * @typedef {Tuple2<number, T>} Entry
- */
-
-/** @type {(index: number) => <T>(value: T) => ScanResult<T, Entry<T>>} */
-const createEntries = index => value => [[index, value], createEntries(index + 1)]
-
-const entries = createEntries(0)
-
-/** @type {(separator: string) => ExclusiveScan<string, string>} */
-const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
-
-const sum = exclusiveScan(op.addition)(0)
-
-/** @type {(a: number) => () => number} */
-const counter = a => () => a + 1
-
-const length = exclusiveScan(counter)(0)
-
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => R} Func
- */
-
-/** @type {<T, R, X>(flatMap: (f: Func<T, readonly[R]>) => X) => (f: Func<T, R>) =>X} */
-const map = flatMap => f => flatMap(x => [f(x)])
-
-/** @type {<T, X>(flatMap: (f: Func<T, readonly[T]|[]>) => X) => (f: Func<T, boolean>) =>X} */
-const filter = flatMap => f => flatMap(x => f(x) ? [x] : [])
-
-module.exports = {
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-}