source: trip-planner-front/node_modules/rxjs/internal/observable/generate.d.ts@ 76712b2

Last change on this file since 76712b2 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 8.9 KB
Line 
1import { Observable } from '../Observable';
2import { SchedulerLike } from '../types';
3export declare type ConditionFunc<S> = (state: S) => boolean;
4export declare type IterateFunc<S> = (state: S) => S;
5export declare type ResultFunc<S, T> = (state: S) => T;
6export interface GenerateBaseOptions<S> {
7 /**
8 * Initial state.
9 */
10 initialState: S;
11 /**
12 * Condition function that accepts state and returns boolean.
13 * When it returns false, the generator stops.
14 * If not specified, a generator never stops.
15 */
16 condition?: ConditionFunc<S>;
17 /**
18 * Iterate function that accepts state and returns new state.
19 */
20 iterate: IterateFunc<S>;
21 /**
22 * SchedulerLike to use for generation process.
23 * By default, a generator starts immediately.
24 */
25 scheduler?: SchedulerLike;
26}
27export interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
28 /**
29 * Result selection function that accepts state and returns a value to emit.
30 */
31 resultSelector: ResultFunc<S, T>;
32}
33/**
34 * Generates an observable sequence by running a state-driven loop
35 * producing the sequence's elements, using the specified scheduler
36 * to send out observer messages.
37 *
38 * ![](generate.png)
39 *
40 * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
41 * const res = generate(0, x => x < 10, x => x + 1, x => x);
42 *
43 * @example <caption>Using asap scheduler, produces sequence of 2, 3, 5, then completes.</caption>
44 * const res = generate(1, x => x < 5, x => x * 2, x => x + 1, asap);
45 *
46 * @see {@link from}
47 * @see {@link Observable}
48 *
49 * @param {S} initialState Initial state.
50 * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
51 * @param {function (state: S): S} iterate Iteration step function.
52 * @param {function (state: S): T} resultSelector Selector function for results produced in the sequence. (deprecated)
53 * @param {SchedulerLike} [scheduler] A {@link SchedulerLike} on which to run the generator loop. If not provided, defaults to emit immediately.
54 * @returns {Observable<T>} The generated sequence.
55 */
56export declare function generate<T, S>(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, resultSelector: ResultFunc<S, T>, scheduler?: SchedulerLike): Observable<T>;
57/**
58 * Generates an Observable by running a state-driven loop
59 * that emits an element on each iteration.
60 *
61 * <span class="informal">Use it instead of nexting values in a for loop.</span>
62 *
63 * <img src="./img/generate.png" width="100%">
64 *
65 * `generate` allows you to create stream of values generated with a loop very similar to
66 * traditional for loop. First argument of `generate` is a beginning value. Second argument
67 * is a function that accepts this value and tests if some condition still holds. If it does,
68 * loop continues, if not, it stops. Third value is a function which takes previously defined
69 * value and modifies it in some way on each iteration. Note how these three parameters
70 * are direct equivalents of three expressions in regular for loop: first expression
71 * initializes some state (for example numeric index), second tests if loop can make next
72 * iteration (for example if index is lower than 10) and third states how defined value
73 * will be modified on every step (index will be incremented by one).
74 *
75 * Return value of a `generate` operator is an Observable that on each loop iteration
76 * emits a value. First, condition function is ran. If it returned true, Observable
77 * emits currently stored value (initial value at the first iteration) and then updates
78 * that value with iterate function. If at some point condition returned false, Observable
79 * completes at that moment.
80 *
81 * Optionally you can pass fourth parameter to `generate` - a result selector function which allows you
82 * to immediately map value that would normally be emitted by an Observable.
83 *
84 * If you find three anonymous functions in `generate` call hard to read, you can provide
85 * single object to the operator instead. That object has properties: `initialState`,
86 * `condition`, `iterate` and `resultSelector`, which should have respective values that you
87 * would normally pass to `generate`. `resultSelector` is still optional, but that form
88 * of calling `generate` allows you to omit `condition` as well. If you omit it, that means
89 * condition always holds, so output Observable will never complete.
90 *
91 * Both forms of `generate` can optionally accept a scheduler. In case of multi-parameter call,
92 * scheduler simply comes as a last argument (no matter if there is resultSelector
93 * function or not). In case of single-parameter call, you can provide it as a
94 * `scheduler` property on object passed to the operator. In both cases scheduler decides when
95 * next iteration of the loop will happen and therefore when next value will be emitted
96 * by the Observable. For example to ensure that each value is pushed to the observer
97 * on separate task in event loop, you could use `async` scheduler. Note that
98 * by default (when no scheduler is passed) values are simply emitted synchronously.
99 *
100 *
101 * @example <caption>Use with condition and iterate functions.</caption>
102 * const generated = generate(0, x => x < 3, x => x + 1);
103 *
104 * generated.subscribe(
105 * value => console.log(value),
106 * err => {},
107 * () => console.log('Yo!')
108 * );
109 *
110 * // Logs:
111 * // 0
112 * // 1
113 * // 2
114 * // "Yo!"
115 *
116 *
117 * @example <caption>Use with condition, iterate and resultSelector functions.</caption>
118 * const generated = generate(0, x => x < 3, x => x + 1, x => x * 1000);
119 *
120 * generated.subscribe(
121 * value => console.log(value),
122 * err => {},
123 * () => console.log('Yo!')
124 * );
125 *
126 * // Logs:
127 * // 0
128 * // 1000
129 * // 2000
130 * // "Yo!"
131 *
132 *
133 * @example <caption>Use with options object.</caption>
134 * const generated = generate({
135 * initialState: 0,
136 * condition(value) { return value < 3; },
137 * iterate(value) { return value + 1; },
138 * resultSelector(value) { return value * 1000; }
139 * });
140 *
141 * generated.subscribe(
142 * value => console.log(value),
143 * err => {},
144 * () => console.log('Yo!')
145 * );
146 *
147 * // Logs:
148 * // 0
149 * // 1000
150 * // 2000
151 * // "Yo!"
152 *
153 * @example <caption>Use options object without condition function.</caption>
154 * const generated = generate({
155 * initialState: 0,
156 * iterate(value) { return value + 1; },
157 * resultSelector(value) { return value * 1000; }
158 * });
159 *
160 * generated.subscribe(
161 * value => console.log(value),
162 * err => {},
163 * () => console.log('Yo!') // This will never run.
164 * );
165 *
166 * // Logs:
167 * // 0
168 * // 1000
169 * // 2000
170 * // 3000
171 * // ...and never stops.
172 *
173 *
174 * @see {@link from}
175 * @see {@link index/Observable.create}
176 *
177 * @param {S} initialState Initial state.
178 * @param {function (state: S): boolean} condition Condition to terminate generation (upon returning false).
179 * @param {function (state: S): S} iterate Iteration step function.
180 * @param {function (state: S): T} [resultSelector] Selector function for results produced in the sequence.
181 * @param {Scheduler} [scheduler] A {@link Scheduler} on which to run the generator loop. If not provided, defaults to emitting immediately.
182 * @return {Observable<T>} The generated sequence.
183 */
184export declare function generate<S>(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, scheduler?: SchedulerLike): Observable<S>;
185/**
186 * Generates an observable sequence by running a state-driven loop
187 * producing the sequence's elements, using the specified scheduler
188 * to send out observer messages.
189 * The overload accepts options object that might contain initial state, iterate,
190 * condition and scheduler.
191 *
192 * ![](generate.png)
193 *
194 * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
195 * const res = generate({
196 * initialState: 0,
197 * condition: x => x < 10,
198 * iterate: x => x + 1,
199 * });
200 *
201 * @see {@link from}
202 * @see {@link Observable}
203 *
204 * @param {GenerateBaseOptions<S>} options Object that must contain initialState, iterate and might contain condition and scheduler.
205 * @returns {Observable<S>} The generated sequence.
206 */
207export declare function generate<S>(options: GenerateBaseOptions<S>): Observable<S>;
208/**
209 * Generates an observable sequence by running a state-driven loop
210 * producing the sequence's elements, using the specified scheduler
211 * to send out observer messages.
212 * The overload accepts options object that might contain initial state, iterate,
213 * condition, result selector and scheduler.
214 *
215 * ![](generate.png)
216 *
217 * @example <caption>Produces sequence of 0, 1, 2, ... 9, then completes.</caption>
218 * const res = generate({
219 * initialState: 0,
220 * condition: x => x < 10,
221 * iterate: x => x + 1,
222 * resultSelector: x => x,
223 * });
224 *
225 * @see {@link from}
226 * @see {@link Observable}
227 *
228 * @param {GenerateOptions<T, S>} options Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler.
229 * @returns {Observable<T>} The generated sequence.
230 */
231export declare function generate<T, S>(options: GenerateOptions<T, S>): Observable<T>;
Note: See TracBrowser for help on using the repository browser.