build: migrate to typescript

.gitignore

@@ -12,3 +12,4 @@ docs/_static
 docs/_templates
 lerna-debug.log
 npm-debug.log
+.rpt2_cache/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

packages/core/package.json

@@ -2,7 +2,7 @@
   "name": "@most/core",
   "version": "1.5.0",
   "description": "Reactive programming with lean, functions-only, curried, tree-shakeable API",
-  "typings": "type-definitions/most.d.ts",
+  "typings": "dist/most.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.es.js",
   "files": [
@@ -11,8 +11,8 @@
   ],
   "scripts": {
     "test": "npm run test:lint && npm run test:unit && npm run test:flow",
-    "test:unit": "cross-env NODE_ENV=test nyc --reporter=text-summary mocha -r babel-register --reporter dot --recursive 'test/**/*-test.js'",
-    "test:lint": "standard --fix 'src/**/*.js' 'test/**/*.js' --verbose | snazzy",
+    "test:unit": "cross-env NODE_ENV=test nyc mocha",
+    "test:lint": "standard --fix 'src/**/*.ts' 'test/**/*.ts' --verbose | snazzy",
     "test:flow": "flow check",
     "build": "npm run build:dist && npm run build:flow",
     "build:dist": "rollup -c",
@@ -39,22 +39,23 @@
   "license": "MIT",
   "devDependencies": {
     "@briancavalier/assert": "^3.2.0",
-    "babel-core": "^6.26.3",
-    "babel-plugin-annotate-pure-calls": "^0.2.0",
-    "babel-plugin-external-helpers": "^6.22.0",
-    "babel-preset-env": "^1.7.0",
-    "babel-register": "^6.26.0",
+    "@istanbuljs/nyc-config-typescript": "^0.1.3",
+    "@types/mocha": "^5.2.7",
+    "@typescript-eslint/eslint-plugin": "^1.11.0",
+    "@typescript-eslint/parser": "^1.11.0",
     "cpy-cli": "^2.0.0",
     "cross-env": "^5.2.0",
     "flow-bin": "^0.101.0",
-    "mocha": "^5.2.0",
+    "mocha": "^6.1.4",
     "nyc": "^14.1.1",
-    "rollup": "^0.50.0",
-    "rollup-plugin-babel": "^3.0.2",
-    "rollup-plugin-local-resolve": "^1.0.7",
+    "rollup": "^1.6.0",
+    "rollup-plugin-local-resolve": "~1.0.7",
+    "rollup-plugin-typescript2": "^0.21.2",
     "sinon": "^1.17.7",
     "snazzy": "^8.0.0",
-    "standard": "^12.0.1"
+    "standard": "^12.0.1",
+    "ts-node": "^8.3.0",
+    "typescript": "^3.5.2"
   },
   "dependencies": {
     "@most/disposable": "^1.2.2",
@@ -66,6 +67,21 @@
     "ignore": [
       "test/perf",
       "test/flow"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint/eslint-plugin"
+    ]
+  },
+  "nyc": {
+    "extends": "@istanbuljs/nyc-config-typescript",
+    "all": true,
+    "reporter": [
+      "text-summary"
+    ],
+    "exclude": [
+      "dist/**",
+      "coverage/**"
     ]
   }
 }

packages/core/rollup.config.js

