├── .eslintignore ├── .eslintrc.js ├── .flowconfig ├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── LICENSE ├── README.MD ├── babel.config.js ├── dts ├── immer.d.ts ├── index.d.ts ├── test │ ├── actions.ts │ ├── reducers-classic.ts │ ├── reducers-immer.ts │ └── types.ts └── types.d.ts ├── flow-typed └── npm │ ├── redux-actions_v2.x.x.js │ ├── redux_v3.x.x.js │ └── rxjs_v5.0.x.js ├── package-lock.json ├── package.json ├── src ├── actions │ └── index.js ├── immer.js ├── index.js ├── redux-observable │ └── index.js ├── tests │ ├── actions.js │ ├── actions.test.js │ ├── epics.js │ ├── reducers.immer.js │ ├── reducers.js │ └── types.js ├── types │ ├── deprecated.js │ └── index.js └── weak.js └── tsconfig.json /.eslintignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | lib 3 | flow-typed 4 | -------------------------------------------------------------------------------- /.eslintrc.js: -------------------------------------------------------------------------------- 1 | 'use strict' 2 | 3 | module.exports = { 4 | extends: [ 5 | 'airbnb-base', 6 | 'plugin:flowtype/recommended', 7 | ], 8 | 9 | rules: { 10 | 'no-unused-expressions': 'off', 11 | 'no-multi-assign': 'off', 12 | semi: ['error', 'never'], 13 | 14 | 'import/no-extraneous-dependencies': ['error', {optionalDependencies: true}], 15 | 'import/prefer-default-export': 'off', 16 | 17 | 'flowtype/no-unused-expressions': 'error', 18 | 'flowtype/generic-spacing': 'off', 19 | 'flowtype/space-before-type-colon': 'off', 20 | 'operator-linebreak': 'off', 21 | }, 22 | 23 | plugins: ['flowtype'], 24 | } 25 | -------------------------------------------------------------------------------- /.flowconfig: -------------------------------------------------------------------------------- 1 | [version] 2 | >=0.65.0 3 | 4 | [lints] 5 | all=warn 6 | unclear-type=off 7 | untyped-import=off 8 | sketchy-null-mixed=off 9 | deprecated-type=off 10 | 11 | [options] 12 | suppress_comment=\\(.\\|\n\\)*\\$ExpectError 13 | include_warnings=true 14 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | lib 3 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | dist: trusty 2 | language: node_js 3 | node_js: 4 | - 8 5 | 6 | cache: yarn 7 | 8 | script: 9 | - yarn --version 10 | - yarn run lint 11 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | ## [v0.10.0](https://github.com/lttb/typed-actions/tree/v0.10.0) (2018-10-23) 4 | 5 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.9.2-0...v0.10.0) 6 | 7 | **Merged pull requests:** 8 | 9 | - Add types ActionOf and ActionsOf [\#12](https://github.com/lttb/typed-actions/pull/12) ([lttb](https://github.com/lttb)) 10 | - Fix functions polymorphism order [\#11](https://github.com/lttb/typed-actions/pull/11) ([lttb](https://github.com/lttb)) 11 | 12 | ## [v0.9.2-0](https://github.com/lttb/typed-actions/tree/v0.9.2-0) (2018-10-14) 13 | 14 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.9.1...v0.9.2-0) 15 | 16 | ## [v0.9.1](https://github.com/lttb/typed-actions/tree/v0.9.1) (2018-07-30) 17 | 18 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.9.0...v0.9.1) 19 | 20 | ## [v0.9.0](https://github.com/lttb/typed-actions/tree/v0.9.0) (2018-07-30) 21 | 22 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.8.0...v0.9.0) 23 | 24 | **Merged pull requests:** 25 | 26 | - Add error action creator [\#10](https://github.com/lttb/typed-actions/pull/10) ([orlov-vo](https://github.com/orlov-vo)) 27 | - Minor fixes [\#9](https://github.com/lttb/typed-actions/pull/9) ([lttb](https://github.com/lttb)) 28 | 29 | ## [v0.8.0](https://github.com/lttb/typed-actions/tree/v0.8.0) (2018-04-17) 30 | 31 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.7.1...v0.8.0) 32 | 33 | **Closed issues:** 34 | 35 | - How to extract flow type of an action from an action creator? [\#7](https://github.com/lttb/typed-actions/issues/7) 36 | 37 | **Merged pull requests:** 38 | 39 | - Add weak handleActions type [\#8](https://github.com/lttb/typed-actions/pull/8) ([lttb](https://github.com/lttb)) 40 | 41 | ## [v0.7.1](https://github.com/lttb/typed-actions/tree/v0.7.1) (2018-03-31) 42 | 43 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.7.0...v0.7.1) 44 | 45 | ## [v0.7.0](https://github.com/lttb/typed-actions/tree/v0.7.0) (2018-03-31) 46 | 47 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.7.0-2...v0.7.0) 48 | 49 | **Merged pull requests:** 50 | 51 | - Immer && action creators arity [\#6](https://github.com/lttb/typed-actions/pull/6) ([lttb](https://github.com/lttb)) 52 | 53 | ## [v0.7.0-2](https://github.com/lttb/typed-actions/tree/v0.7.0-2) (2018-03-31) 54 | 55 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.7.0-1...v0.7.0-2) 56 | 57 | ## [v0.7.0-1](https://github.com/lttb/typed-actions/tree/v0.7.0-1) (2018-03-30) 58 | 59 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.7.0-0...v0.7.0-1) 60 | 61 | ## [v0.7.0-0](https://github.com/lttb/typed-actions/tree/v0.7.0-0) (2018-03-30) 62 | 63 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.6.0...v0.7.0-0) 64 | 65 | ## [v0.6.0](https://github.com/lttb/typed-actions/tree/v0.6.0) (2018-03-29) 66 | 67 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.6.0-2...v0.6.0) 68 | 69 | **Merged pull requests:** 70 | 71 | - Imporove typings for action creators [\#5](https://github.com/lttb/typed-actions/pull/5) ([lttb](https://github.com/lttb)) 72 | 73 | ## [v0.6.0-2](https://github.com/lttb/typed-actions/tree/v0.6.0-2) (2018-03-29) 74 | 75 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.6.0-1...v0.6.0-2) 76 | 77 | ## [v0.6.0-1](https://github.com/lttb/typed-actions/tree/v0.6.0-1) (2018-03-29) 78 | 79 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.6.0-0...v0.6.0-1) 80 | 81 | ## [v0.6.0-0](https://github.com/lttb/typed-actions/tree/v0.6.0-0) (2018-03-29) 82 | 83 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.5.1...v0.6.0-0) 84 | 85 | **Merged pull requests:** 86 | 87 | - Fix package.json [\#4](https://github.com/lttb/typed-actions/pull/4) ([lttb](https://github.com/lttb)) 88 | 89 | ## [v0.5.1](https://github.com/lttb/typed-actions/tree/v0.5.1) (2018-03-14) 90 | 91 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.5.0...v0.5.1) 92 | 93 | ## [v0.5.0](https://github.com/lttb/typed-actions/tree/v0.5.0) (2018-03-14) 94 | 95 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.4.3...v0.5.0) 96 | 97 | **Closed issues:** 98 | 99 | - createAction doesn't support Symbol type [\#2](https://github.com/lttb/typed-actions/issues/2) 100 | 101 | **Merged pull requests:** 102 | 103 | - Fix epic type [\#3](https://github.com/lttb/typed-actions/pull/3) ([lttb](https://github.com/lttb)) 104 | 105 | ## [v0.4.3](https://github.com/lttb/typed-actions/tree/v0.4.3) (2018-03-02) 106 | 107 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.4.2...v0.4.3) 108 | 109 | ## [v0.4.2](https://github.com/lttb/typed-actions/tree/v0.4.2) (2018-03-01) 110 | 111 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.4.1...v0.4.2) 112 | 113 | ## [v0.4.1](https://github.com/lttb/typed-actions/tree/v0.4.1) (2018-03-01) 114 | 115 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.4.0...v0.4.1) 116 | 117 | ## [v0.4.0](https://github.com/lttb/typed-actions/tree/v0.4.0) (2018-03-01) 118 | 119 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.5...v0.4.0) 120 | 121 | ## [v0.3.5](https://github.com/lttb/typed-actions/tree/v0.3.5) (2018-02-26) 122 | 123 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.4...v0.3.5) 124 | 125 | ## [v0.3.4](https://github.com/lttb/typed-actions/tree/v0.3.4) (2018-02-26) 126 | 127 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.3...v0.3.4) 128 | 129 | ## [v0.3.3](https://github.com/lttb/typed-actions/tree/v0.3.3) (2018-02-26) 130 | 131 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.2...v0.3.3) 132 | 133 | ## [v0.3.2](https://github.com/lttb/typed-actions/tree/v0.3.2) (2018-02-23) 134 | 135 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.1...v0.3.2) 136 | 137 | ## [v0.3.1](https://github.com/lttb/typed-actions/tree/v0.3.1) (2018-02-23) 138 | 139 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.3.0...v0.3.1) 140 | 141 | ## [v0.3.0](https://github.com/lttb/typed-actions/tree/v0.3.0) (2018-02-23) 142 | 143 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.2.0...v0.3.0) 144 | 145 | ## [v0.2.0](https://github.com/lttb/typed-actions/tree/v0.2.0) (2018-02-22) 146 | 147 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.1.1...v0.2.0) 148 | 149 | ## [v0.1.1](https://github.com/lttb/typed-actions/tree/v0.1.1) (2018-02-21) 150 | 151 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.1.0...v0.1.1) 152 | 153 | ## [v0.1.0](https://github.com/lttb/typed-actions/tree/v0.1.0) (2018-02-20) 154 | 155 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.0.2...v0.1.0) 156 | 157 | **Merged pull requests:** 158 | 159 | - Improve deep immutable Frozen Type [\#1](https://github.com/lttb/typed-actions/pull/1) ([lttb](https://github.com/lttb)) 160 | 161 | ## [v0.0.2](https://github.com/lttb/typed-actions/tree/v0.0.2) (2018-02-16) 162 | 163 | [Full Changelog](https://github.com/lttb/typed-actions/compare/v0.0.1...v0.0.2) 164 | 165 | ## [v0.0.1](https://github.com/lttb/typed-actions/tree/v0.0.1) (2018-02-16) 166 | 167 | [Full Changelog](https://github.com/lttb/typed-actions/compare/bf3dfebaaf8480a0f24d4db07af3ad4c50dadae0...v0.0.1) 168 | 169 | 170 | 171 | \* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)* -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Artur Kenzhaev 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.MD: -------------------------------------------------------------------------------- 1 | # typed-actions 2 | 3 | [![Travis branch](https://img.shields.io/travis/lttb/typed-actions/master.svg?style=flat)](https://travis-ci.org/lttb/typed-actions) 4 | [![npm version](https://img.shields.io/npm/v/typed-actions.svg?style=flat)](https://www.npmjs.com/package/typed-actions) 5 | [![npm license](https://img.shields.io/npm/l/typed-actions.svg?style=flat)](https://www.npmjs.com/package/typed-actions) 6 | 7 | 8 | Some Types and Utils (based on [redux-actions](https://github.com/reduxactions/redux-actions) way) to create type-safe actions, reducers, and epics with auto-inferred types. 9 | 10 | **Main points**: 11 | - 100% Flow coverage for the redux-side with minimum typings (auto-inferred types) and less boilerplate 12 | - Safe types and functions, which help to reduce risks for Type mistakes 13 | - Accurate Type-errors handling 14 | - Deep immutable Type (`Frozen`) for actions and redux state 15 | - [Immer](https://github.com/mweststrate/immer) support 16 | 17 | ## Installation 18 | 19 | ```sh 20 | npm install typed-actions 21 | ``` 22 | 23 | ## Usage 24 | 25 | > You can get some examples [here](https://github.com/lttb/typed-actions/tree/master/src/tests) with explanations. 26 | 27 | - [Actions](#actions) 28 | - [Reducers](#reducers) 29 | - [Immer](#immer) 30 | - [Epics](#epics) 31 | 32 | ### Actions 33 | Actions are compatible with [Flux Standard Action](https://github.com/redux-utilities/flux-standard-action) 34 | 35 | - `action(payload, ?meta)` produces `{type, payload} | {type, payload, meta}` 36 | - `error(payload, ?meta)` produces `{type, payload, error: true} | {type, payload, meta, error: true}` 37 | - `empty()` produces `{type}` 38 | 39 | 40 | ```js 41 | import {createActions, action, empty} from 'typed-actions' 42 | import type {EntityId} from '../types'; 43 | 44 | /** 45 | * Declare Action Types as constants and export them 46 | */ 47 | export const UPDATE = '@namespace/UPDATE' 48 | export const UPDATE_FULFILLED = '@namespace/UPDATE_FULFILLED' 49 | export const UPDATE_FAILED = '@namespace/UPDATE_FAILED' 50 | 51 | /** 52 | * Create Actions Collection 53 | */ 54 | const actions = createActions({ 55 | /** 56 | * {type: UPDATE} 57 | */ 58 | [UPDATE]: empty, 59 | /** 60 | * {type: UPDATE_FULFILLED, payload: EntityId[]} 61 | */ 62 | [UPDATE_FULFILLED]: (x: EntityId[]) => action(x), 63 | /** 64 | * {type: UPDATE_FAILED, payload: EntityId, meta: {sync: true}} 65 | */ 66 | [UPDATE_FAILED]: (x: EntityId) => action(x, {sync: true}), 67 | }) 68 | 69 | /** 70 | * Export Action Creators 71 | */ 72 | export const { 73 | [UPDATE]: update, 74 | [UPDATE_FULFILLED]: updateFulfilled, 75 | [UPDATE_FAILED]: updateFailed, 76 | } = actions 77 | 78 | /** 79 | * Export Collection Type 80 | */ 81 | export type Actions = typeof actions 82 | ``` 83 | 84 | You might find this declaration style more readable: 85 | 86 | ```js 87 | let actions 88 | 89 | export const { 90 | [UPDATE]: update, 91 | [UPDATE_FULFILLED]: updateFulfilled, 92 | [UPDATE_FAILED]: updateFailed, 93 | } = actions = createActions({ 94 | [UPDATE]: empty, 95 | [UPDATE_FULFILLED]: (x: EntityId[]) => action(x) 96 | [UPDATE_FAILED]: (x: EntityId) => action(x, {sync: true}), 97 | }) 98 | 99 | export type Actions = typeof actions 100 | ``` 101 | 102 | ### Reducers 103 | 104 | ```js 105 | import {handleActions, type Handlers, type Frozen} from 'typed-actions'; 106 | import type {EntityId} from '../types'; 107 | 108 | /** 109 | * Import action types with Actions Collection Type 110 | */ 111 | import { 112 | type Actions, 113 | UPDATE, 114 | UPDATE_FULFILLED, 115 | UPDATE_FAILED, 116 | } from './actions'; 117 | 118 | /** 119 | * Declare State for the reducer 120 | */ 121 | export type State = { 122 | data: EntityId[], 123 | status: 'done' | 'pending' | 'failed', 124 | }; 125 | 126 | /** 127 | * Use Handlers Type for the type-casting. 128 | * This way functions will get right arguments Types 129 | */ 130 | export default handleActions(({ 131 | /** 132 | * No need to point the State Type in arguments, 133 | * it would be auto-inferred Deep Immutable Type of State 134 | */ 135 | [UPDATE]: state => ({ 136 | ...state, 137 | status: 'pending', 138 | }), 139 | 140 | /** 141 | * The second argument (action) will also have the right type 142 | * {type: UPDATE_FULFILLED, payload: EntityId[]} 143 | */ 144 | [UPDATE_FULFILLED]: (state, {payload}) => ({ 145 | ...state, 146 | data: payload, 147 | status: 'done', 148 | }), 149 | 150 | [UPDATE_FAILED]: state => ({ 151 | ...state, 152 | status: 'failed', 153 | }), 154 | }: Handlers)); 155 | ``` 156 | 157 | #### Immer 158 | 159 | You can use [immer](https://github.com/mweststrate/immer) for immutable state modifying. 160 | 161 | > Note that `handler` accepts 3 arguments: `draft state` (for changes), `action` and `current state`. 162 | 163 | ```js 164 | import { type Handlers, handleActions } from 'typed-actions/immer' 165 | import type {EntityId} from '../types'; 166 | 167 | import { 168 | type Actions, 169 | UPDATE, 170 | UPDATE_FULFILLED, 171 | UPDATE_FAILED, 172 | } from './actions'; 173 | 174 | export type State = { 175 | data: EntityId[], 176 | status: 'done' | 'pending' | 'failed', 177 | }; 178 | 179 | export default handleActions(({ 180 | [UPDATE]: state => { 181 | state.status = 'pending' 182 | }, 183 | 184 | [UPDATE_FULFILLED]: (state, {payload}) => { 185 | state.data = payload 186 | state.status = 'done' 187 | }, 188 | 189 | [UPDATE_FAILED]: state => { 190 | state.status = 'failed' 191 | }, 192 | }: Handlers)); 193 | ``` 194 | 195 | ### Epics 196 | 197 | If you're using [redux-observable](https://github.com/redux-observable/redux-observable), this Epic Type could be useful. 198 | 199 | ```js 200 | import type {Epic} from 'typed-actions/redux-observable'; 201 | 202 | import { 203 | type Actions, 204 | UPDATE_FULFILLED, 205 | anotherOneAction, 206 | } from './actions'; 207 | 208 | import {type State} from './reducers'; 209 | 210 | export const updateEpic: Epic = action$ => action$ 211 | .ofType(UPDATE_FULFILLED) 212 | /** 213 | * No need to add types here, action would be the right Type out of the box 214 | */ 215 | .map(action => anotherOneAction(action.payload)); 216 | 217 | export const unionEpic: Epic = action$ => action$ 218 | .ofType(UPDATE, UPDATE_FULFILLED) 219 | /** 220 | * {type: UPDATE} | {type: UPDATE_FULFILLED, payload: EntityId[]} 221 | */ 222 | .map(action => { 223 | if (action.type === UPDATE_FULFILLED) { 224 | /** 225 | * Type Refinement will work as well 226 | * 227 | * {type: UPDATE_FULFILLED, payload: EntityId[]} 228 | */ 229 | console.log(action.payload) 230 | } 231 | }); 232 | ``` 233 | 234 | Just to note, if you're using `dependencies` in epics, you can pass its type in as the third argument. 235 | 236 | ```js 237 | type Dependencies = {api: () => void} 238 | 239 | export const epic: Epic = action$ => action$ 240 | ``` 241 | 242 | The recommended way is to redeclare your own `Epic` type with custom dependencies and use it, like: 243 | 244 | ```js 245 | // types.js 246 | import type {Epic} from 'typed-actions/redux-observable' 247 | 248 | type Dependencies = {api: () => void} 249 | 250 | export type Epic = Epic 251 | 252 | // epics.js 253 | import type {Epic} from './types' 254 | 255 | export const epic: Epic = action$ => action$ 256 | ``` 257 | -------------------------------------------------------------------------------- /babel.config.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | passPerPreset: true, 3 | presets: [ 4 | '@babel/preset-flow', 5 | ['@babel/preset-env', { targets: { node: '12' } }], 6 | ], 7 | plugins: [ 8 | ['@babel/plugin-transform-runtime', { regenerator: false }], 9 | ], 10 | } 11 | -------------------------------------------------------------------------------- /dts/immer.d.ts: -------------------------------------------------------------------------------- 1 | import type {Reducer} from 'redux-actions'; 2 | 3 | // utils 4 | type AbstractActions = Record any>; 5 | type $Exact = T & {[key in string]?: T[keyof T] | never}; 6 | export type ExtractActionsFromHandlers> = { 7 | [K in keyof H]: Required[K] extends (...args: [any, infer Action, ...any[]]) => any ? Action : never; 8 | }[keyof H]; 9 | export type ExtractStateFromHandlers> = { 10 | [K in keyof H]: Required[K] extends (...args: [infer State, ...any[]]) => any ? State : never; 11 | }[keyof H]; 12 | 13 | export type Handlers = { 14 | [K in keyof A]?: (state: S, action: ReturnType) => void; 15 | } 16 | 17 | export declare function handleActions>(arg: T, state?: ExtractStateFromHandlers): Reducer, ExtractActionsFromHandlers> 18 | -------------------------------------------------------------------------------- /dts/index.d.ts: -------------------------------------------------------------------------------- 1 | import type {Reducer} from 'redux-actions'; 2 | 3 | export * from './types'; 4 | 5 | // utils 6 | type AbstractActions = Record any>; 7 | type $Exact = T & {[key in string]?: T[keyof T] | never}; 8 | export type ExtractActionsFromHandlers> = { 9 | [K in keyof H]: Required[K] extends (...args: [any, infer Action, ...any[]]) => any ? Action : never; 10 | }[keyof H]; 11 | export type ExtractStateFromHandlers> = { 12 | [K in keyof H]: Required[K] extends (...args: [infer State, ...any[]]) => any ? State : never; 13 | }[keyof H]; 14 | 15 | declare function action(): {type: string}; 16 | declare function action(arg: T): {type: string; payload: T}; 17 | declare function action(arg: T, meta: M): {type: string; payload: T; meta: M}; 18 | declare function action(arg?: any, meta?: any): {type: string; payload?: any; meta?: any}; 19 | 20 | declare function error(arg: T): {type: string; payload: T, error: true}; 21 | declare function error(arg: T, meta: M): {type: string; payload: T; meta: M, error: true}; 22 | declare function error(arg?: any, meta?: any): {type: string, payload?: any, meta?: any, error: true}; 23 | 24 | declare function empty(): {type: string}; 25 | 26 | declare function createActions( 27 | arg: T, 28 | ): { 29 | [K in keyof T]: ReturnType extends {error: true} 30 | ? Parameters extends [infer P, infer M] 31 | ? (arg: P, meta: M) => {type: K, payload: P, meta: M, error: true} 32 | : Parameters extends [infer P] 33 | ? (arg: P) => {type: K, payload: P, error: true} 34 | : () => {type: K, payload: undefined, error: true} 35 | : Parameters extends [infer P, infer M] 36 | ? (arg: P, meta: M) => {type: K; payload: P; meta: M} 37 | : Parameters extends [infer P] 38 | ? (arg: P) => {type: K; payload: P} 39 | : () => {type: K}; 40 | }; 41 | 42 | export type Handlers = { 43 | [K in keyof A]?: (state: S, action: ReturnType) => $Exact 44 | }; 45 | 46 | declare function handleActions>(arg: T, state?: ExtractStateFromHandlers): Reducer, ExtractActionsFromHandlers> 47 | 48 | export {action, error, empty, createActions, handleActions} 49 | -------------------------------------------------------------------------------- /dts/test/actions.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable flowtype/no-types-missing-file-annotation */ 2 | /* eslint-disable import/no-unresolved */ 3 | import { 4 | action, empty, error, createActions, 5 | } from '../index' 6 | 7 | export const UPDATE = '@namespace/UPDATE' 8 | export const EMPTY = '@namespace/EMPTY' 9 | export const UPDATE_FULFILLED = '@namespace/UPDATE_FULFILLED' 10 | export const UPDATE_FAILED = '@namespace/UPDATE_FAILED' 11 | export const BOOL_ACTION = '@namespace/BOOL_ACTION' 12 | export const ERR_ACTION = '@namespace/ERR_ACTION' 13 | export const ERR_META_ACTION = '@namespace/ERR_META_ACTION' 14 | 15 | export type EntityId = {id: number} 16 | export type State = { 17 | status: 'done' | 'pending' | 'error' | 'failed'; 18 | ready: boolean; 19 | data?: EntityId[]; 20 | } 21 | 22 | const actions = createActions({ 23 | /** 24 | * {type: EMPTY} 25 | */ 26 | [EMPTY]: empty, 27 | /** 28 | * {type: UPDATE} 29 | */ 30 | [UPDATE]: action, 31 | /** 32 | * {type: UPDATE_FULFILLED, payload: EntityId[]} 33 | */ 34 | [UPDATE_FULFILLED]: (x: EntityId[]) => action(x), 35 | /** 36 | * {type: UPDATE_FAILED, payload: EntityId, meta: {sync: true}} 37 | */ 38 | [UPDATE_FAILED]: (x: EntityId, meta: {sync: true}) => action(x, meta), 39 | [BOOL_ACTION]: (x: boolean) => action(x), 40 | [ERR_ACTION]: (x: number) => error(x), 41 | [ERR_META_ACTION]: (x: number, m: number) => error(x, m), 42 | }) 43 | 44 | export const { 45 | [UPDATE]: update, 46 | [UPDATE_FULFILLED]: updateFulfilled, 47 | [UPDATE_FAILED]: updateFailed, 48 | [BOOL_ACTION]: boolAction, 49 | [ERR_ACTION]: errAction, 50 | [ERR_META_ACTION]: errMetaAction, 51 | } = actions 52 | 53 | export type Actions = typeof actions 54 | 55 | /** 56 | * Tests start 57 | */ 58 | 59 | const checkInferedActionsType: { 60 | '@namespace/UPDATE': () => {type: '@namespace/UPDATE'}, 61 | '@namespace/EMPTY': () => {type: '@namespace/EMPTY'}, 62 | '@namespace/UPDATE_FULFILLED': (arg: EntityId[]) => {type: '@namespace/UPDATE_FULFILLED', payload: EntityId[]}, 63 | '@namespace/UPDATE_FAILED': (arg: EntityId, meta: {sync: true}) => {type: '@namespace/UPDATE_FAILED', payload: EntityId, meta: {sync: true}}, 64 | '@namespace/BOOL_ACTION': (arg: boolean) => {type: '@namespace/BOOL_ACTION', payload: boolean}, 65 | '@namespace/ERR_ACTION': (arg: number) => {type: '@namespace/ERR_ACTION'; payload: number; error: true}, 66 | '@namespace/ERR_META_ACTION': (arg: number, meta: number) => {type: '@namespace/ERR_META_ACTION'; payload: number; meta: number, error: true}, 67 | } = actions 68 | 69 | const testUpdate: () => {type: '@namespace/UPDATE'} = update 70 | const testUpdateFulffilled: (x: EntityId[]) => {type: '@namespace/UPDATE_FULFILLED', payload: EntityId[]} = updateFulfilled 71 | const testUpdateFailed: (x: EntityId, meta: {sync: true}) => {type: '@namespace/UPDATE_FAILED', payload: EntityId, meta: {sync: true}} = updateFailed 72 | const testErrAction: (x: number) => {type: '@namespace/ERR_ACTION', payload: number, error: true} = errAction 73 | const testErrMetaAction: (x: number, m: number) => {type: '@namespace/ERR_META_ACTION', payload: number, meta: number, error: true} = errMetaAction 74 | 75 | /* eslint-disable no-console */ 76 | console.log( 77 | checkInferedActionsType, 78 | testUpdate, 79 | testUpdateFulffilled, 80 | testUpdateFailed, 81 | testErrAction, 82 | testErrMetaAction, 83 | ) 84 | -------------------------------------------------------------------------------- /dts/test/reducers-classic.ts: -------------------------------------------------------------------------------- 1 | import {UPDATE, UPDATE_FULFILLED, UPDATE_FAILED, BOOL_ACTION} from './actions' 2 | import type {State, Actions} from './actions' 3 | import {handleActions} from '../index' 4 | import type {Handlers} from '../index' 5 | 6 | // providing all reducers is not required 7 | export const reducer_1 = handleActions({} as Handlers) 8 | 9 | // @ts-expect-error cannot return a state shape instead of state✅ 10 | export const reducer_2 = handleActions({ 11 | [UPDATE]: () => ({}), 12 | } as Handlers) 13 | 14 | // payload is inferred correctly sinec it is assignable to data property ✅ 15 | export const reducer_3 = handleActions({ 16 | [UPDATE_FULFILLED]: (state, {payload}) => ({ 17 | ...state, 18 | data: payload, 19 | status: 'done', 20 | }), 21 | } as Handlers) 22 | 23 | // @ts-expect-error: unknownField property raises an error when value is not one of $Values 24 | export const reducer_4 = handleActions({ 25 | [UPDATE]: (state) => ({ 26 | ...state, 27 | unknownField: 'I SHOULD NOT BE HERE', 28 | }), 29 | } as Handlers) 30 | 31 | /** 32 | * ❌ unknownField does not raise an error for $Values 33 | * This is expected. It is a limitation of $Exact util implementation 34 | * without custom $Exact typescript does not raise an error for any addional fields 35 | */ 36 | export const reducer_5 = handleActions({ 37 | [UPDATE_FAILED]: (state, action) => ({ 38 | ...state, 39 | ready: action.meta.sync, 40 | status: 'failed', 41 | unknownField: true, 42 | }), 43 | } as Handlers) 44 | 45 | export const reducer_6 = handleActions({ 46 | [UPDATE_FAILED]: (state, action): State => ({ 47 | // ^^^^^ explicit return type 48 | ...state, 49 | ready: action.meta.sync, 50 | status: 'failed', 51 | // @ts-expect-error: to avoid additional fields State should be specified as a return type explicitly 52 | unknownField: true, 53 | }), 54 | } as Handlers) 55 | 56 | type BoolState = boolean; 57 | 58 | // accepts the second argument the same type as state 59 | export const bool_reducer_1 = handleActions({ 60 | [BOOL_ACTION]: (state, {payload}) => state && payload, 61 | } as Handlers, false) 62 | 63 | // does not accept the second argument that's not of type State 64 | export const bool_reducer_2 = handleActions( 65 | { 66 | [BOOL_ACTION]: (state, {payload}) => state && payload, 67 | } as Handlers, 68 | // @ts-expect-error Argument of type '"string"' is not assignable to parameter of type 'boolean | undefined'. 69 | 'string', 70 | ) 71 | -------------------------------------------------------------------------------- /dts/test/reducers-immer.ts: -------------------------------------------------------------------------------- 1 | import {UPDATE, UPDATE_FULFILLED, UPDATE_FAILED, BOOL_ACTION} from './actions' 2 | import type {State, Actions} from './actions' 3 | import {handleActions} from '../immer' 4 | import type {Handlers} from '../immer' 5 | 6 | // providing all reducers is not required 7 | export const reducer_1 = handleActions({} as Handlers) 8 | 9 | export const reducer_2 = handleActions({ 10 | [UPDATE]: () => ({}), 11 | } as Handlers) 12 | 13 | // payload is inferred correctly sinec it is assignable to data property ✅ 14 | export const reducer_3 = handleActions({ 15 | [UPDATE_FULFILLED]: (state, {payload}) => { 16 | state.data = payload; 17 | state.status = 'done'; 18 | }, 19 | [UPDATE_FAILED]: (state, {payload, meta}) => { 20 | state.data = [payload]; 21 | // correct meta type ✅ 22 | state.ready = meta.sync, 23 | state.status = 'done'; 24 | }, 25 | } as Handlers) 26 | 27 | export const reducer_4 = handleActions({ 28 | [UPDATE]: (state) => { 29 | // @ts-expect-error: unknownField does not exist on State 30 | state.unknownField = 'I SHOULD NOT BE HERE'; 31 | }, 32 | } as Handlers) 33 | 34 | type BoolState = boolean; 35 | 36 | // accepts the second argument the same type as state 37 | export const bool_reducer_1 = handleActions({ 38 | [BOOL_ACTION]: (state, {payload}) => state && payload, 39 | } as Handlers, false) 40 | 41 | // does not accept the second argument that's not of type State 42 | export const bool_reducer_2 = handleActions( 43 | { 44 | [BOOL_ACTION]: (state, {payload}) => state && payload, 45 | } as Handlers, 46 | // @ts-expect-error Argument of type '"string"' is not assignable to parameter of type 'boolean | undefined'. 47 | 'string', 48 | ) 49 | -------------------------------------------------------------------------------- /dts/test/types.ts: -------------------------------------------------------------------------------- 1 | import type {Frozen} from '../types' 2 | 3 | type Extends = A extends B ? true : never; 4 | 5 | export type Result = Frozen<{ 6 | num: number; 7 | bool: boolean; 8 | str: 'foo'; 9 | tuple: [number, string]; 10 | obj: { 11 | undef: undefined; 12 | nil: null; 13 | }; 14 | }> 15 | 16 | export const checkDeepFreeze 17 | : Extends< 18 | Result, 19 | { 20 | readonly num: number; 21 | readonly bool: boolean; 22 | readonly str: 'foo'; 23 | readonly tuple: readonly [number, string]; 24 | readonly obj: { 25 | readonly undef: undefined; 26 | readonly nil: null; 27 | }; 28 | } 29 | > = true; 30 | 31 | type StringFrozen = Frozen<'foo'>; 32 | 33 | export const checkPrimitiveFreeze: Extends = true 34 | 35 | type TupleFrozen = Frozen<['foo', 'bar']>; 36 | 37 | export const checkTupleFreeze: Extends = true 38 | -------------------------------------------------------------------------------- /dts/types.d.ts: -------------------------------------------------------------------------------- 1 | export type Frozen = Readonly> 2 | export type InnerFrozen = T extends object 3 | ? Readonly<{[K in keyof T]: InnerFrozen}> 4 | : T extends any[] 5 | ? ReadonlyArray 6 | : T 7 | 8 | export type Arguments any> = Parameters 9 | -------------------------------------------------------------------------------- /flow-typed/npm/redux-actions_v2.x.x.js: -------------------------------------------------------------------------------- 1 | // flow-typed signature: 7e15adce10779b8fb956eeb8c0c83512 2 | // flow-typed version: 56da885f85/redux-actions_v2.x.x/flow_>=v0.39.x 3 | 4 | declare module "redux-actions" { 5 | /* 6 | * Use `ActionType` to get the type of the action created by a given action 7 | * creator. For example: 8 | * 9 | * import { createAction, type ActionType } from 'redux-actions' 10 | * 11 | * const increment = createAction(INCREMENT, (count: number) => count) 12 | * 13 | * function myReducer(state: State = initState, action: ActionType): State { 14 | * // Flow will infer that the type of `action.payload` is `number` 15 | * } 16 | */ 17 | declare type ActionType = _ActionType<*, ActionCreator>; 18 | declare type _ActionType R> = R; 19 | 20 | /* 21 | * To get the most from Flow type checking use a `payloadCreator` argument 22 | * with `createAction`. Make sure that Flow can infer the argument type of the 23 | * `payloadCreator`. That will allow Flow to infer the payload type of actions 24 | * created by that action creator in other parts of the program. For example: 25 | * 26 | * const increment = createAction(INCREMENT, (count: number) => count) 27 | * 28 | */ 29 | declare function createAction( 30 | type: T, 31 | $?: empty // hack to force Flow to not use this signature when more than one argument is given 32 | ): (payload: P, ...rest: any[]) => { type: T, payload: P, error?: boolean }; 33 | 34 | declare function createAction( 35 | type: T, 36 | payloadCreator: (...rest: A) => P, 37 | $?: empty 38 | ): (...rest: A) => { type: T, payload: P, error?: boolean }; 39 | 40 | declare function createAction( 41 | type: T, 42 | payloadCreator: (...rest: A) => P, 43 | metaCreator: (...rest: A) => M 44 | ): (...rest: A) => { type: T, payload: P, error?: boolean, meta: M }; 45 | 46 | declare function createAction( 47 | type: T, 48 | payloadCreator: null | void, 49 | metaCreator: (payload: P, ...rest: any[]) => M 50 | ): ( 51 | payload: P, 52 | ...rest: any[] 53 | ) => { type: T, payload: P, error?: boolean, meta: M }; 54 | 55 | // `createActions` is quite difficult to write a type for. Maybe try not to 56 | // use this one? 57 | declare function createActions( 58 | actionMap: Object, 59 | ...identityActions: string[] 60 | ): Object; 61 | declare function createActions(...identityActions: string[]): Object; 62 | 63 | declare type Reducer = (state: S, action: A) => S; 64 | 65 | declare type ReducerMap = 66 | | { next: Reducer } 67 | | { throw: Reducer } 68 | | { next: Reducer, throw: Reducer }; 69 | 70 | /* 71 | * To get full advantage from Flow, use a type annotation on the action 72 | * argument to your reducer when creating a reducer with `handleAction` or 73 | * `handleActions`. For example: 74 | * 75 | * import { type Reducer } from 'redux' 76 | * import { createAction, handleAction, type Action } from 'redux-actions' 77 | * 78 | * const increment = createAction(INCREMENT, (count: number) => count) 79 | * 80 | * const reducer = handleAction(INCREMENT, (state, { payload }: ActionType) => { 81 | * // Flow infers that the type of `payload` is number 82 | * }, defaultState) 83 | */ 84 | 85 | declare type ReducerDefinition = { 86 | [key: string]: 87 | | (Reducer | ReducerDefinition) 88 | | ReducerMap 89 | }; 90 | 91 | declare function handleAction( 92 | type: Type, 93 | reducer: ReducerDefinition, 94 | defaultState: State 95 | ): Reducer; 96 | 97 | declare function handleActions( 98 | reducers: { 99 | [key: string]: Reducer | ReducerMap 100 | }, 101 | defaultState?: State 102 | ): Reducer; 103 | 104 | declare function combineActions( 105 | ...types: (string | Symbol | Function)[] 106 | ): string; 107 | } 108 | -------------------------------------------------------------------------------- /flow-typed/npm/redux_v3.x.x.js: -------------------------------------------------------------------------------- 1 | // flow-typed signature: ec7daead5cb4fec5ab25fedbedef29e8 2 | // flow-typed version: 2c04631d20/redux_v3.x.x/flow_>=v0.55.x 3 | 4 | declare module 'redux' { 5 | 6 | /* 7 | 8 | S = State 9 | A = Action 10 | D = Dispatch 11 | 12 | */ 13 | 14 | declare export type DispatchAPI = (action: A) => A; 15 | declare export type Dispatch }> = DispatchAPI; 16 | 17 | declare export type MiddlewareAPI> = { 18 | dispatch: D; 19 | getState(): S; 20 | }; 21 | 22 | declare export type Store> = { 23 | // rewrite MiddlewareAPI members in order to get nicer error messages (intersections produce long messages) 24 | dispatch: D; 25 | getState(): S; 26 | subscribe(listener: () => void): () => void; 27 | replaceReducer(nextReducer: Reducer): void 28 | }; 29 | 30 | declare export type Reducer = (state: S, action: A) => S; 31 | 32 | declare export type CombinedReducer = (state: $Shape & {} | void, action: A) => S; 33 | 34 | declare export type Middleware> = 35 | (api: MiddlewareAPI) => 36 | (next: D) => D; 37 | 38 | declare export type StoreCreator> = { 39 | (reducer: Reducer, enhancer?: StoreEnhancer): Store; 40 | (reducer: Reducer, preloadedState: S, enhancer?: StoreEnhancer): Store; 41 | }; 42 | 43 | declare export type StoreEnhancer> = (next: StoreCreator) => StoreCreator; 44 | 45 | declare export function createStore(reducer: Reducer, enhancer?: StoreEnhancer): Store; 46 | declare export function createStore(reducer: Reducer, preloadedState: S, enhancer?: StoreEnhancer): Store; 47 | 48 | declare export function applyMiddleware(...middlewares: Array>): StoreEnhancer; 49 | 50 | declare export type ActionCreator = (...args: Array) => A; 51 | declare export type ActionCreators = { [key: K]: ActionCreator }; 52 | 53 | declare export function bindActionCreators, D: DispatchAPI>(actionCreator: C, dispatch: D): C; 54 | declare export function bindActionCreators, D: DispatchAPI>(actionCreators: C, dispatch: D): C; 55 | 56 | declare export function combineReducers(reducers: O): CombinedReducer<$ObjMap(r: Reducer) => S>, A>; 57 | 58 | declare export var compose: $Compose; 59 | } -------------------------------------------------------------------------------- /flow-typed/npm/rxjs_v5.0.x.js: -------------------------------------------------------------------------------- 1 | // flow-typed signature: 40d60f46fb115f551b496c572b577cfe 2 | // flow-typed version: 55b9091816/rxjs_v5.0.x/flow_>=v0.34.x 3 | 4 | // FIXME(samgoldman) Remove top-level interface once Babel supports 5 | // `declare interface` syntax. 6 | // FIXME(samgoldman) Remove this once rxjs$Subject can mixin rxjs$Observer 7 | interface rxjs$IObserver<-T> { 8 | closed?: boolean; 9 | next(value: T): mixed; 10 | error(error: any): mixed; 11 | complete(): mixed; 12 | } 13 | 14 | type rxjs$PartialObserver<-T> = 15 | | { 16 | +next: (value: T) => mixed, 17 | +error?: (error: any) => mixed, 18 | +complete?: () => mixed 19 | } 20 | | { 21 | +next?: (value: T) => mixed, 22 | +error: (error: any) => mixed, 23 | +complete?: () => mixed 24 | } 25 | | { 26 | +next?: (value: T) => mixed, 27 | +error?: (error: any) => mixed, 28 | +complete: () => mixed 29 | }; 30 | 31 | interface rxjs$ISubscription { 32 | unsubscribe(): void; 33 | } 34 | 35 | type rxjs$TeardownLogic = rxjs$ISubscription | (() => void); 36 | 37 | type rxjs$EventListenerOptions = 38 | | { 39 | capture?: boolean, 40 | passive?: boolean, 41 | once?: boolean 42 | } 43 | | boolean; 44 | 45 | type rxjs$ObservableInput = rxjs$Observable | Promise | Iterable; 46 | 47 | type rxjs$OperatorFunction = (rxjs$Observable) => rxjs$Observable; 48 | type rxjs$OperatorFunctionLast> = ( 49 | rxjs$Observable 50 | ) => R; 51 | 52 | declare class rxjs$Observable<+T> { 53 | static bindCallback( 54 | callbackFunc: (callback: (_: void) => any) => any, 55 | selector?: void, 56 | scheduler?: rxjs$SchedulerClass 57 | ): () => rxjs$Observable; 58 | static bindCallback( 59 | callbackFunc: (callback: (result: U) => any) => any, 60 | selector?: void, 61 | scheduler?: rxjs$SchedulerClass 62 | ): () => rxjs$Observable; 63 | static bindCallback( 64 | callbackFunc: (v1: T, callback: (result: U) => any) => any, 65 | selector?: void, 66 | scheduler?: rxjs$SchedulerClass 67 | ): (v1: T) => rxjs$Observable; 68 | static bindCallback( 69 | callbackFunc: (v1: T, v2: T2, callback: (result: U) => any) => any, 70 | selector?: void, 71 | scheduler?: rxjs$SchedulerClass 72 | ): (v1: T, v2: T2) => rxjs$Observable; 73 | static bindCallback( 74 | callbackFunc: (v1: T, v2: T2, v3: T3, callback: (result: U) => any) => any, 75 | selector?: void, 76 | scheduler?: rxjs$SchedulerClass 77 | ): (v1: T, v2: T2, v3: T3) => rxjs$Observable; 78 | static bindCallback( 79 | callbackFunc: ( 80 | v1: T, 81 | v2: T2, 82 | v3: T3, 83 | v4: T4, 84 | callback: (result: U) => any 85 | ) => any, 86 | selector?: void, 87 | scheduler?: rxjs$SchedulerClass 88 | ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable; 89 | static bindCallback( 90 | callbackFunc: ( 91 | v1: T, 92 | v2: T2, 93 | v3: T3, 94 | v4: T4, 95 | v5: T5, 96 | callback: (result: U) => any 97 | ) => any, 98 | selector?: void, 99 | scheduler?: rxjs$SchedulerClass 100 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable; 101 | static bindCallback( 102 | callbackFunc: ( 103 | v1: T, 104 | v2: T2, 105 | v3: T3, 106 | v4: T4, 107 | v5: T5, 108 | v6: T6, 109 | callback: (result: U) => any 110 | ) => any, 111 | selector?: void, 112 | scheduler?: rxjs$SchedulerClass 113 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable; 114 | static bindCallback( 115 | callbackFunc: (callback: (...args: Array) => any) => any, 116 | selector: (...args: Array) => U, 117 | scheduler?: rxjs$SchedulerClass 118 | ): () => rxjs$Observable; 119 | static bindCallback( 120 | callbackFunc: (v1: T, callback: (...args: Array) => any) => any, 121 | selector: (...args: Array) => U, 122 | scheduler?: rxjs$SchedulerClass 123 | ): (v1: T) => rxjs$Observable; 124 | static bindCallback( 125 | callbackFunc: ( 126 | v1: T, 127 | v2: T2, 128 | callback: (...args: Array) => any 129 | ) => any, 130 | selector: (...args: Array) => U, 131 | scheduler?: rxjs$SchedulerClass 132 | ): (v1: T, v2: T2) => rxjs$Observable; 133 | static bindCallback( 134 | callbackFunc: ( 135 | v1: T, 136 | v2: T2, 137 | v3: T3, 138 | callback: (...args: Array) => any 139 | ) => any, 140 | selector: (...args: Array) => U, 141 | scheduler?: rxjs$SchedulerClass 142 | ): (v1: T, v2: T2, v3: T3) => rxjs$Observable; 143 | static bindCallback( 144 | callbackFunc: ( 145 | v1: T, 146 | v2: T2, 147 | v3: T3, 148 | v4: T4, 149 | callback: (...args: Array) => any 150 | ) => any, 151 | selector: (...args: Array) => U, 152 | scheduler?: rxjs$SchedulerClass 153 | ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable; 154 | static bindCallback( 155 | callbackFunc: ( 156 | v1: T, 157 | v2: T2, 158 | v3: T3, 159 | v4: T4, 160 | v5: T5, 161 | callback: (...args: Array) => any 162 | ) => any, 163 | selector: (...args: Array) => U, 164 | scheduler?: rxjs$SchedulerClass 165 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable; 166 | static bindCallback( 167 | callbackFunc: ( 168 | v1: T, 169 | v2: T2, 170 | v3: T3, 171 | v4: T4, 172 | v5: T5, 173 | v6: T6, 174 | callback: (...args: Array) => any 175 | ) => any, 176 | selector: (...args: Array) => U, 177 | scheduler?: rxjs$SchedulerClass 178 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable; 179 | static bindCallback( 180 | callbackFunc: Function, 181 | selector?: void, 182 | scheduler?: rxjs$SchedulerClass 183 | ): (...args: Array) => rxjs$Observable; 184 | static bindCallback( 185 | callbackFunc: Function, 186 | selector?: (...args: Array) => T, 187 | scheduler?: rxjs$SchedulerClass 188 | ): (...args: Array) => rxjs$Observable; 189 | 190 | static bindNodeCallback( 191 | callbackFunc: (callback: (err: any, result: U) => any) => any, 192 | selector?: void, 193 | scheduler?: rxjs$SchedulerClass 194 | ): () => rxjs$Observable; 195 | static bindNodeCallback( 196 | callbackFunc: (v1: T, callback: (err: any, result: U) => any) => any, 197 | selector?: void, 198 | scheduler?: rxjs$SchedulerClass 199 | ): (v1: T) => rxjs$Observable; 200 | static bindNodeCallback( 201 | callbackFunc: ( 202 | v1: T, 203 | v2: T2, 204 | callback: (err: any, result: U) => any 205 | ) => any, 206 | selector?: void, 207 | scheduler?: rxjs$SchedulerClass 208 | ): (v1: T, v2: T2) => rxjs$Observable; 209 | static bindNodeCallback( 210 | callbackFunc: ( 211 | v1: T, 212 | v2: T2, 213 | v3: T3, 214 | callback: (err: any, result: U) => any 215 | ) => any, 216 | selector?: void, 217 | scheduler?: rxjs$SchedulerClass 218 | ): (v1: T, v2: T2, v3: T3) => rxjs$Observable; 219 | static bindNodeCallback( 220 | callbackFunc: ( 221 | v1: T, 222 | v2: T2, 223 | v3: T3, 224 | v4: T4, 225 | callback: (err: any, result: U) => any 226 | ) => any, 227 | selector?: void, 228 | scheduler?: rxjs$SchedulerClass 229 | ): (v1: T, v2: T2, v3: T3, v4: T4) => rxjs$Observable; 230 | static bindNodeCallback( 231 | callbackFunc: ( 232 | v1: T, 233 | v2: T2, 234 | v3: T3, 235 | v4: T4, 236 | v5: T5, 237 | callback: (err: any, result: U) => any 238 | ) => any, 239 | selector?: void, 240 | scheduler?: rxjs$SchedulerClass 241 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => rxjs$Observable; 242 | static bindNodeCallback( 243 | callbackFunc: ( 244 | v1: T, 245 | v2: T2, 246 | v3: T3, 247 | v4: T4, 248 | v5: T5, 249 | v6: T6, 250 | callback: (err: any, result: U) => any 251 | ) => any, 252 | selector?: void, 253 | scheduler?: rxjs$SchedulerClass 254 | ): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => rxjs$Observable; 255 | static bindNodeCallback( 256 | callbackFunc: Function, 257 | selector?: void, 258 | scheduler?: rxjs$SchedulerClass 259 | ): (...args: Array) => rxjs$Observable; 260 | static bindNodeCallback( 261 | callbackFunc: Function, 262 | selector?: (...args: Array) => T, 263 | scheduler?: rxjs$SchedulerClass 264 | ): (...args: Array) => rxjs$Observable; 265 | 266 | static concat(...sources: rxjs$Observable[]): rxjs$Observable; 267 | 268 | static create( 269 | subscribe: ( 270 | observer: rxjs$Observer 271 | ) => rxjs$ISubscription | Function | void 272 | ): rxjs$Observable; 273 | 274 | static defer( 275 | observableFactory: () => rxjs$Observable | Promise 276 | ): rxjs$Observable; 277 | 278 | static from( 279 | input: rxjs$ObservableInput, 280 | scheduler?: rxjs$SchedulerClass 281 | ): rxjs$Observable; 282 | 283 | static fromEvent( 284 | element: any, 285 | eventName: string, 286 | ...none: Array 287 | ): rxjs$Observable; 288 | static fromEvent( 289 | element: any, 290 | eventName: string, 291 | options: rxjs$EventListenerOptions, 292 | ...none: Array 293 | ): rxjs$Observable; 294 | static fromEvent( 295 | element: any, 296 | eventName: string, 297 | selector: () => T, 298 | ...none: Array 299 | ): rxjs$Observable; 300 | static fromEvent( 301 | element: any, 302 | eventName: string, 303 | options: rxjs$EventListenerOptions, 304 | selector: () => T 305 | ): rxjs$Observable; 306 | 307 | static fromEventPattern( 308 | addHandler: (handler: (item: T) => void) => void, 309 | removeHandler: (handler: (item: T) => void) => void, 310 | selector?: () => T 311 | ): rxjs$Observable; 312 | 313 | static fromPromise(promise: Promise): rxjs$Observable; 314 | 315 | static empty(): rxjs$Observable; 316 | 317 | static interval(period: number): rxjs$Observable; 318 | 319 | static timer( 320 | initialDelay: number | Date, 321 | period?: number, 322 | scheduler?: rxjs$SchedulerClass 323 | ): rxjs$Observable; 324 | 325 | static merge( 326 | source0: rxjs$Observable, 327 | source1: rxjs$Observable 328 | ): rxjs$Observable; 329 | static merge( 330 | source0: rxjs$Observable, 331 | source1: rxjs$Observable, 332 | source2: rxjs$Observable 333 | ): rxjs$Observable; 334 | static merge(...sources: rxjs$Observable[]): rxjs$Observable; 335 | 336 | static never(): rxjs$Observable; 337 | 338 | static of(...values: T[]): rxjs$Observable; 339 | 340 | static range( 341 | start?: number, 342 | count?: number, 343 | scheduler?: rxjs$SchedulerClass 344 | ): rxjs$Observable; 345 | 346 | static throw(error: any): rxjs$Observable; 347 | 348 | audit( 349 | durationSelector: (value: T) => rxjs$Observable | Promise 350 | ): rxjs$Observable; 351 | 352 | auditTime( 353 | duration: number, 354 | scheduler?: rxjs$SchedulerClass 355 | ): rxjs$Observable; 356 | 357 | race(other: rxjs$Observable): rxjs$Observable; 358 | 359 | repeat(count?: number): rxjs$Observable; 360 | 361 | buffer(bufferBoundaries: rxjs$Observable): rxjs$Observable>; 362 | 363 | bufferCount( 364 | bufferSize: number, 365 | startBufferEvery?: number 366 | ): rxjs$Observable>; 367 | 368 | bufferTime( 369 | bufferTimeSpan: number, 370 | bufferCreationInterval?: number, 371 | maxBufferSize?: number, 372 | scheduler?: rxjs$SchedulerClass 373 | ): rxjs$Observable>; 374 | 375 | bufferToggle( 376 | openings: rxjs$Observable | Promise, 377 | closingSelector: (value: U) => rxjs$Observable | Promise 378 | ): rxjs$Observable>; 379 | 380 | bufferWhen( 381 | closingSelector: () => rxjs$Observable 382 | ): rxjs$Observable>; 383 | 384 | catch( 385 | selector: (err: any, caught: rxjs$Observable) => rxjs$Observable 386 | ): rxjs$Observable; 387 | 388 | concat(...sources: rxjs$Observable[]): rxjs$Observable; 389 | 390 | concatAll(): rxjs$Observable; 391 | 392 | concatMap( 393 | f: (value: T, index: number) => rxjs$ObservableInput, 394 | _: void 395 | ): rxjs$Observable; 396 | concatMap( 397 | f: (value: T, index: number) => rxjs$ObservableInput, 398 | resultSelector: ( 399 | outerValue: T, 400 | innerValue: U, 401 | outerIndex: number, 402 | innerIndex: number 403 | ) => V 404 | ): rxjs$Observable; 405 | 406 | debounceTime( 407 | dueTime: number, 408 | scheduler?: rxjs$SchedulerClass 409 | ): rxjs$Observable; 410 | 411 | defaultIfEmpty(defaultValue: U): rxjs$Observable; 412 | 413 | delay(dueTime: number, scheduler?: rxjs$SchedulerClass): rxjs$Observable; 414 | 415 | delayWhen( 416 | delayDurationSelector: (value: T) => rxjs$Observable, 417 | subscriptionDelay?: rxjs$Observable 418 | ): rxjs$Observable; 419 | 420 | distinctUntilChanged(compare?: (x: T, y: T) => boolean): rxjs$Observable; 421 | 422 | distinct( 423 | keySelector?: (value: T) => U, 424 | flushes?: rxjs$Observable 425 | ): rxjs$Observable; 426 | 427 | distinctUntilKeyChanged( 428 | key: string, 429 | compare?: (x: mixed, y: mixed) => boolean 430 | ): rxjs$Observable; 431 | 432 | elementAt(index: number, defaultValue?: T): rxjs$Observable; 433 | 434 | exhaustMap( 435 | project: (value: T, index: number) => rxjs$ObservableInput, 436 | _: void 437 | ): rxjs$Observable; 438 | exhaustMap( 439 | project: (value: T, index: number) => rxjs$ObservableInput, 440 | resultSelector: ( 441 | outerValue: T, 442 | innerValue: U, 443 | outerIndex: number, 444 | innerIndex: number 445 | ) => V 446 | ): rxjs$Observable; 447 | 448 | expand( 449 | project: (value: T, index: number) => rxjs$Observable, 450 | concurrent?: number, 451 | scheduler?: rxjs$SchedulerClass 452 | ): rxjs$Observable; 453 | 454 | filter( 455 | predicate: (value: T, index: number) => boolean, 456 | thisArg?: any 457 | ): rxjs$Observable; 458 | 459 | finally(f: () => mixed): rxjs$Observable; 460 | 461 | first( 462 | predicate?: (value: T, index: number, source: rxjs$Observable) => boolean 463 | ): rxjs$Observable; 464 | first( 465 | predicate: ?( 466 | value: T, 467 | index: number, 468 | source: rxjs$Observable 469 | ) => boolean, 470 | resultSelector: (value: T, index: number) => U 471 | ): rxjs$Observable; 472 | first( 473 | predicate: ?( 474 | value: T, 475 | index: number, 476 | source: rxjs$Observable 477 | ) => boolean, 478 | resultSelector: ?(value: T, index: number) => U, 479 | defaultValue: U 480 | ): rxjs$Observable; 481 | 482 | groupBy( 483 | keySelector: (value: T) => K, 484 | _: void 485 | ): rxjs$Observable>; 486 | groupBy( 487 | keySelector: (value: T) => K, 488 | elementSelector: (value: T) => V, 489 | durationSelector?: ( 490 | grouped: rxjs$GroupedObservable 491 | ) => rxjs$Observable 492 | ): rxjs$Observable>; 493 | 494 | ignoreElements(): rxjs$Observable; 495 | 496 | last( 497 | predicate?: (value: T, index: number, source: rxjs$Observable) => boolean 498 | ): rxjs$Observable; 499 | last( 500 | predicate: ?( 501 | value: T, 502 | index: number, 503 | source: rxjs$Observable 504 | ) => boolean, 505 | resultSelector: (value: T, index: number) => U 506 | ): rxjs$Observable; 507 | last( 508 | predicate: ?( 509 | value: T, 510 | index: number, 511 | source: rxjs$Observable 512 | ) => boolean, 513 | resultSelector: ?(value: T, index: number) => U, 514 | defaultValue: U 515 | ): rxjs$Observable; 516 | 517 | let( 518 | project: (self: rxjs$Observable) => rxjs$Observable 519 | ): rxjs$Observable; 520 | 521 | // Alias for `let` 522 | letBind( 523 | project: (self: rxjs$Observable) => rxjs$Observable 524 | ): rxjs$Observable; 525 | 526 | switch(): T; // assumption: T is Observable 527 | 528 | // Alias for `mergeMap` 529 | flatMap( 530 | project: (value: T, index: number) => rxjs$ObservableInput, 531 | concurrency?: number 532 | ): rxjs$Observable; 533 | flatMap( 534 | project: (value: T, index: number) => rxjs$ObservableInput, 535 | resultSelector: ( 536 | outerValue: T, 537 | innerValue: U, 538 | outerIndex: number, 539 | innerIndex: number 540 | ) => V, 541 | concurrency?: number 542 | ): rxjs$Observable; 543 | 544 | flatMapTo(innerObservable: rxjs$Observable): rxjs$Observable; 545 | 546 | flatMapTo( 547 | innerObservable: rxjs$Observable, 548 | resultSelector: ( 549 | outerValue: T, 550 | innerValue: U, 551 | outerIndex: number, 552 | innerIndex: number 553 | ) => V, 554 | concurrent?: number 555 | ): rxjs$Observable; 556 | 557 | switchMap( 558 | project: (value: T, index: number) => rxjs$ObservableInput, 559 | _: void 560 | ): rxjs$Observable; 561 | switchMap( 562 | project: (value: T, index: number) => rxjs$ObservableInput, 563 | resultSelector: ( 564 | outerValue: T, 565 | innerValue: U, 566 | outerIndex: number, 567 | innerIndex: number 568 | ) => V 569 | ): rxjs$Observable; 570 | 571 | switchMapTo(innerObservable: rxjs$Observable): rxjs$Observable; 572 | 573 | map(f: (value: T, index: number) => U, thisArg?: any): rxjs$Observable; 574 | 575 | mapTo(value: U): rxjs$Observable; 576 | 577 | merge(other: rxjs$Observable): rxjs$Observable; 578 | 579 | mergeAll(): rxjs$Observable; 580 | 581 | mergeMap( 582 | project: (value: T, index: number) => rxjs$ObservableInput, 583 | concurrency?: number 584 | ): rxjs$Observable; 585 | mergeMap( 586 | project: (value: T, index: number) => rxjs$ObservableInput, 587 | resultSelector: ( 588 | outerValue: T, 589 | innerValue: U, 590 | outerIndex: number, 591 | innerIndex: number 592 | ) => V, 593 | concurrency?: number 594 | ): rxjs$Observable; 595 | 596 | mergeMapTo(innerObservable: rxjs$Observable): rxjs$Observable; 597 | 598 | mergeMapTo( 599 | innerObservable: rxjs$Observable, 600 | resultSelector: ( 601 | outerValue: T, 602 | innerValue: U, 603 | outerIndex: number, 604 | innerIndex: number 605 | ) => V, 606 | concurrent?: number 607 | ): rxjs$Observable; 608 | 609 | multicast( 610 | subjectOrSubjectFactory: rxjs$Subject | (() => rxjs$Subject) 611 | ): rxjs$ConnectableObservable; 612 | 613 | observeOn(scheduler: rxjs$SchedulerClass): rxjs$Observable; 614 | 615 | pairwise(): rxjs$Observable<[T, T]>; 616 | 617 | partition( 618 | predicate: (value: T, index: number) => boolean, 619 | thisArg: any 620 | ): [rxjs$Observable, rxjs$Observable]; 621 | 622 | pipe(): rxjs$Observable; 623 | 624 | pipe(op1: rxjs$OperatorFunctionLast): A; 625 | 626 | pipe( 627 | op1: rxjs$OperatorFunction, 628 | op2: rxjs$OperatorFunctionLast 629 | ): B; 630 | 631 | pipe( 632 | op1: rxjs$OperatorFunction, 633 | op2: rxjs$OperatorFunction, 634 | op3: rxjs$OperatorFunctionLast 635 | ): C; 636 | 637 | pipe( 638 | op1: rxjs$OperatorFunction, 639 | op2: rxjs$OperatorFunction, 640 | op3: rxjs$OperatorFunction, 641 | op4: rxjs$OperatorFunctionLast 642 | ): D; 643 | 644 | pipe( 645 | op1: rxjs$OperatorFunction, 646 | op2: rxjs$OperatorFunction, 647 | op3: rxjs$OperatorFunction, 648 | op4: rxjs$OperatorFunction, 649 | op5: rxjs$OperatorFunctionLast 650 | ): E; 651 | 652 | publish(): rxjs$ConnectableObservable; 653 | 654 | publishLast(): rxjs$ConnectableObservable; 655 | 656 | reduce( 657 | accumulator: ( 658 | acc: U, 659 | currentValue: T, 660 | index: number, 661 | source: rxjs$Observable 662 | ) => U, 663 | seed: U 664 | ): rxjs$Observable; 665 | 666 | sample(notifier: rxjs$Observable): rxjs$Observable; 667 | 668 | sampleTime( 669 | delay: number, 670 | scheduler?: rxjs$SchedulerClass 671 | ): rxjs$Observable; 672 | 673 | publishReplay( 674 | bufferSize?: number, 675 | windowTime?: number, 676 | scheduler?: rxjs$SchedulerClass 677 | ): rxjs$ConnectableObservable; 678 | 679 | retry(retryCount: ?number): rxjs$Observable; 680 | 681 | retryWhen( 682 | notifier: (errors: rxjs$Observable) => rxjs$Observable 683 | ): rxjs$Observable; 684 | 685 | scan(f: (acc: U, value: T) => U, initialValue: U): rxjs$Observable; 686 | 687 | share(): rxjs$Observable; 688 | 689 | skip(count: number): rxjs$Observable; 690 | 691 | skipUntil(other: rxjs$Observable | Promise): rxjs$Observable; 692 | 693 | skipWhile( 694 | predicate: (value: T, index: number) => boolean 695 | ): rxjs$Observable; 696 | 697 | startWith(...values: Array): rxjs$Observable; 698 | 699 | subscribeOn(scheduler: rxjs$SchedulerClass): rxjs$Observable; 700 | 701 | take(count: number): rxjs$Observable; 702 | 703 | takeUntil(other: rxjs$Observable): rxjs$Observable; 704 | 705 | takeWhile( 706 | predicate: (value: T, index: number) => boolean 707 | ): rxjs$Observable; 708 | 709 | do( 710 | onNext?: (value: T) => mixed, 711 | onError?: (error: any) => mixed, 712 | onCompleted?: () => mixed 713 | ): rxjs$Observable; 714 | do(observer: { 715 | next?: (value: T) => mixed, 716 | error?: (error: any) => mixed, 717 | complete?: () => mixed 718 | }): rxjs$Observable; 719 | 720 | throttleTime(duration: number): rxjs$Observable; 721 | 722 | timeout(due: number | Date, _: void): rxjs$Observable; 723 | 724 | timeoutWith( 725 | due: number | Date, 726 | withObservable: rxjs$Observable, 727 | scheduler?: rxjs$SchedulerClass 728 | ): rxjs$Observable; 729 | 730 | toArray(): rxjs$Observable; 731 | 732 | toPromise(): Promise; 733 | 734 | subscribe(observer: rxjs$PartialObserver): rxjs$Subscription; 735 | subscribe( 736 | onNext: ?(value: T) => mixed, 737 | onError: ?(error: any) => mixed, 738 | onCompleted: ?() => mixed 739 | ): rxjs$Subscription; 740 | 741 | static combineLatest( 742 | a: rxjs$Observable, 743 | resultSelector: (a: A) => B 744 | ): rxjs$Observable; 745 | 746 | static combineLatest( 747 | a: rxjs$Observable, 748 | b: rxjs$Observable, 749 | resultSelector: (a: A, b: B) => C 750 | ): rxjs$Observable; 751 | 752 | static combineLatest( 753 | a: rxjs$Observable, 754 | b: rxjs$Observable, 755 | c: rxjs$Observable, 756 | resultSelector: (a: A, b: B, c: C) => D 757 | ): rxjs$Observable; 758 | 759 | static combineLatest( 760 | a: rxjs$Observable, 761 | b: rxjs$Observable, 762 | c: rxjs$Observable, 763 | d: rxjs$Observable, 764 | resultSelector: (a: A, b: B, c: C, d: D) => E 765 | ): rxjs$Observable; 766 | 767 | static combineLatest( 768 | a: rxjs$Observable, 769 | b: rxjs$Observable, 770 | c: rxjs$Observable, 771 | d: rxjs$Observable, 772 | e: rxjs$Observable, 773 | resultSelector: (a: A, b: B, c: C, d: D, e: E) => F 774 | ): rxjs$Observable; 775 | 776 | static combineLatest( 777 | a: rxjs$Observable, 778 | b: rxjs$Observable, 779 | c: rxjs$Observable, 780 | d: rxjs$Observable, 781 | e: rxjs$Observable, 782 | f: rxjs$Observable, 783 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G 784 | ): rxjs$Observable; 785 | 786 | static combineLatest( 787 | a: rxjs$Observable, 788 | b: rxjs$Observable, 789 | c: rxjs$Observable, 790 | d: rxjs$Observable, 791 | e: rxjs$Observable, 792 | f: rxjs$Observable, 793 | g: rxjs$Observable, 794 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 795 | ): rxjs$Observable; 796 | 797 | static combineLatest(a: rxjs$Observable, _: void): rxjs$Observable<[A]>; 798 | 799 | static combineLatest( 800 | a: rxjs$Observable, 801 | b: rxjs$Observable, 802 | _: void 803 | ): rxjs$Observable<[A, B]>; 804 | 805 | static combineLatest( 806 | a: rxjs$Observable, 807 | b: rxjs$Observable, 808 | c: rxjs$Observable, 809 | _: void 810 | ): rxjs$Observable<[A, B, C]>; 811 | 812 | static combineLatest( 813 | a: rxjs$Observable, 814 | b: rxjs$Observable, 815 | c: rxjs$Observable, 816 | d: rxjs$Observable, 817 | _: void 818 | ): rxjs$Observable<[A, B, C, D]>; 819 | 820 | static combineLatest( 821 | a: rxjs$Observable, 822 | b: rxjs$Observable, 823 | c: rxjs$Observable, 824 | d: rxjs$Observable, 825 | e: rxjs$Observable, 826 | _: void 827 | ): rxjs$Observable<[A, B, C, D, E]>; 828 | 829 | static combineLatest( 830 | a: rxjs$Observable, 831 | b: rxjs$Observable, 832 | c: rxjs$Observable, 833 | d: rxjs$Observable, 834 | e: rxjs$Observable, 835 | f: rxjs$Observable, 836 | _: void 837 | ): rxjs$Observable<[A, B, C, D, E, F]>; 838 | 839 | static combineLatest( 840 | a: rxjs$Observable, 841 | b: rxjs$Observable, 842 | c: rxjs$Observable, 843 | d: rxjs$Observable, 844 | e: rxjs$Observable, 845 | f: rxjs$Observable, 846 | g: rxjs$Observable, 847 | _: void 848 | ): rxjs$Observable<[A, B, C, D, E, F, G]>; 849 | 850 | static combineLatest( 851 | a: rxjs$Observable, 852 | b: rxjs$Observable, 853 | c: rxjs$Observable, 854 | d: rxjs$Observable, 855 | e: rxjs$Observable, 856 | f: rxjs$Observable, 857 | g: rxjs$Observable, 858 | h: rxjs$Observable, 859 | _: void 860 | ): rxjs$Observable<[A, B, C, D, E, F, G, H]>; 861 | 862 | combineLatest( 863 | a: rxjs$Observable, 864 | b: rxjs$Observable, 865 | c: rxjs$Observable, 866 | d: rxjs$Observable, 867 | e: rxjs$Observable, 868 | f: rxjs$Observable, 869 | g: rxjs$Observable, 870 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 871 | ): rxjs$Observable; 872 | 873 | combineLatest( 874 | a: rxjs$Observable, 875 | b: rxjs$Observable, 876 | c: rxjs$Observable, 877 | d: rxjs$Observable, 878 | e: rxjs$Observable, 879 | f: rxjs$Observable, 880 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G 881 | ): rxjs$Observable; 882 | 883 | combineLatest( 884 | a: rxjs$Observable, 885 | b: rxjs$Observable, 886 | c: rxjs$Observable, 887 | d: rxjs$Observable, 888 | e: rxjs$Observable, 889 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F 890 | ): rxjs$Observable; 891 | 892 | combineLatest( 893 | a: rxjs$Observable, 894 | b: rxjs$Observable, 895 | c: rxjs$Observable, 896 | d: rxjs$Observable, 897 | resultSelector: (t: T, a: A, b: B, c: C, d: D) => E 898 | ): rxjs$Observable; 899 | 900 | combineLatest( 901 | a: rxjs$Observable, 902 | b: rxjs$Observable, 903 | c: rxjs$Observable, 904 | resultSelector: (t: T, a: A, b: B, c: C) => D 905 | ): rxjs$Observable; 906 | 907 | combineLatest( 908 | a: rxjs$Observable, 909 | b: rxjs$Observable, 910 | resultSelector: (t: T, a: A, b: B) => C 911 | ): rxjs$Observable; 912 | 913 | combineLatest( 914 | a: rxjs$Observable, 915 | resultSelector: (t: T, a: A) => B 916 | ): rxjs$Observable; 917 | 918 | combineLatest( 919 | a: rxjs$Observable, 920 | b: rxjs$Observable, 921 | c: rxjs$Observable, 922 | d: rxjs$Observable, 923 | e: rxjs$Observable, 924 | f: rxjs$Observable, 925 | g: rxjs$Observable, 926 | _: void 927 | ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>; 928 | 929 | combineLatest( 930 | a: rxjs$Observable, 931 | b: rxjs$Observable, 932 | c: rxjs$Observable, 933 | d: rxjs$Observable, 934 | e: rxjs$Observable, 935 | f: rxjs$Observable, 936 | _: void 937 | ): rxjs$Observable<[T, A, B, C, D, E, F]>; 938 | 939 | combineLatest( 940 | a: rxjs$Observable, 941 | b: rxjs$Observable, 942 | c: rxjs$Observable, 943 | d: rxjs$Observable, 944 | e: rxjs$Observable, 945 | _: void 946 | ): rxjs$Observable<[T, A, B, C, D, E]>; 947 | 948 | combineLatest( 949 | a: rxjs$Observable, 950 | b: rxjs$Observable, 951 | c: rxjs$Observable, 952 | d: rxjs$Observable, 953 | _: void 954 | ): rxjs$Observable<[T, A, B, C, D]>; 955 | 956 | combineLatest( 957 | a: rxjs$Observable, 958 | b: rxjs$Observable, 959 | c: rxjs$Observable, 960 | _: void 961 | ): rxjs$Observable<[T, A, B, C]>; 962 | 963 | combineLatest( 964 | a: rxjs$Observable, 965 | b: rxjs$Observable, 966 | _: void 967 | ): rxjs$Observable<[T, A, B]>; 968 | 969 | combineLatest(a: rxjs$Observable, _: void): rxjs$Observable<[T, A]>; 970 | 971 | static zip( 972 | a: rxjs$Observable, 973 | resultSelector: (a: A) => B 974 | ): rxjs$Observable; 975 | 976 | static zip( 977 | a: rxjs$Observable, 978 | b: rxjs$Observable, 979 | resultSelector: (a: A, b: B) => C 980 | ): rxjs$Observable; 981 | 982 | static zip( 983 | a: rxjs$Observable, 984 | b: rxjs$Observable, 985 | c: rxjs$Observable, 986 | resultSelector: (a: A, b: B, c: C) => D 987 | ): rxjs$Observable; 988 | 989 | static zip( 990 | a: rxjs$Observable, 991 | b: rxjs$Observable, 992 | c: rxjs$Observable, 993 | d: rxjs$Observable, 994 | resultSelector: (a: A, b: B, c: C, d: D) => E 995 | ): rxjs$Observable; 996 | 997 | static zip( 998 | a: rxjs$Observable, 999 | b: rxjs$Observable, 1000 | c: rxjs$Observable, 1001 | d: rxjs$Observable, 1002 | e: rxjs$Observable, 1003 | resultSelector: (a: A, b: B, c: C, d: D, e: E) => F 1004 | ): rxjs$Observable; 1005 | 1006 | static zip( 1007 | a: rxjs$Observable, 1008 | b: rxjs$Observable, 1009 | c: rxjs$Observable, 1010 | d: rxjs$Observable, 1011 | e: rxjs$Observable, 1012 | f: rxjs$Observable, 1013 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G 1014 | ): rxjs$Observable; 1015 | 1016 | static zip( 1017 | a: rxjs$Observable, 1018 | b: rxjs$Observable, 1019 | c: rxjs$Observable, 1020 | d: rxjs$Observable, 1021 | e: rxjs$Observable, 1022 | f: rxjs$Observable, 1023 | g: rxjs$Observable, 1024 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 1025 | ): rxjs$Observable; 1026 | 1027 | static zip(a: rxjs$Observable, _: void): rxjs$Observable<[A]>; 1028 | 1029 | static zip( 1030 | a: rxjs$Observable, 1031 | b: rxjs$Observable, 1032 | _: void 1033 | ): rxjs$Observable<[A, B]>; 1034 | 1035 | static zip( 1036 | a: rxjs$Observable, 1037 | b: rxjs$Observable, 1038 | c: rxjs$Observable, 1039 | _: void 1040 | ): rxjs$Observable<[A, B, C]>; 1041 | 1042 | static zip( 1043 | a: rxjs$Observable, 1044 | b: rxjs$Observable, 1045 | c: rxjs$Observable, 1046 | d: rxjs$Observable, 1047 | _: void 1048 | ): rxjs$Observable<[A, B, C, D]>; 1049 | 1050 | static zip( 1051 | a: rxjs$Observable, 1052 | b: rxjs$Observable, 1053 | c: rxjs$Observable, 1054 | d: rxjs$Observable, 1055 | e: rxjs$Observable, 1056 | _: void 1057 | ): rxjs$Observable<[A, B, C, D, E]>; 1058 | 1059 | static zip( 1060 | a: rxjs$Observable, 1061 | b: rxjs$Observable, 1062 | c: rxjs$Observable, 1063 | d: rxjs$Observable, 1064 | e: rxjs$Observable, 1065 | f: rxjs$Observable, 1066 | _: void 1067 | ): rxjs$Observable<[A, B, C, D, E, F]>; 1068 | 1069 | static zip( 1070 | a: rxjs$Observable, 1071 | b: rxjs$Observable, 1072 | c: rxjs$Observable, 1073 | d: rxjs$Observable, 1074 | e: rxjs$Observable, 1075 | f: rxjs$Observable, 1076 | g: rxjs$Observable, 1077 | _: void 1078 | ): rxjs$Observable<[A, B, C, D, E, F, G]>; 1079 | 1080 | static zip( 1081 | a: rxjs$Observable, 1082 | b: rxjs$Observable, 1083 | c: rxjs$Observable, 1084 | d: rxjs$Observable, 1085 | e: rxjs$Observable, 1086 | f: rxjs$Observable, 1087 | g: rxjs$Observable, 1088 | h: rxjs$Observable, 1089 | _: void 1090 | ): rxjs$Observable<[A, B, C, D, E, F, G, H]>; 1091 | 1092 | zip( 1093 | a: rxjs$Observable, 1094 | b: rxjs$Observable, 1095 | c: rxjs$Observable, 1096 | d: rxjs$Observable, 1097 | e: rxjs$Observable, 1098 | f: rxjs$Observable, 1099 | g: rxjs$Observable, 1100 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 1101 | ): rxjs$Observable; 1102 | 1103 | zip( 1104 | a: rxjs$Observable, 1105 | b: rxjs$Observable, 1106 | c: rxjs$Observable, 1107 | d: rxjs$Observable, 1108 | e: rxjs$Observable, 1109 | f: rxjs$Observable, 1110 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G 1111 | ): rxjs$Observable; 1112 | 1113 | zip( 1114 | a: rxjs$Observable, 1115 | b: rxjs$Observable, 1116 | c: rxjs$Observable, 1117 | d: rxjs$Observable, 1118 | e: rxjs$Observable, 1119 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F 1120 | ): rxjs$Observable; 1121 | 1122 | zip( 1123 | a: rxjs$Observable, 1124 | b: rxjs$Observable, 1125 | c: rxjs$Observable, 1126 | d: rxjs$Observable, 1127 | resultSelector: (t: T, a: A, b: B, c: C, d: D) => E 1128 | ): rxjs$Observable; 1129 | 1130 | zip( 1131 | a: rxjs$Observable, 1132 | b: rxjs$Observable, 1133 | c: rxjs$Observable, 1134 | resultSelector: (t: T, a: A, b: B, c: C) => D 1135 | ): rxjs$Observable; 1136 | 1137 | zip( 1138 | a: rxjs$Observable, 1139 | b: rxjs$Observable, 1140 | resultSelector: (t: T, a: A, b: B) => C 1141 | ): rxjs$Observable; 1142 | 1143 | zip( 1144 | a: rxjs$Observable, 1145 | resultSelector: (t: T, a: A) => B 1146 | ): rxjs$Observable; 1147 | 1148 | zip( 1149 | a: rxjs$Observable, 1150 | b: rxjs$Observable, 1151 | c: rxjs$Observable, 1152 | d: rxjs$Observable, 1153 | e: rxjs$Observable, 1154 | f: rxjs$Observable, 1155 | g: rxjs$Observable, 1156 | _: void 1157 | ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>; 1158 | 1159 | zip( 1160 | a: rxjs$Observable, 1161 | b: rxjs$Observable, 1162 | c: rxjs$Observable, 1163 | d: rxjs$Observable, 1164 | e: rxjs$Observable, 1165 | f: rxjs$Observable, 1166 | _: void 1167 | ): rxjs$Observable<[T, A, B, C, D, E, F]>; 1168 | 1169 | zip( 1170 | a: rxjs$Observable, 1171 | b: rxjs$Observable, 1172 | c: rxjs$Observable, 1173 | d: rxjs$Observable, 1174 | e: rxjs$Observable, 1175 | _: void 1176 | ): rxjs$Observable<[T, A, B, C, D, E]>; 1177 | 1178 | zip( 1179 | a: rxjs$Observable, 1180 | b: rxjs$Observable, 1181 | c: rxjs$Observable, 1182 | d: rxjs$Observable, 1183 | _: void 1184 | ): rxjs$Observable<[T, A, B, C, D]>; 1185 | 1186 | zip( 1187 | a: rxjs$Observable, 1188 | b: rxjs$Observable, 1189 | c: rxjs$Observable, 1190 | _: void 1191 | ): rxjs$Observable<[T, A, B, C]>; 1192 | 1193 | zip( 1194 | a: rxjs$Observable, 1195 | b: rxjs$Observable, 1196 | _: void 1197 | ): rxjs$Observable<[T, A, B]>; 1198 | 1199 | zip(a: rxjs$Observable, _: void): rxjs$Observable<[T, A]>; 1200 | 1201 | static forkJoin( 1202 | a: rxjs$Observable, 1203 | resultSelector: (a: A) => B 1204 | ): rxjs$Observable; 1205 | 1206 | static forkJoin( 1207 | a: rxjs$Observable, 1208 | b: rxjs$Observable, 1209 | resultSelector: (a: A, b: B) => C 1210 | ): rxjs$Observable; 1211 | 1212 | static forkJoin( 1213 | a: rxjs$Observable, 1214 | b: rxjs$Observable, 1215 | c: rxjs$Observable, 1216 | resultSelector: (a: A, b: B, c: C) => D 1217 | ): rxjs$Observable; 1218 | 1219 | static forkJoin( 1220 | a: rxjs$Observable, 1221 | b: rxjs$Observable, 1222 | c: rxjs$Observable, 1223 | d: rxjs$Observable, 1224 | resultSelector: (a: A, b: B, c: C, d: D) => E 1225 | ): rxjs$Observable; 1226 | 1227 | static forkJoin( 1228 | a: rxjs$Observable, 1229 | b: rxjs$Observable, 1230 | c: rxjs$Observable, 1231 | d: rxjs$Observable, 1232 | e: rxjs$Observable, 1233 | resultSelector: (a: A, b: B, c: C, d: D, e: E) => F 1234 | ): rxjs$Observable; 1235 | 1236 | static forkJoin( 1237 | a: rxjs$Observable, 1238 | b: rxjs$Observable, 1239 | c: rxjs$Observable, 1240 | d: rxjs$Observable, 1241 | e: rxjs$Observable, 1242 | f: rxjs$Observable, 1243 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F) => G 1244 | ): rxjs$Observable; 1245 | 1246 | static forkJoin( 1247 | a: rxjs$Observable, 1248 | b: rxjs$Observable, 1249 | c: rxjs$Observable, 1250 | d: rxjs$Observable, 1251 | e: rxjs$Observable, 1252 | f: rxjs$Observable, 1253 | g: rxjs$Observable, 1254 | resultSelector: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 1255 | ): rxjs$Observable; 1256 | 1257 | static forkJoin( 1258 | a: rxjs$Observable, 1259 | b: rxjs$Observable, 1260 | _: void 1261 | ): rxjs$Observable<[A, B]>; 1262 | 1263 | static forkJoin( 1264 | a: rxjs$Observable, 1265 | b: rxjs$Observable, 1266 | c: rxjs$Observable, 1267 | _: void 1268 | ): rxjs$Observable<[A, B, C]>; 1269 | 1270 | static forkJoin( 1271 | a: rxjs$Observable, 1272 | b: rxjs$Observable, 1273 | c: rxjs$Observable, 1274 | d: rxjs$Observable, 1275 | _: void 1276 | ): rxjs$Observable<[A, B, C, D]>; 1277 | 1278 | static forkJoin( 1279 | a: rxjs$Observable, 1280 | b: rxjs$Observable, 1281 | c: rxjs$Observable, 1282 | d: rxjs$Observable, 1283 | e: rxjs$Observable, 1284 | _: void 1285 | ): rxjs$Observable<[A, B, C, D, E]>; 1286 | 1287 | static forkJoin( 1288 | a: rxjs$Observable, 1289 | b: rxjs$Observable, 1290 | c: rxjs$Observable, 1291 | d: rxjs$Observable, 1292 | e: rxjs$Observable, 1293 | f: rxjs$Observable, 1294 | _: void 1295 | ): rxjs$Observable<[A, B, C, D, E, F]>; 1296 | 1297 | static forkJoin( 1298 | a: rxjs$Observable, 1299 | b: rxjs$Observable, 1300 | c: rxjs$Observable, 1301 | d: rxjs$Observable, 1302 | e: rxjs$Observable, 1303 | f: rxjs$Observable, 1304 | g: rxjs$Observable, 1305 | _: void 1306 | ): rxjs$Observable<[A, B, C, D, E, F, G]>; 1307 | 1308 | static forkJoin( 1309 | a: rxjs$Observable, 1310 | b: rxjs$Observable, 1311 | c: rxjs$Observable, 1312 | d: rxjs$Observable, 1313 | e: rxjs$Observable, 1314 | f: rxjs$Observable, 1315 | g: rxjs$Observable, 1316 | h: rxjs$Observable, 1317 | _: void 1318 | ): rxjs$Observable<[A, B, C, D, E, F, G, H]>; 1319 | 1320 | static forkJoin( 1321 | a: Array>, 1322 | _: void 1323 | ): rxjs$Observable>; 1324 | 1325 | static forkJoin( 1326 | a: Array>, 1327 | _: void 1328 | ): rxjs$Observable; 1329 | 1330 | static forkJoin( 1331 | a: Array>, 1332 | resultSelector: (...values: Array) => B 1333 | ): rxjs$Observable; 1334 | 1335 | static forkJoin( 1336 | a: Array>, 1337 | resultSelector: (...values: Array) => A 1338 | ): rxjs$Observable; 1339 | 1340 | window( 1341 | windowBoundaries: rxjs$Observable 1342 | ): rxjs$Observable>; 1343 | windowCount( 1344 | windowSize: number, 1345 | startWindowEvery?: number 1346 | ): rxjs$Observable>; 1347 | windowToggle( 1348 | openings: rxjs$Observable, 1349 | closingSelector: (value: A) => rxjs$Observable 1350 | ): rxjs$Observable>; 1351 | windowWhen( 1352 | closingSelector: () => rxjs$Observable 1353 | ): rxjs$Observable>; 1354 | 1355 | withLatestFrom( 1356 | a: rxjs$Observable, 1357 | b: rxjs$Observable, 1358 | c: rxjs$Observable, 1359 | d: rxjs$Observable, 1360 | e: rxjs$Observable, 1361 | f: rxjs$Observable, 1362 | g: rxjs$Observable, 1363 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F, g: G) => H 1364 | ): rxjs$Observable; 1365 | 1366 | withLatestFrom( 1367 | a: rxjs$Observable, 1368 | b: rxjs$Observable, 1369 | c: rxjs$Observable, 1370 | d: rxjs$Observable, 1371 | e: rxjs$Observable, 1372 | f: rxjs$Observable, 1373 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E, f: F) => G 1374 | ): rxjs$Observable; 1375 | 1376 | withLatestFrom( 1377 | a: rxjs$Observable, 1378 | b: rxjs$Observable, 1379 | c: rxjs$Observable, 1380 | d: rxjs$Observable, 1381 | e: rxjs$Observable, 1382 | resultSelector: (t: T, a: A, b: B, c: C, d: D, e: E) => F 1383 | ): rxjs$Observable; 1384 | 1385 | withLatestFrom( 1386 | a: rxjs$Observable, 1387 | b: rxjs$Observable, 1388 | c: rxjs$Observable, 1389 | d: rxjs$Observable, 1390 | resultSelector: (t: T, a: A, b: B, c: C, d: D) => E 1391 | ): rxjs$Observable; 1392 | 1393 | withLatestFrom( 1394 | a: rxjs$Observable, 1395 | b: rxjs$Observable, 1396 | c: rxjs$Observable, 1397 | resultSelector: (t: T, a: A, b: B, c: C) => D 1398 | ): rxjs$Observable; 1399 | 1400 | withLatestFrom( 1401 | a: rxjs$Observable, 1402 | b: rxjs$Observable, 1403 | resultSelector: (t: T, a: A, b: B) => C 1404 | ): rxjs$Observable; 1405 | 1406 | withLatestFrom( 1407 | a: rxjs$Observable, 1408 | resultSelector: (t: T, a: A) => B 1409 | ): rxjs$Observable; 1410 | 1411 | withLatestFrom( 1412 | a: rxjs$Observable, 1413 | b: rxjs$Observable, 1414 | c: rxjs$Observable, 1415 | d: rxjs$Observable, 1416 | e: rxjs$Observable, 1417 | f: rxjs$Observable, 1418 | g: rxjs$Observable, 1419 | _: void 1420 | ): rxjs$Observable<[T, A, B, C, D, E, E, F, G]>; 1421 | 1422 | withLatestFrom( 1423 | a: rxjs$Observable, 1424 | b: rxjs$Observable, 1425 | c: rxjs$Observable, 1426 | d: rxjs$Observable, 1427 | e: rxjs$Observable, 1428 | f: rxjs$Observable, 1429 | _: void 1430 | ): rxjs$Observable<[T, A, B, C, D, E, F]>; 1431 | 1432 | withLatestFrom( 1433 | a: rxjs$Observable, 1434 | b: rxjs$Observable, 1435 | c: rxjs$Observable, 1436 | d: rxjs$Observable, 1437 | e: rxjs$Observable, 1438 | _: void 1439 | ): rxjs$Observable<[T, A, B, C, D, E]>; 1440 | 1441 | withLatestFrom( 1442 | a: rxjs$Observable, 1443 | b: rxjs$Observable, 1444 | c: rxjs$Observable, 1445 | d: rxjs$Observable, 1446 | _: void 1447 | ): rxjs$Observable<[T, A, B, C, D]>; 1448 | 1449 | withLatestFrom( 1450 | a: rxjs$Observable, 1451 | b: rxjs$Observable, 1452 | c: rxjs$Observable, 1453 | _: void 1454 | ): rxjs$Observable<[T, A, B, C]>; 1455 | 1456 | withLatestFrom( 1457 | a: rxjs$Observable, 1458 | b: rxjs$Observable, 1459 | _: void 1460 | ): rxjs$Observable<[T, A, B]>; 1461 | 1462 | withLatestFrom(a: rxjs$Observable, _: void): rxjs$Observable<[T, A]>; 1463 | 1464 | static using( 1465 | resourceFactory: () => ?R, 1466 | observableFactory: (resource: R) => rxjs$Observable | Promise | void 1467 | ): rxjs$Observable; 1468 | 1469 | _subscribe(observer: rxjs$Subscriber): rxjs$Subscription; 1470 | 1471 | _isScalar: boolean; 1472 | source: ?rxjs$Observable; 1473 | operator: ?rxjs$Operator; 1474 | } 1475 | 1476 | declare class rxjs$ConnectableObservable extends rxjs$Observable { 1477 | connect(): rxjs$Subscription; 1478 | refCount(): rxjs$Observable; 1479 | } 1480 | 1481 | declare class rxjs$GroupedObservable extends rxjs$Observable { 1482 | key: K; 1483 | } 1484 | 1485 | declare class rxjs$Observer { 1486 | next(value: T): mixed; 1487 | 1488 | error(error: any): mixed; 1489 | 1490 | complete(): mixed; 1491 | } 1492 | 1493 | declare interface rxjs$Operator { 1494 | call(subscriber: rxjs$Subscriber, source: any): rxjs$TeardownLogic; 1495 | } 1496 | 1497 | // FIXME(samgoldman) should be `mixins rxjs$Observable, rxjs$Observer` 1498 | // once Babel parsing support exists: https://phabricator.babeljs.io/T6821 1499 | declare class rxjs$Subject extends rxjs$Observable { 1500 | asObservable(): rxjs$Observable; 1501 | 1502 | observers: Array>; 1503 | 1504 | unsubscribe(): void; 1505 | 1506 | // Copied from rxjs$Observer 1507 | next(value: T): mixed; 1508 | error(error: any): mixed; 1509 | complete(): mixed; 1510 | 1511 | // For use in subclasses only: 1512 | _next(value: T): void; 1513 | } 1514 | 1515 | declare class rxjs$AnonymousSubject extends rxjs$Subject { 1516 | source: ?rxjs$Observable; 1517 | destination: ?rxjs$Observer; 1518 | 1519 | constructor( 1520 | destination?: rxjs$IObserver, 1521 | source?: rxjs$Observable 1522 | ): void; 1523 | next(value: T): void; 1524 | error(err: any): void; 1525 | complete(): void; 1526 | } 1527 | 1528 | declare class rxjs$BehaviorSubject extends rxjs$Subject { 1529 | constructor(initialValue: T): void; 1530 | 1531 | getValue(): T; 1532 | } 1533 | 1534 | declare class rxjs$ReplaySubject extends rxjs$Subject { 1535 | constructor( 1536 | bufferSize?: number, 1537 | windowTime?: number, 1538 | scheduler?: rxjs$SchedulerClass 1539 | ): void; 1540 | } 1541 | 1542 | declare class rxjs$Subscription { 1543 | unsubscribe(): void; 1544 | add(teardown: rxjs$TeardownLogic): rxjs$Subscription; 1545 | } 1546 | 1547 | declare class rxjs$Subscriber extends rxjs$Subscription { 1548 | static create( 1549 | next?: (x?: T) => void, 1550 | error?: (e?: any) => void, 1551 | complete?: () => void 1552 | ): rxjs$Subscriber; 1553 | 1554 | constructor( 1555 | destinationOrNext?: rxjs$PartialObserver | ((value: T) => void), 1556 | error?: (e?: any) => void, 1557 | complete?: () => void 1558 | ): void; 1559 | next(value?: T): void; 1560 | error(err?: any): void; 1561 | complete(): void; 1562 | unsubscribe(): void; 1563 | } 1564 | 1565 | declare class rxjs$SchedulerClass { 1566 | schedule( 1567 | work: (state?: T) => void, 1568 | delay?: number, 1569 | state?: T 1570 | ): rxjs$Subscription; 1571 | } 1572 | 1573 | declare class rxjs$TimeoutError extends Error {} 1574 | 1575 | declare module "rxjs" { 1576 | declare module.exports: { 1577 | Observable: typeof rxjs$Observable, 1578 | Observer: typeof rxjs$Observer, 1579 | ConnectableObservable: typeof rxjs$ConnectableObservable, 1580 | Subject: typeof rxjs$Subject, 1581 | Subscriber: typeof rxjs$Subscriber, 1582 | AnonymousSubject: typeof rxjs$AnonymousSubject, 1583 | BehaviorSubject: typeof rxjs$BehaviorSubject, 1584 | ReplaySubject: typeof rxjs$ReplaySubject, 1585 | Scheduler: { 1586 | asap: rxjs$SchedulerClass, 1587 | queue: rxjs$SchedulerClass, 1588 | animationFrame: rxjs$SchedulerClass, 1589 | async: rxjs$SchedulerClass 1590 | }, 1591 | Subscription: typeof rxjs$Subscription, 1592 | TimeoutError: typeof rxjs$TimeoutError 1593 | }; 1594 | } 1595 | 1596 | declare module "rxjs/Observable" { 1597 | declare module.exports: { 1598 | Observable: typeof rxjs$Observable 1599 | }; 1600 | } 1601 | 1602 | declare module "rxjs/Observer" { 1603 | declare module.exports: { 1604 | Observer: typeof rxjs$Observer 1605 | }; 1606 | } 1607 | 1608 | declare module "rxjs/BehaviorSubject" { 1609 | declare module.exports: { 1610 | BehaviorSubject: typeof rxjs$BehaviorSubject 1611 | }; 1612 | } 1613 | 1614 | declare module "rxjs/ReplaySubject" { 1615 | declare module.exports: { 1616 | ReplaySubject: typeof rxjs$ReplaySubject 1617 | }; 1618 | } 1619 | 1620 | declare module "rxjs/Subject" { 1621 | declare module.exports: { 1622 | Subject: typeof rxjs$Subject, 1623 | AnonymousSubject: typeof rxjs$AnonymousSubject 1624 | }; 1625 | } 1626 | 1627 | declare module "rxjs/Subscriber" { 1628 | declare module.exports: { 1629 | Subscriber: typeof rxjs$Subscriber 1630 | }; 1631 | } 1632 | 1633 | declare module "rxjs/Subscription" { 1634 | declare module.exports: { 1635 | Subscription: typeof rxjs$Subscription 1636 | }; 1637 | } 1638 | 1639 | declare module "rxjs/testing/TestScheduler" { 1640 | declare module.exports: { 1641 | TestScheduler: typeof rxjs$SchedulerClass 1642 | }; 1643 | } 1644 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "typed-actions", 3 | "version": "0.12.0", 4 | "description": "Typed actions for redux", 5 | "main": "index.js", 6 | "types": "./index.d.ts", 7 | "repository": { 8 | "type": "git", 9 | "url": "git+https://github.com/lttb/typed-actions.git" 10 | }, 11 | "author": "", 12 | "license": "MIT", 13 | "bugs": { 14 | "url": "https://github.com/lttb/typed-actions/issues" 15 | }, 16 | "homepage": "https://github.com/lttb/typed-actions#readme", 17 | "scripts": { 18 | "clean": "rimraf lib", 19 | "prebuild": "npm run clean", 20 | "build": "BABEL_ENV=production babel src --ignore '**/tests/**' --out-dir lib", 21 | "postbuild": "npm run cp:flow && npm run cp:meta && npm run cp:d.ts", 22 | "cp:meta": "copyfiles -e '**/tests/**' package.json README.md LICENSE 'src/.*' -a -f lib", 23 | "cp:d.ts": "copyfiles -e '**/tests/**' dts/*.d.ts -f lib/.", 24 | "cp:flow": "flow-copy-source -i '**/tests/*' src lib", 25 | "lint": "npm run lint:eslint && npm run lint:flow && npm run lint:typescript", 26 | "lint:eslint": "eslint .", 27 | "lint:flow": "flow check --include-warnings --show-all-errors --max-warnings 0", 28 | "lint:typescript": "tsc", 29 | "preversion": "npm run lint", 30 | "version": "npm run build", 31 | "postversion": "git push --follow-tags && npm publish lib", 32 | "precommit": "npm run lint:flow && lint-staged" 33 | }, 34 | "lint-staged": { 35 | "*.js": "eslint" 36 | }, 37 | "devDependencies": { 38 | "@babel/cli": "^7.14.8", 39 | "@babel/core": "^7.14.8", 40 | "@babel/plugin-transform-runtime": "^7.14.5", 41 | "@babel/preset-env": "^7.14.8", 42 | "@babel/preset-flow": "^7.14.5", 43 | "babel-eslint": "^10.1.0", 44 | "copyfiles": "^2.4.1", 45 | "eslint": "^5.16.0", 46 | "eslint-config-airbnb-base": "^13.2.0", 47 | "eslint-plugin-flowtype": "^3.13.0", 48 | "eslint-plugin-import": "2.14.0", 49 | "flow-bin": "^0.83.0", 50 | "flow-copy-source": "^2.0.9", 51 | "flow-typed": "^3.8.0", 52 | "husky": "^1.3.1", 53 | "immer": "9.0.6", 54 | "lint-staged": "^7.3.0", 55 | "typescript": "^4.3.5" 56 | }, 57 | "dependencies": { 58 | "@types/redux-actions": "^2.6.2", 59 | "redux-actions": "^2.6.5" 60 | }, 61 | "optionalDependencies": { 62 | "immer": ">= 1.0.0", 63 | "rxjs": ">= 5.5.0" 64 | }, 65 | "engines": { 66 | "node": ">=12" 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/actions/index.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import type { Actions } from '../types' 4 | 5 | const entries 6 | : (T) => $TupleMap<$Keys, (V) => [V, $ElementType]> 7 | = (Object.entries: any) 8 | 9 | const { assign } = Object 10 | 11 | export const createActions 12 | : (A) => Actions 13 | = actions => entries(actions).reduce((acc, [type, actionCreator]) => ({ 14 | ...acc, 15 | [type]: (...args) => assign({ type }, actionCreator(...args)), 16 | }), {}) 17 | 18 | export const empty 19 | : (void) => void 20 | = () => undefined 21 | 22 | /* eslint-disable no-redeclare */ 23 | declare function actionResult

