update typescript to 3.1, cycle/run to 5.1

Author: staltz

package.json

@@ -18,26 +18,26 @@
   "typings": "lib/cjs/index.d.ts",
   "types": "lib/cjs/index.d.ts",
   "dependencies": {
-    "@cycle/run": "4.x.x",
-    "react": "16.4.x",
+    "@cycle/run": "5.x.x",
+    "react": "16.5.x",
     "xstream": "11.x.x"
   },
   "devDependencies": {
-    "@cycle/run": "^4.4.0",
-    "@cycle/isolate": "^3.3.0",
+    "@cycle/run": "^5.1.0",
+    "@cycle/isolate": "^4.1.0",
     "@types/mocha": "^2.2.40",
     "@types/node": "^10.5.2",
     "@types/react": "16.4.0",
     "mocha": "^5.2.0",
     "parcel": "^1.9.4",
     "parcel-bundler": "^1.9.6",
-    "react": "16.4.1",
-    "react-dom": "^16.4.1",
-    "react-test-renderer": "16.4.1",
+    "react": "16.5.2",
+    "react-dom": "16.5.2",
+    "react-test-renderer": "16.5.2",
     "symbol-observable": "^1.2.0",
     "ts-node": "^7.0.0",
-    "typescript": "^2.9.2",
-    "xstream": "^11.7.0"
+    "typescript": "3.1.3",
+    "xstream": "11.7.0"
   },
   "publishConfig": {
     "access": "public"

src/context.ts

@@ -1,4 +1,4 @@
 import {createContext, Context} from 'react';
 import {Scope} from './scope';
 
-export const ScopeContext = createContext<Scope>(new Scope());
+export const ScopeContext: Context<Scope> = createContext<Scope>(new Scope());

src/convert.ts

@@ -10,7 +10,13 @@ import {
 } from 'react';
 import {Stream, Subscription} from 'xstream';
 import {ScopeContext} from './context';
-import {Sources, FantasySinks, Drivers, setup} from '@cycle/run';
+import {
+  Sources,
+  Drivers,
+  MatchingDrivers,
+  MatchingMain,
+  setup,
+} from '@cycle/run';
 import {ReactSource} from './ReactSource';
 import {StreamRenderer} from './StreamRenderer';
 
@@ -92,12 +98,12 @@ export function makeCycleReactComponent<P = any>(
 }
 
 export function makeComponent<
-  So extends Sources,
-  Si extends FantasySinks<Si>,
+  D extends MatchingDrivers<D, M>,
+  M extends MatchingMain<D, M>,
   P = any
 >(
-  main: (sources: So) => Si,
-  drivers: Drivers<So, Si> = null as any,
+  main: MatchingMain<D, M>,
+  drivers: MatchingDrivers<D, M> = null as any,
   channel: string = 'react',
 ): ComponentType<P> {
   if (drivers) {

src/h.ts

@@ -1,62 +1,62 @@
-import {createElement} from 'react';
+import {createElement, ReactElement, ReactType} from 'react';
 import {incorporate} from './incorporate';
 
 export type PropsExtensions = {
   sel?: string | symbol;
 };
 
-function createElementSpreading<P>(
-  type: React.ReactType<P>,
+function createElementSpreading<P = any>(
+  type: ReactType<P>,
   props: P | null,
-  children: string | Array<React.ReactElement<any>>,
-): React.ReactElement<P> {
+  children: string | Array<ReactElement<any>>,
+): ReactElement<P> {
   if (typeof children === 'string') {
     return createElement(type, props, children);
   } else {
     return createElement(type, props, ...children);
   }
 }
 
-function hyperscriptProps<P>(
-  type: React.ReactType<P>,
+function hyperscriptProps<P = any>(
+  type: ReactType<P>,
   props: P & PropsExtensions,
-): React.ReactElement<P> {
+): ReactElement<P> {
   if (!props.sel) {
     return createElement(type, props);
   } else {
     return createElement(incorporate(type), props);
   }
 }
 
-function hyperscriptChildren<P>(
-  type: React.ReactType<P>,
-  children: string | Array<React.ReactElement<any>>,
-): React.ReactElement<P> {
+function hyperscriptChildren<P = any>(
+  type: ReactType<P>,
+  children: string | Array<ReactElement<any>>,
+): ReactElement<P> {
   return createElementSpreading(type, null, children);
 }
 
-function hyperscriptPropsChildren<P>(
-  type: React.ReactType<P>,
+function hyperscriptPropsChildren<P = any>(
+  type: ReactType<P>,
   props: P & PropsExtensions,
-  children: string | Array<React.ReactElement<any>>,
-): React.ReactElement<P> {
+  children: string | Array<ReactElement<any>>,
+): ReactElement<P> {
   if (!props.sel) {
     return createElementSpreading(type, props, children);
   } else {
     return createElementSpreading(incorporate(type), props, children);
   }
 }
 
-export function h<P>(
-  type: React.ReactType<P>,
-  a?: (P & PropsExtensions) | string | Array<React.ReactElement<any>>,
+export function h<P = any>(
+  type: ReactType<P>,
+  a?: (P & PropsExtensions) | string | Array<ReactElement<any>>,
   b?: string | Array<React.ReactElement<any>>,
-): React.ReactElement<P> {
+): ReactElement<P> {
   if (a === undefined && b === undefined) {
     return createElement(type, null);
   }
   if (b === undefined && (typeof a === 'string' || Array.isArray(a))) {
-    return hyperscriptChildren(type, a);
+    return hyperscriptChildren(type, a as string | Array<ReactElement<any>>);
   }
   if (b === undefined && typeof a === 'object' && !Array.isArray(a)) {
     return hyperscriptProps(type, a);

test/isolation.ts

@@ -1,5 +1,5 @@
 import 'mocha';
-import xs from 'xstream';
+import xs, {Stream} from 'xstream';
 import {createElement, PureComponent} from 'react';
 import isolate from '@cycle/isolate';
 import * as renderer from 'react-test-renderer';
@@ -135,12 +135,13 @@ describe('Isolation', function() {
     }
 
     function parent(sources: {react: ReactSource}) {
-      const firstSinks = isolate(firstborn, 'first')(sources);
-      const secondSinks = isolate(secondborn, 'second')(sources);
+      type Sinks = {react: Stream<React.ReactElement<any>>};
+      const firstSinks: Sinks = isolate(firstborn, 'first')(sources);
+      const secondSinks: Sinks = isolate(secondborn, 'second')(sources);
 
       const vdom$ = xs
         .combine(firstSinks.react, secondSinks.react)
-        .map(([firstChild, secondChild]: [any, any]) =>
+        .map(([firstChild, secondChild]) =>
           h('div', {sel: 'top-most'}, [firstChild, secondChild]),
         );