@@ -1,14 +1,14 @@
-import babel from 'rollup-plugin-babel'
+import typescript from 'rollup-plugin-typescript2'
 import localResolve from 'rollup-plugin-local-resolve'
 import pkg from './package.json'
 
 export default {
-  input: 'src/index.js',
+  input: 'src/index.ts',
   plugins: [
     localResolve(),
-    babel({
-      exclude: 'node_modules/**',
-      plugins: ['external-helpers']
+    typescript({
+      tsconfig: './src/tsconfig.json',
+      typescript: require('typescript'),
     })
   ],
   external: [

packages/core/src/Queue.js → packages/core/src/Queue.ts

@@ -14,15 +14,20 @@ const HEAD_MAX_SHRINK = 2
 // its internal array
 const TAIL_MIN_SHRINK = 10000
 
-export default class Queue {
+export default class Queue<A> {
+  private _head: number;
+  private _tail: number;
+  private _capacityMask: number;
+  private _list: Array<A | undefined>;
+
   constructor () {
     this._head = 0
     this._tail = 0
     this._capacityMask = 0x3
     this._list = new Array(4)
   }
 
-  push (x) {
+  push (x: A): number {
     const tail = this._tail
     this._list[tail] = x
     this._tail = (tail + 1) & this._capacityMask
@@ -37,7 +42,7 @@ export default class Queue {
     }
   }
 
-  shift () {
+  shift (): A | undefined {
     const head = this._head
     if (head === this._tail) {
       return undefined
@@ -55,11 +60,11 @@ export default class Queue {
     return x
   }
 
-  isEmpty () {
+  isEmpty (): boolean {
     return this._head === this._tail
   }
 
-  length () {
+  length (): number {
     if (this._head === this._tail) {
       return 0
     } else if (this._head < this._tail) {
@@ -69,7 +74,7 @@ export default class Queue {
     }
   }
 
-  _growArray () {
+  _growArray (): void {
     if (this._head) {
       // copy existing data, head to end, then beginning to tail.
       this._list = this._copyArray()
@@ -83,12 +88,12 @@ export default class Queue {
     this._capacityMask = (this._capacityMask << 1) | 1
   }
 
-  _shrinkArray () {
+  _shrinkArray (): void {
     this._list.length >>>= 1
     this._capacityMask >>>= 1
   }
 
-  _copyArray () {
+  _copyArray (): Array<A | undefined> {
     const newArray = []
     const list = this._list
     const len = list.length
@@ -104,3 +109,8 @@ export default class Queue {
     return newArray
   }
 }
+
+export interface NonEmptyQueue<A> extends Queue<A> {
+  isEmpty(): false
+  shift(): A
+}

packages/core/src/combinator/applicative.js → packages/core/src/combinator/applicative.ts

@@ -4,6 +4,7 @@
 
 import { combine } from './combine'
 import { apply } from '@most/prelude'
+import { Stream } from '@most/types' // eslint-disable-line no-unused-vars
 
 /**
  * Assume fs is a stream containing functions, and apply the latest function
@@ -15,6 +16,6 @@ import { apply } from '@most/prelude'
  * @param {Stream} xs stream of values to which to apply all the latest f
  * @returns {Stream} stream containing all the applications of fs to xs
  */
-export function ap (fs, xs) {
+export function ap <A, B> (fs: Stream<(a: A) => B>, xs: Stream<A>): Stream<B> {
   return combine(apply, fs, xs)
 }

packages/core/src/combinator/chain.ts

@@ -0,0 +1,23 @@
+/** @license MIT License (c) copyright 2010-2016 original author or authors */
+/** @author Brian Cavalier */
+/** @author John Hann */
+
+import { mergeConcurrently, mergeMapConcurrently } from './mergeConcurrently'
+import { Stream } from '@most/types' // eslint-disable-line no-unused-vars
+
+/**
+ * Map each value in the stream to a new stream, and merge it into the
+ * returned outer stream. Event arrival times are preserved.
+ * @param f chaining function, must return a Stream
+ * @param stream
+ * @returns new stream containing all events from each stream returned by f
+ */
+export const chain = <A, B>(f: (value: A) => Stream<B>, stream: Stream<A>): Stream<B> => mergeMapConcurrently(f, Infinity, stream)
+
+/**
+ * Monadic join. Flatten a Stream<Stream<X>> to Stream<X> by merging inner
+ * streams to the outer. Event arrival times are preserved.
+ * @param stream stream of streams
+ * @returns new stream containing all events of all inner streams
+ */
+export const join = <A>(stream: Stream<Stream<A>>): Stream<A> => mergeConcurrently(Infinity, stream)

packages/core/src/combinator/combine.js → packages/core/src/combinator/combine.ts

@@ -3,43 +3,48 @@
 import { map } from './transform'
 import { empty, containsCanonicalEmpty } from '../source/empty'
 import Pipe from '../sink/Pipe'
-import IndexSink from '../sink/IndexSink'
+import IndexSink, { IndexedValue } from '../sink/IndexSink' // eslint-disable-line no-unused-vars
 import { disposeAll, tryDispose } from '@most/disposable'
 import invoke from '../invoke'
+import { Stream, Sink, Scheduler, Disposable, Time } from '@most/types' // eslint-disable-line no-unused-vars
+import { ToStreamsArray } from './variadic' // eslint-disable-line no-unused-vars
 
 /**
  * Combine latest events from two streams
- * @param {function(...events):*} f function to combine most recent events
- * @returns {Stream} stream containing the result of applying f to the most recent
+ * @param f function to combine most recent events
+ * @returns stream containing the result of applying f to the most recent
  *  event of each input stream, whenever a new event arrives on any stream.
  */
-export const combine = (f, stream1, stream2) =>
+export const combine = <A, B, C>(f: (a: A, b: B) => C, stream1: Stream<A>, stream2: Stream<B>): Stream<C> =>
   combineArray(f, [stream1, stream2])
 
 /**
 * Combine latest events from all input streams
-* @param {function(...events):*} f function to combine most recent events
-* @param {[Stream]} streams most recent events
-* @returns {Stream} stream containing the result of applying f to the most recent
+* @param f function to combine most recent events
+* @param streams most recent events
+* @returns stream containing the result of applying f to the most recent
 *  event of each input stream, whenever a new event arrives on any stream.
 */
-export const combineArray = (f, streams) =>
+export const combineArray = <Args extends any[], R>(f: (...args: Args) => R, streams: ToStreamsArray<Args>): Stream<R> =>
   streams.length === 0 || containsCanonicalEmpty(streams) ? empty()
-    : streams.length === 1 ? map(f, streams[0])
-      : new Combine(f, streams)
+    : streams.length === 1 ? map(f as any, streams[0])
+      : new Combine(f as any, streams)
 
-class Combine {
-  constructor (f, sources) {
+class Combine<A, B> {
+  private readonly f: (...args: A[]) => B
+  private readonly sources: Stream<A>[];
+
+  constructor (f: (...args: A[]) => B, sources: Stream<A>[]) {
     this.f = f
     this.sources = sources
   }
 
-  run (sink, scheduler) {
+  run (sink: Sink<B>, scheduler: Scheduler) {
     const l = this.sources.length
     const disposables = new Array(l)
     const sinks = new Array(l)
 
-    const mergeSink = new CombineSink(disposables, sinks, sink, this.f)
+    const mergeSink = new CombineSink(disposables, sinks.length, sink, this.f)
 
     for (let indexSink, i = 0; i < l; ++i) {
       indexSink = sinks[i] = new IndexSink(i, mergeSink)
@@ -50,21 +55,27 @@ class Combine {
   }
 }
 
-class CombineSink extends Pipe {
-  constructor (disposables, sinks, sink, f) {
+class CombineSink<A, B> extends Pipe<B | IndexedValue<A>> {
+  private readonly disposables: Disposable[]
+  private readonly f: (...args: A[]) => B
+  private awaiting: number
+  private hasValue: boolean[]
+  private activeCount: number
+  private readonly values: A[]
+
+  constructor (disposables: Disposable[], length: number, sink: Sink<B>, f: (...args: A[]) => B) {
     super(sink)
     this.disposables = disposables
-    this.sinks = sinks
     this.f = f
 
-    const l = sinks.length
+    const l = length
     this.awaiting = l
     this.values = new Array(l)
     this.hasValue = new Array(l).fill(false)
-    this.activeCount = sinks.length
+    this.activeCount = length
   }
 
-  event (t, indexedValue) {
+  event (t: Time, indexedValue: IndexedValue<A>) {
     if (!indexedValue.active) {
       this._dispose(t, indexedValue.index)
       return
@@ -79,7 +90,7 @@ class CombineSink extends Pipe {
     }
   }
 
-  _updateReady (index) {
+  _updateReady (index: number) {
     if (this.awaiting > 0) {
       if (!this.hasValue[index]) {
         this.hasValue[index] = true
@@ -89,7 +100,7 @@ class CombineSink extends Pipe {
     return this.awaiting
   }
 
-  _dispose (t, index) {
+  _dispose (t: Time, index: number) {
     tryDispose(t, this.disposables[index], this.sink)
     if (--this.activeCount === 0) {
       this.sink.end(t)