([P]): {|payload: P|} 24 | declare function actionResult([P, M]): {|payload: P, meta: M|} 25 | 26 | declare function action(...args: T): $Call 27 | 28 | export function action(payload, meta) { 29 | return (meta !== undefined ? { payload, meta } : { payload }) 30 | } 31 | 32 | declare function errorResult

([P]): {|payload: P, error: true|} 33 | declare function errorResult([P, M]): {|payload: P, error: true, meta: M|} 34 | 35 | declare function error(...args: T): $Call 36 | 37 | export function error(payload, meta) { 38 | return (meta !== undefined ? { payload, error: true, meta } : { payload, error: true }) 39 | } 40 | /* eslint-enable no-redeclare */ 41 | -------------------------------------------------------------------------------- /src/immer.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import produce from 'immer' 4 | 5 | import type { Reducer } from 'redux-actions' 6 | 7 | import type { SafeExact, InnerFrozen, Frozen } from './types' 8 | 9 | type MapReducer = ( 10 | (...args: any[]) => ActionType 11 | ) => (S, ActionType, $Call) => (void | S) 12 | 13 | type Handlers = $Shape<$ObjMap>>> 14 | 15 | /** 16 | * There is an issue with imports ordering. 17 | * 18 | * When you export types A and B (that uses A), if you'll import type B before the A, 19 | * there will be some strange issues in some cases. 20 | * 21 | * This way we 'bound' the type declared in file to force flow use the correct type. 22 | * 23 | * TODO: (@lttb) need to open a @flowtype issue with a simple example. 24 | */ 25 | type _Handlers = Handlers 26 | export type { _Handlers as Handlers } 27 | 28 | 29 | /* eslint-disable no-redeclare */ 30 | declare function handleActions( 31 | _Handlers, 32 | ?(S | {||}) 33 | ): Reducer((...args: T) => R) => Frozen>>> 34 | 35 | export function handleActions(handlers, defaultState = {}) { 36 | return (state = defaultState, action) => produce(state, (draft) => { 37 | if (!handlers[action.type]) return undefined 38 | 39 | return handlers[action.type](draft, action, state) 40 | }) 41 | } 42 | /* eslint-enable no-redeclare */ 43 | -------------------------------------------------------------------------------- /src/index.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import type { Reducer } from 'redux-actions' 4 | import baseHandleActions from 'redux-actions/lib/handleActions' 5 | import type { InnerFrozen, Frozen } from './types' 6 | 7 | export * from './types' 8 | export * from './actions' 9 | 10 | type MapReducer = ((...args: any) => A) => (S, {...$Exact>}) => S 11 | 12 | type Handlers = $Shape<$ObjMap>>> 13 | 14 | /** 15 | * There is an issue with imports ordering. 16 | * 17 | * When you export types A and B (that uses A), if you'll import type B before the A, 18 | * there will be some strange issues in some cases. 19 | * 20 | * This way we 'bound' the type declared in file to force flow use the correct type. 21 | * 22 | * TODO: (@lttb) need to open a @flowtype issue with a simple example. 23 | */ 24 | type _Handlers = Handlers 25 | export type { _Handlers as Handlers } 26 | 27 | 28 | /* eslint-disable no-redeclare */ 29 | declare function handleActions( 30 | _Handlers, 31 | ?(S | {||}), 32 | ): Reducer((...args: T) => R) => Frozen>>> 33 | 34 | export function handleActions(handlers, defaultState = {}) { 35 | return baseHandleActions(handlers, defaultState) 36 | } 37 | /* eslint-enable no-redeclare */ 38 | -------------------------------------------------------------------------------- /src/redux-observable/index.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | /* eslint-disable import/no-unresolved, import/extensions */ 4 | 5 | import type { Observable } from 'rxjs/Observable' 6 | 7 | interface ActionObservable extends Observable { 8 | ofType: >(...args: T[]) => ActionObservable< 9 | Actions, 10 | /** 11 | * Make Actions flatten by $Exact trick for the better readability in epics 12 | */ 13 | $ElementType<$ObjMap(T => R) => $Exact<{...$Exact}>>, T> 14 | >; 15 | } 16 | 17 | export type Epic = ( 18 | action$: ActionObservable, 19 | store: {getState(): S}, 20 | dependencies: D, 21 | ) => Observable<*>; 22 | -------------------------------------------------------------------------------- /src/tests/actions.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import { 4 | createActions, 5 | action, 6 | empty, 7 | error, 8 | } from '..' 9 | 10 | import type { A, B } from './types' 11 | 12 | let actions 13 | 14 | export const TEST = '@namespace/TEST' 15 | export const INIT = '@namespace/INIT' 16 | export const UPDATE = '@namespace/UPDATE' 17 | export const UNION = '@namespace/UNION' 18 | export const INTER = '@namespace/INTER' 19 | export const ARITY2 = '@namespace/ARITY2' 20 | export const ARITY3 = '@namespace/ARITY3' 21 | export const ERROR = '@namespace/ERROR' 22 | export const ERROR_META = '@namespace/ERROR_META' 23 | 24 | export const OPAQUE_ARITY3 = '@hoho/OPAQUE_ARITY3' 25 | 26 | type T = {x: number} 27 | 28 | export const { 29 | [TEST]: test, 30 | [INIT]: init, 31 | [UPDATE]: update, 32 | [UNION]: union, 33 | [INTER]: inter, 34 | [ARITY2]: arity2, 35 | [ARITY3]: arity3, 36 | [ERROR]: errorAction, 37 | [ERROR_META]: errorMetaAction, 38 | [OPAQUE_ARITY3]: opaqueArity3, 39 | } = actions = createActions({ 40 | [TEST]: (x: {data: {nestedData: string}}) => action(x), 41 | [INIT]: empty, 42 | [UPDATE]: (x: ?string) => action(x), 43 | [UNION]: (x: string | number | boolean) => action(x), 44 | [INTER]: (x: ($Exact<{a: 1, b: 1}>) | $Exact<{x: 1}>) => action(x), 45 | [ARITY2]: (x: boolean, y: boolean) => action(x && y), 46 | [ARITY3]: (x: boolean, y: T, z: string) => action({ x, y, z }), 47 | [ERROR]: (x: string) => error(x), 48 | [ERROR_META]: (x: string) => error(x, { someData: true }), 49 | [OPAQUE_ARITY3]: ( 50 | a: A, 51 | b: B, 52 | c: number, 53 | ) => action({ a, b, c }), 54 | }) 55 | 56 | export type Actions = typeof actions 57 | -------------------------------------------------------------------------------- /src/tests/actions.test.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import { 4 | init, 5 | test, 6 | update, 7 | union, 8 | inter, 9 | arity2, 10 | arity3, 11 | errorAction, 12 | errorMetaAction, 13 | opaqueArity3, 14 | type Actions, 15 | } from './actions' 16 | 17 | import type { A, B } from './types' 18 | import type { ActionOf, ActionsOf } from '..' 19 | 20 | (() => { 21 | /** 22 | * Check 23 | */ 24 | type Action = ActionsOf 25 | type InitAction = ActionOf 26 | type ErrorAction = ActionOf 27 | 28 | const initAction = init(); 29 | (initAction: InitAction); 30 | (initAction: Action); 31 | 32 | /** 33 | * $ExpectError 34 | * 35 | * Incompatible type 36 | */ 37 | (initAction: ErrorAction); 38 | 39 | /** 40 | * It should work with the correct type 41 | */ 42 | ({ type: '@namespace/ERROR', payload: 'x', error: true }: Action); 43 | 44 | /** 45 | * $ExpectError 46 | * 47 | * Incompatible type 48 | */ 49 | ({ type: '@namespace/ERROR', payload: 1, error: true }: Action) 50 | })() 51 | 52 | { 53 | declare var a: A 54 | declare var b: B 55 | 56 | /** 57 | * It should not have errors 58 | */ 59 | const x = opaqueArity3(a, b, 100); 60 | 61 | (x.payload: { 62 | a: A, 63 | b: B, 64 | c: number 65 | }); 66 | 67 | /** 68 | * $ExpectError 69 | * 70 | * It should error with opaque type A 71 | */ 72 | (x.payload: { 73 | a: string, 74 | b: B, 75 | c: number 76 | }) 77 | } 78 | 79 | /** 80 | * ActionCreator interface tests 81 | */ 82 | 83 | arity2(true, false) 84 | /** 85 | * $ExpectError 86 | * 87 | * Incompatible arguments type 88 | */ 89 | arity2('true', 'false') 90 | 91 | arity3(true, { x: 1 }, 'x') 92 | 93 | /** 94 | * $ExpectError 95 | * 96 | * Incompatible arguments type 97 | */ 98 | arity3('true', 'false', 'true') 99 | 100 | inter({ a: 1, b: 1 }) 101 | inter({ x: 1 }) 102 | /** 103 | * $ExpectError 104 | * 105 | * Incompatible argument type 106 | */ 107 | inter({ a: 1, b: 1, x: 1 }) 108 | 109 | union(1) 110 | union('1') 111 | union(true) 112 | /** 113 | * $ExpectError 114 | * 115 | * Incompatible argument type 116 | */ 117 | union() 118 | /** 119 | * $ExpectError 120 | * 121 | * Incompatible argument type 122 | */ 123 | union(null) 124 | /** 125 | * $ExpectError 126 | * 127 | * Incompatible argument type 128 | */ 129 | union({ _: {} }) 130 | 131 | init() 132 | init(undefined) 133 | /** 134 | * $ExpectError 135 | * 136 | * Incompatible argument type 137 | */ 138 | init(null) 139 | 140 | test({ data: { nestedData: 'test' } }) 141 | /** 142 | * $ExpectError 143 | * 144 | * Incompatible argument type 145 | */ 146 | test({ data: { nestedData: 1 } }) 147 | /** 148 | * $ExpectError 149 | * 150 | * Incompatible argument type 151 | */ 152 | test({ data: {} }) 153 | 154 | 155 | update('test') 156 | /** 157 | * $ExpectError 158 | * 159 | * Incompatible argument type 160 | */ 161 | update(1) 162 | 163 | { 164 | /** 165 | * $ExpectError 166 | * 167 | * Incompatible argument type 168 | */ 169 | errorAction(1) 170 | 171 | /** 172 | * $ExpectError 173 | * 174 | * Incompatible argument type 175 | */ 176 | errorMetaAction(1) 177 | 178 | 179 | const err = errorAction('test') 180 | const errMeta = errorMetaAction('test'); 181 | 182 | (err: {error: true, payload: string}); 183 | /** 184 | * $ExpectError 185 | * 186 | * 'error' prop should be true 187 | */ 188 | (err: {error: false, payload: string}); 189 | 190 | (errMeta: {error: true, payload: string, meta: {someData: true}}); 191 | /** 192 | * $ExpectError 193 | * 194 | * 'meta' prop should be {someData: true} 195 | */ 196 | (errMeta: {error: true, payload: string, meta: {someData: false}}) 197 | } 198 | -------------------------------------------------------------------------------- /src/tests/epics.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import { type Epic } from '../redux-observable' 4 | import { type Actions, INIT, UPDATE } from './actions' 5 | import { type State } from './reducers' 6 | 7 | const testEpic 8 | : Epic 9 | = action$ => action$ 10 | .ofType(INIT, UPDATE) 11 | .map((action) => { 12 | if (action.type === INIT) { 13 | /** 14 | * $ExpectError 15 | * 16 | * There is no .payload for INIT action 17 | */ 18 | (action.payload: string) 19 | } else { 20 | /** 21 | * $ExpectError 22 | * 23 | * payload is string 24 | */ 25 | (action.payload: number) 26 | } 27 | 28 | return {} 29 | }) 30 | 31 | export default testEpic 32 | -------------------------------------------------------------------------------- /src/tests/reducers.immer.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | /* eslint-disable no-param-reassign */ 4 | 5 | import { type Handlers, handleActions } from '../immer' 6 | 7 | import { 8 | type Actions, 9 | 10 | INIT, 11 | UPDATE, 12 | } from './actions' 13 | 14 | export type State = { 15 | data: { 16 | nestedData: number, 17 | }, 18 | anotherData: string, 19 | arrayData: $ReadOnlyArray<{test: string}>, 20 | }; 21 | 22 | handleActions(({ 23 | [INIT]: state => state, 24 | 25 | [UPDATE]: (state, { payload }) => { 26 | state.anotherData = payload || '' 27 | }, 28 | }: Handlers)) 29 | 30 | /** 31 | * $ExpectError 32 | * 33 | * Property HEY not found in the Type 34 | */ 35 | handleActions(({ 36 | HEY: state => state, 37 | }: Handlers)) 38 | 39 | handleActions(({ 40 | [UPDATE]: (state, { payload }) => { 41 | /** 42 | * $ExpectError 43 | * 44 | * Incompatible state and payload types 45 | */ 46 | state.data = payload 47 | }, 48 | }: Handlers)) 49 | 50 | const reducer = handleActions(({ 51 | [UPDATE]: (state, { payload }) => { 52 | state.anotherData = payload || '' 53 | }, 54 | }: Handlers)) 55 | 56 | /** 57 | * $ExpectError 58 | * 59 | * Incompatible State Types 60 | */ 61 | reducer({ 62 | data: { 63 | nestedData: 2, 64 | }, 65 | }, { 66 | type: UPDATE, 67 | payload: 'test', 68 | }) 69 | 70 | /** 71 | * $ExpectError 72 | * 73 | * There is no action argument 74 | */ 75 | reducer({ 76 | data: { 77 | nestedData: 2, 78 | }, 79 | anotherData: 'test', 80 | }) 81 | 82 | reducer({ 83 | data: { 84 | nestedData: 2, 85 | }, 86 | anotherData: 'test', 87 | arrayData: [{ test: 'me' }], 88 | }, { 89 | type: UPDATE, 90 | payload: 'test', 91 | }) 92 | 93 | reducer({ 94 | data: { 95 | nestedData: 2, 96 | }, 97 | anotherData: 'test', 98 | arrayData: [{ test: 'me' }], 99 | }, { 100 | type: UPDATE, 101 | /** 102 | * $ExpectError 103 | * 104 | * Incompatible Action Type 105 | */ 106 | payload: 2, 107 | }) 108 | 109 | /** 110 | * It should work with State as a primitive 111 | */ 112 | handleActions(({ 113 | [UPDATE]: state => state, 114 | }: Handlers<'a' | 'b' | '', Actions>), '') 115 | 116 | /** 117 | * It should work with State as an array 118 | */ 119 | handleActions(({ 120 | [UPDATE]: state => state, 121 | }: Handlers<$ReadOnlyArray, Actions>), [1, 2, 3]) 122 | -------------------------------------------------------------------------------- /src/tests/reducers.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import { type Handlers, type Frozen, handleActions } from '..' 4 | 5 | import { 6 | type Actions, 7 | 8 | TEST, 9 | INIT, 10 | UPDATE, 11 | } from './actions' 12 | 13 | export type State = Frozen<{ 14 | data: { 15 | nestedData: number, 16 | }, 17 | anotherData: string, 18 | arrayData: $ReadOnlyArray<{test: string}>, 19 | }>; 20 | 21 | handleActions(({ 22 | [INIT]: state => state, 23 | 24 | [UPDATE]: (state, { payload }) => ({ 25 | ...state, 26 | anotherData: payload || '', 27 | }), 28 | }: Handlers)) 29 | 30 | /** 31 | * $ExpectError 32 | * 33 | * Property HEY not found in the Type 34 | */ 35 | handleActions(({ 36 | HEY: state => state, 37 | }: Handlers)) 38 | 39 | /** 40 | * $ExpectError 41 | * 42 | * Incompatible state and payload types 43 | */ 44 | handleActions(({ 45 | [UPDATE]: (state, { payload }) => ({ 46 | ...state, 47 | data: payload, 48 | }), 49 | }: Handlers)) 50 | 51 | handleActions(({ 52 | [TEST]: (state, action) => { 53 | /* eslint-disable no-param-reassign */ 54 | 55 | /** 56 | * $ExpectError 57 | * 58 | * Deep Immutable State 59 | */ 60 | state.data.nestedData = 1 61 | 62 | /** 63 | * $ExpectError 64 | * 65 | * Deep Immutable action 66 | */ 67 | action.payload.data.nestedData = 'test' 68 | 69 | /** 70 | * $ExpectError 71 | * 72 | * It should keep ReadOnlyArray Type 73 | */ 74 | state.arrayData[0] = { test: 'me' } 75 | 76 | /** 77 | * $ExpectError 78 | * 79 | * Deep Immutable ReadOnlyArray Item 80 | */ 81 | state.arrayData[0].test = 'me' 82 | 83 | /* eslint-enable no-param-reassign */ 84 | 85 | return state 86 | }, 87 | }: Handlers)) 88 | 89 | const reducer = handleActions(({ 90 | [UPDATE]: (state, { payload }) => ({ 91 | ...state, 92 | anotherData: payload || '', 93 | }), 94 | }: Handlers)) 95 | 96 | /** 97 | * $ExpectError 98 | * 99 | * Incompatible State Types 100 | */ 101 | reducer({ 102 | data: { 103 | nestedData: 2, 104 | }, 105 | }, { 106 | type: UPDATE, 107 | payload: 'test', 108 | }) 109 | 110 | /** 111 | * $ExpectError 112 | * 113 | * There is no action argument 114 | */ 115 | reducer({ 116 | data: { 117 | nestedData: 2, 118 | }, 119 | anotherData: 'test', 120 | }) 121 | 122 | reducer({ 123 | data: { 124 | nestedData: 2, 125 | }, 126 | anotherData: 'test', 127 | arrayData: [{ test: 'me' }], 128 | }, { 129 | type: UPDATE, 130 | payload: 'test', 131 | }) 132 | 133 | reducer({ 134 | data: { 135 | nestedData: 2, 136 | }, 137 | anotherData: 'test', 138 | arrayData: [{ test: 'me' }], 139 | }, { 140 | type: UPDATE, 141 | /** 142 | * $ExpectError 143 | * 144 | * Incompatible Action Type 145 | */ 146 | payload: 2, 147 | }) 148 | 149 | /** 150 | * It should work with State as a primitive 151 | */ 152 | handleActions(({ 153 | [UPDATE]: state => state, 154 | }: Handlers<'a' | 'b' | '', Actions>), '') 155 | 156 | /** 157 | * It should work with State as an array 158 | */ 159 | handleActions(({ 160 | [UPDATE]: state => state, 161 | }: Handlers<$ReadOnlyArray, Actions>), [1, 2, 3]) 162 | -------------------------------------------------------------------------------- /src/tests/types.js: -------------------------------------------------------------------------------- 1 | // @flow 2 | 3 | export opaque type A = string; 4 | export opaque type B = string; 5 | -------------------------------------------------------------------------------- /src/types/deprecated.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | export type ArgumentType = ((T) => R) => T & T 4 | export type ReturnType = ((...args: T) => R) => R 5 | -------------------------------------------------------------------------------- /src/types/index.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | export * from './deprecated' 4 | 5 | /* eslint-disable no-use-before-define */ 6 | export type Frozen = $ReadOnly> 7 | type FrozenMapper = $Exact<$ObjMap> 8 | export type InnerFrozen = 9 | & ((V) => $ReadOnly>) 10 | & (>(V) => $TupleMap) 11 | & (>(V) => $TupleMap) 12 | & ((V) => V) 13 | /* eslint-enable no-use-before-define */ 14 | 15 | type Action, Rest> = {|type: T, ...$Exact|} 16 | 17 | /* eslint-disable no-redeclare */ 18 | declare function arguments((A) => any): [A] 19 | declare function arguments((A, B) => any): [A, B] 20 | declare function arguments((A, B, C) => any): [A, B, C] 21 | 22 | export type Arguments = $Call 23 | 24 | /** 25 | * A function to locate errors well after $ObjMap. 26 | * 27 | * @see https://github.com/facebook/flow/issues/5785 28 | */ 29 | 30 | declare function locate(( 31 | A | (B & void), 32 | C | (D & void), 33 | E | (F & void), 34 | ) => R): (( 35 | A | (void & null & empty), 36 | C | (void & null & empty), 37 | E | (void & null & empty), 38 | ) => R) 39 | 40 | declare function locate(( 41 | A | (B & void), 42 | C | (D & void), 43 | ) => R): (( 44 | A | (void & null & empty), 45 | C | (void & null & empty), 46 | ) => R) 47 | 48 | declare function locate(( 49 | A | (B & void), 50 | ) => R): (( 51 | // a hack to get rid of extra unions without type loss 52 | A | (void & null & empty), 53 | ) => R) 54 | 55 | declare function locate( 56 | A => R, 57 | ): (A => R) 58 | /* eslint-enable no-redeclare */ 59 | 60 | export type Actions = $ObjMap<$ObjMapi(K, V) => $Call< 63 | & (((...args: [A, B, C]) => R) => (A, B, C) => Action) 64 | & (((...args: [A, B]) => R) => (A, B) => Action) 65 | & (((...args: [A]) => R) => (A) => Action) 66 | , V>>, typeof locate> 67 | 68 | export type _ActionOf = ((...args: T) => R) => Frozen 69 | export type ActionOf = $Call<_ActionOf, A> 70 | 71 | export type _ActionsOf = (AC) => $Values<$ObjMap> 72 | export type ActionsOf = $Call<_ActionsOf, ActionCollection>; 73 | 74 | export type SafeExact = 75 | & ((V) => $Exact) 76 | & ((V) => V) 77 | -------------------------------------------------------------------------------- /src/weak.js: -------------------------------------------------------------------------------- 1 | /* @flow */ 2 | 3 | import type { Reducer } from 'redux-actions' 4 | import baseHandleActions from 'redux-actions/lib/handleActions' 5 | 6 | export * from './types' 7 | export * from './actions' 8 | 9 | type MapReducer = ((...args: any) => A) => ({...$Exact}, {...$Exact}) => S 10 | 11 | type Handlers = $Shape<$ObjMap>> 12 | 13 | /** 14 | * There is an issue with imports ordering. 15 | * 16 | * When you export types A and B (that uses A), if you'll import type B before the A, 17 | * there will be some strange issues in some cases. 18 | * 19 | * This way we 'bound' the type declared in file to force flow use the correct type. 20 | * 21 | * TODO: (@lttb) need to open a @flowtype issue with a simple example. 22 | */ 23 | type _Handlers = Handlers 24 | export type { _Handlers as Handlers } 25 | 26 | 27 | /* eslint-disable no-redeclare */ 28 | declare function handleActions( 29 | _Handlers, 30 | ?(S | {||}), 31 | ): Reducer((...args: T) => R) => R>>> 32 | 33 | export function handleActions(handlers, defaultState = {}) { 34 | return baseHandleActions(handlers, defaultState) 35 | } 36 | /* eslint-enable no-redeclare */ 37 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "noEmit": true, 4 | "strict": true 5 | } 6 | } 7 | --------------------------------------------------------------------------------