diff options
Diffstat (limited to 'node_modules/rxjs/src/internal/scheduler')
21 files changed, 0 insertions, 960 deletions
diff --git a/node_modules/rxjs/src/internal/scheduler/Action.ts b/node_modules/rxjs/src/internal/scheduler/Action.ts deleted file mode 100644 index a9c543b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/Action.ts +++ /dev/null @@ -1,34 +0,0 @@ -import { Scheduler } from '../Scheduler'; -import { Subscription } from '../Subscription'; -import { SchedulerAction } from '../types'; - -/** - * A unit of work to be executed in a `scheduler`. An action is typically - * created from within a {@link SchedulerLike} and an RxJS user does not need to concern - * themselves about creating and manipulating an Action. - * - * ```ts - * class Action<T> extends Subscription { - * new (scheduler: Scheduler, work: (state?: T) => void); - * schedule(state?: T, delay: number = 0): Subscription; - * } - * ``` - */ -export class Action<T> extends Subscription { - constructor(scheduler: Scheduler, work: (this: SchedulerAction<T>, state?: T) => void) { - super(); - } - /** - * Schedules this action on its parent {@link SchedulerLike} for execution. May be passed - * some context object, `state`. May happen at some point in the future, - * according to the `delay` parameter, if specified. - * @param state Some contextual data that the `work` function uses when called by the - * Scheduler. - * @param delay Time to wait before executing the work, where the time unit is implicit - * and defined by the Scheduler. - * @return A subscription in order to be able to unsubscribe the scheduled work. - */ - public schedule(state?: T, delay: number = 0): Subscription { - return this; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts b/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts deleted file mode 100644 index 502bbc7..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AnimationFrameScheduler } from './AnimationFrameScheduler'; -import { SchedulerAction } from '../types'; -import { animationFrameProvider } from './animationFrameProvider'; -import { TimerHandle } from './timerHandle'; - -export class AnimationFrameAction<T> extends AsyncAction<T> { - constructor(protected scheduler: AnimationFrameScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - protected requestAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay is greater than 0, request as an async action. - if (delay !== null && delay > 0) { - return super.requestAsyncId(scheduler, id, delay); - } - // Push the action to the end of the scheduler queue. - scheduler.actions.push(this); - // If an animation frame has already been requested, don't request another - // one. If an animation frame hasn't been requested yet, request one. Return - // the current animation frame request id. - return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(() => scheduler.flush(undefined))); - } - - protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - if (delay != null ? delay > 0 : this.delay > 0) { - return super.recycleAsyncId(scheduler, id, delay); - } - // If the scheduler queue has no remaining actions with the same async id, - // cancel the requested animation frame and set the scheduled flag to - // undefined so the next AnimationFrameAction will request its own. - const { actions } = scheduler; - if (id != null && id === scheduler._scheduled && actions[actions.length - 1]?.id !== id) { - animationFrameProvider.cancelAnimationFrame(id as number); - scheduler._scheduled = undefined; - } - // Return undefined so the action knows to request a new async id if it's rescheduled. - return undefined; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts deleted file mode 100644 index 1f21ffa..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -export class AnimationFrameScheduler extends AsyncScheduler { - public flush(action?: AsyncAction<any>): void { - this._active = true; - // The async id that effects a call to flush is stored in _scheduled. - // Before executing an action, it's necessary to check the action's async - // id to determine whether it's supposed to be executed in the current - // flush. - // Previous implementations of this method used a count to determine this, - // but that was unsound, as actions that are unsubscribed - i.e. cancelled - - // are removed from the actions array and that can shift actions that are - // scheduled to be executed in a subsequent flush into positions at which - // they are executed within the current flush. - let flushId; - if (action) { - flushId = action.id; - } else { - flushId = this._scheduled; - this._scheduled = undefined; - } - - const { actions } = this; - let error: any; - action = action || actions.shift()!; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions[0]) && action.id === flushId && actions.shift()); - - this._active = false; - - if (error) { - while ((action = actions[0]) && action.id === flushId && actions.shift()) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsapAction.ts b/node_modules/rxjs/src/internal/scheduler/AsapAction.ts deleted file mode 100644 index 178f677..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsapAction.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsapScheduler } from './AsapScheduler'; -import { SchedulerAction } from '../types'; -import { immediateProvider } from './immediateProvider'; -import { TimerHandle } from './timerHandle'; - -export class AsapAction<T> extends AsyncAction<T> { - constructor(protected scheduler: AsapScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - protected requestAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay is greater than 0, request as an async action. - if (delay !== null && delay > 0) { - return super.requestAsyncId(scheduler, id, delay); - } - // Push the action to the end of the scheduler queue. - scheduler.actions.push(this); - // If a microtask has already been scheduled, don't schedule another - // one. If a microtask hasn't been scheduled yet, schedule one now. Return - // the current scheduled microtask id. - return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined))); - } - - protected recycleAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - if (delay != null ? delay > 0 : this.delay > 0) { - return super.recycleAsyncId(scheduler, id, delay); - } - // If the scheduler queue has no remaining actions with the same async id, - // cancel the requested microtask and set the scheduled flag to undefined - // so the next AsapAction will request its own. - const { actions } = scheduler; - if (id != null && actions[actions.length - 1]?.id !== id) { - immediateProvider.clearImmediate(id); - if (scheduler._scheduled === id) { - scheduler._scheduled = undefined; - } - } - // Return undefined so the action knows to request a new async id if it's rescheduled. - return undefined; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts deleted file mode 100644 index 95874bd..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts +++ /dev/null @@ -1,38 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -export class AsapScheduler extends AsyncScheduler { - public flush(action?: AsyncAction<any>): void { - this._active = true; - // The async id that effects a call to flush is stored in _scheduled. - // Before executing an action, it's necessary to check the action's async - // id to determine whether it's supposed to be executed in the current - // flush. - // Previous implementations of this method used a count to determine this, - // but that was unsound, as actions that are unsubscribed - i.e. cancelled - - // are removed from the actions array and that can shift actions that are - // scheduled to be executed in a subsequent flush into positions at which - // they are executed within the current flush. - const flushId = this._scheduled; - this._scheduled = undefined; - - const { actions } = this; - let error: any; - action = action || actions.shift()!; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions[0]) && action.id === flushId && actions.shift()); - - this._active = false; - - if (error) { - while ((action = actions[0]) && action.id === flushId && actions.shift()) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts b/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts deleted file mode 100644 index 704b571..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts +++ /dev/null @@ -1,150 +0,0 @@ -import { Action } from './Action'; -import { SchedulerAction } from '../types'; -import { Subscription } from '../Subscription'; -import { AsyncScheduler } from './AsyncScheduler'; -import { intervalProvider } from './intervalProvider'; -import { arrRemove } from '../util/arrRemove'; -import { TimerHandle } from './timerHandle'; - -export class AsyncAction<T> extends Action<T> { - public id: TimerHandle | undefined; - public state?: T; - // @ts-ignore: Property has no initializer and is not definitely assigned - public delay: number; - protected pending: boolean = false; - - constructor(protected scheduler: AsyncScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (this.closed) { - return this; - } - - // Always replace the current state with the new state. - this.state = state; - - const id = this.id; - const scheduler = this.scheduler; - - // - // Important implementation note: - // - // Actions only execute once by default, unless rescheduled from within the - // scheduled callback. This allows us to implement single and repeat - // actions via the same code path, without adding API surface area, as well - // as mimic traditional recursion but across asynchronous boundaries. - // - // However, JS runtimes and timers distinguish between intervals achieved by - // serial `setTimeout` calls vs. a single `setInterval` call. An interval of - // serial `setTimeout` calls can be individually delayed, which delays - // scheduling the next `setTimeout`, and so on. `setInterval` attempts to - // guarantee the interval callback will be invoked more precisely to the - // interval period, regardless of load. - // - // Therefore, we use `setInterval` to schedule single and repeat actions. - // If the action reschedules itself with the same delay, the interval is not - // canceled. If the action doesn't reschedule, or reschedules with a - // different delay, the interval will be canceled after scheduled callback - // execution. - // - if (id != null) { - this.id = this.recycleAsyncId(scheduler, id, delay); - } - - // Set the pending flag indicating that this action has been scheduled, or - // has recursively rescheduled itself. - this.pending = true; - - this.delay = delay; - // If this action has already an async Id, don't request a new one. - this.id = this.id ?? this.requestAsyncId(scheduler, this.id, delay); - - return this; - } - - protected requestAsyncId(scheduler: AsyncScheduler, _id?: TimerHandle, delay: number = 0): TimerHandle { - return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay); - } - - protected recycleAsyncId(_scheduler: AsyncScheduler, id?: TimerHandle, delay: number | null = 0): TimerHandle | undefined { - // If this action is rescheduled with the same delay time, don't clear the interval id. - if (delay != null && this.delay === delay && this.pending === false) { - return id; - } - // Otherwise, if the action's delay time is different from the current delay, - // or the action has been rescheduled before it's executed, clear the interval id - if (id != null) { - intervalProvider.clearInterval(id); - } - - return undefined; - } - - /** - * Immediately executes this action and the `work` it contains. - */ - public execute(state: T, delay: number): any { - if (this.closed) { - return new Error('executing a cancelled action'); - } - - this.pending = false; - const error = this._execute(state, delay); - if (error) { - return error; - } else if (this.pending === false && this.id != null) { - // Dequeue if the action didn't reschedule itself. Don't call - // unsubscribe(), because the action could reschedule later. - // For example: - // ``` - // scheduler.schedule(function doWork(counter) { - // /* ... I'm a busy worker bee ... */ - // var originalAction = this; - // /* wait 100ms before rescheduling the action */ - // setTimeout(function () { - // originalAction.schedule(counter + 1); - // }, 100); - // }, 1000); - // ``` - this.id = this.recycleAsyncId(this.scheduler, this.id, null); - } - } - - protected _execute(state: T, _delay: number): any { - let errored: boolean = false; - let errorValue: any; - try { - this.work(state); - } catch (e) { - errored = true; - // HACK: Since code elsewhere is relying on the "truthiness" of the - // return here, we can't have it return "" or 0 or false. - // TODO: Clean this up when we refactor schedulers mid-version-8 or so. - errorValue = e ? e : new Error('Scheduled action threw falsy error'); - } - if (errored) { - this.unsubscribe(); - return errorValue; - } - } - - unsubscribe() { - if (!this.closed) { - const { id, scheduler } = this; - const { actions } = scheduler; - - this.work = this.state = this.scheduler = null!; - this.pending = false; - - arrRemove(actions, this); - if (id != null) { - this.id = this.recycleAsyncId(scheduler, id, null); - } - - this.delay = null!; - super.unsubscribe(); - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts deleted file mode 100644 index b05e2e3..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts +++ /dev/null @@ -1,52 +0,0 @@ -import { Scheduler } from '../Scheduler'; -import { Action } from './Action'; -import { AsyncAction } from './AsyncAction'; -import { TimerHandle } from './timerHandle'; - -export class AsyncScheduler extends Scheduler { - public actions: Array<AsyncAction<any>> = []; - /** - * A flag to indicate whether the Scheduler is currently executing a batch of - * queued actions. - * @internal - */ - public _active: boolean = false; - /** - * An internal ID used to track the latest asynchronous task such as those - * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and - * others. - * @internal - */ - public _scheduled: TimerHandle | undefined; - - constructor(SchedulerAction: typeof Action, now: () => number = Scheduler.now) { - super(SchedulerAction, now); - } - - public flush(action: AsyncAction<any>): void { - const { actions } = this; - - if (this._active) { - actions.push(action); - return; - } - - let error: any; - this._active = true; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions.shift()!)); // exhaust the scheduler queue - - this._active = false; - - if (error) { - while ((action = actions.shift()!)) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/QueueAction.ts b/node_modules/rxjs/src/internal/scheduler/QueueAction.ts deleted file mode 100644 index 9016edb..0000000 --- a/node_modules/rxjs/src/internal/scheduler/QueueAction.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { Subscription } from '../Subscription'; -import { QueueScheduler } from './QueueScheduler'; -import { SchedulerAction } from '../types'; -import { TimerHandle } from './timerHandle'; - -export class QueueAction<T> extends AsyncAction<T> { - constructor(protected scheduler: QueueScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (delay > 0) { - return super.schedule(state, delay); - } - this.delay = delay; - this.state = state; - this.scheduler.flush(this); - return this; - } - - public execute(state: T, delay: number): any { - return delay > 0 || this.closed ? super.execute(state, delay) : this._execute(state, delay); - } - - protected requestAsyncId(scheduler: QueueScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - - if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) { - return super.requestAsyncId(scheduler, id, delay); - } - - // Otherwise flush the scheduler starting with this action. - scheduler.flush(this); - - // HACK: In the past, this was returning `void`. However, `void` isn't a valid - // `TimerHandle`, and generally the return value here isn't really used. So the - // compromise is to return `0` which is both "falsy" and a valid `TimerHandle`, - // as opposed to refactoring every other instanceo of `requestAsyncId`. - return 0; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts b/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts deleted file mode 100644 index e9dab3d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts +++ /dev/null @@ -1,4 +0,0 @@ -import { AsyncScheduler } from './AsyncScheduler'; - -export class QueueScheduler extends AsyncScheduler { -} diff --git a/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts b/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts deleted file mode 100644 index 70fec02..0000000 --- a/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts +++ /dev/null @@ -1,128 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { Subscription } from '../Subscription'; -import { AsyncScheduler } from './AsyncScheduler'; -import { SchedulerAction } from '../types'; -import { TimerHandle } from './timerHandle'; - -export class VirtualTimeScheduler extends AsyncScheduler { - /** @deprecated Not used in VirtualTimeScheduler directly. Will be removed in v8. */ - static frameTimeFactor = 10; - - /** - * The current frame for the state of the virtual scheduler instance. The difference - * between two "frames" is synonymous with the passage of "virtual time units". So if - * you record `scheduler.frame` to be `1`, then later, observe `scheduler.frame` to be at `11`, - * that means `10` virtual time units have passed. - */ - public frame: number = 0; - - /** - * Used internally to examine the current virtual action index being processed. - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - public index: number = -1; - - /** - * This creates an instance of a `VirtualTimeScheduler`. Experts only. The signature of - * this constructor is likely to change in the long run. - * - * @param schedulerActionCtor The type of Action to initialize when initializing actions during scheduling. - * @param maxFrames The maximum number of frames to process before stopping. Used to prevent endless flush cycles. - */ - constructor(schedulerActionCtor: typeof AsyncAction = VirtualAction as any, public maxFrames: number = Infinity) { - super(schedulerActionCtor, () => this.frame); - } - - /** - * Prompt the Scheduler to execute all of its queued actions, therefore - * clearing its queue. - */ - public flush(): void { - const { actions, maxFrames } = this; - let error: any; - let action: AsyncAction<any> | undefined; - - while ((action = actions[0]) && action.delay <= maxFrames) { - actions.shift(); - this.frame = action.delay; - - if ((error = action.execute(action.state, action.delay))) { - break; - } - } - - if (error) { - while ((action = actions.shift())) { - action.unsubscribe(); - } - throw error; - } - } -} - -export class VirtualAction<T> extends AsyncAction<T> { - protected active: boolean = true; - - constructor( - protected scheduler: VirtualTimeScheduler, - protected work: (this: SchedulerAction<T>, state?: T) => void, - protected index: number = (scheduler.index += 1) - ) { - super(scheduler, work); - this.index = scheduler.index = index; - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (Number.isFinite(delay)) { - if (!this.id) { - return super.schedule(state, delay); - } - this.active = false; - // If an action is rescheduled, we save allocations by mutating its state, - // pushing it to the end of the scheduler queue, and recycling the action. - // But since the VirtualTimeScheduler is used for testing, VirtualActions - // must be immutable so they can be inspected later. - const action = new VirtualAction(this.scheduler, this.work); - this.add(action); - return action.schedule(state, delay); - } else { - // If someone schedules something with Infinity, it'll never happen. So we - // don't even schedule it. - return Subscription.EMPTY; - } - } - - protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle { - this.delay = scheduler.frame + delay; - const { actions } = scheduler; - actions.push(this); - (actions as Array<VirtualAction<T>>).sort(VirtualAction.sortActions); - return 1; - } - - protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle | undefined { - return undefined; - } - - protected _execute(state: T, delay: number): any { - if (this.active === true) { - return super._execute(state, delay); - } - } - - private static sortActions<T>(a: VirtualAction<T>, b: VirtualAction<T>) { - if (a.delay === b.delay) { - if (a.index === b.index) { - return 0; - } else if (a.index > b.index) { - return 1; - } else { - return -1; - } - } else if (a.delay > b.delay) { - return 1; - } else { - return -1; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/animationFrame.ts b/node_modules/rxjs/src/internal/scheduler/animationFrame.ts deleted file mode 100644 index 2ce033d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/animationFrame.ts +++ /dev/null @@ -1,41 +0,0 @@ -import { AnimationFrameAction } from './AnimationFrameAction'; -import { AnimationFrameScheduler } from './AnimationFrameScheduler'; - -/** - * - * Animation Frame Scheduler - * - * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span> - * - * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler - * behaviour. - * - * Without delay, `animationFrame` scheduler can be used to create smooth browser animations. - * It makes sure scheduled task will happen just before next browser content repaint, - * thus performing animations as efficiently as possible. - * - * ## Example - * Schedule div height animation - * ```ts - * // html: <div style="background: #0ff;"></div> - * import { animationFrameScheduler } from 'rxjs'; - * - * const div = document.querySelector('div'); - * - * animationFrameScheduler.schedule(function(height) { - * div.style.height = height + "px"; - * - * this.schedule(height + 1); // `this` references currently executing Action, - * // which we reschedule with new state - * }, 0, 0); - * - * // You will see a div element growing in height - * ``` - */ - -export const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction); - -/** - * @deprecated Renamed to {@link animationFrameScheduler}. Will be removed in v8. - */ -export const animationFrame = animationFrameScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts b/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts deleted file mode 100644 index 610093b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { Subscription } from '../Subscription'; - -interface AnimationFrameProvider { - schedule(callback: FrameRequestCallback): Subscription; - requestAnimationFrame: typeof requestAnimationFrame; - cancelAnimationFrame: typeof cancelAnimationFrame; - delegate: - | { - requestAnimationFrame: typeof requestAnimationFrame; - cancelAnimationFrame: typeof cancelAnimationFrame; - } - | undefined; -} - -export const animationFrameProvider: AnimationFrameProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - schedule(callback) { - let request = requestAnimationFrame; - let cancel: typeof cancelAnimationFrame | undefined = cancelAnimationFrame; - const { delegate } = animationFrameProvider; - if (delegate) { - request = delegate.requestAnimationFrame; - cancel = delegate.cancelAnimationFrame; - } - const handle = request((timestamp) => { - // Clear the cancel function. The request has been fulfilled, so - // attempting to cancel the request upon unsubscription would be - // pointless. - cancel = undefined; - callback(timestamp); - }); - return new Subscription(() => cancel?.(handle)); - }, - requestAnimationFrame(...args) { - const { delegate } = animationFrameProvider; - return (delegate?.requestAnimationFrame || requestAnimationFrame)(...args); - }, - cancelAnimationFrame(...args) { - const { delegate } = animationFrameProvider; - return (delegate?.cancelAnimationFrame || cancelAnimationFrame)(...args); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/asap.ts b/node_modules/rxjs/src/internal/scheduler/asap.ts deleted file mode 100644 index 5be1be4..0000000 --- a/node_modules/rxjs/src/internal/scheduler/asap.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { AsapAction } from './AsapAction'; -import { AsapScheduler } from './AsapScheduler'; - -/** - * - * Asap Scheduler - * - * <span class="informal">Perform task as fast as it can be performed asynchronously</span> - * - * `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task - * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing - * code to end and then it will try to execute given task as fast as possible. - * - * `asap` scheduler will do its best to minimize time between end of currently executing code - * and start of scheduled task. This makes it best candidate for performing so called "deferring". - * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves - * some (although minimal) unwanted delay. - * - * Note that using `asap` scheduler does not necessarily mean that your task will be first to process - * after currently executing code. In particular, if some task was also scheduled with `asap` before, - * that task will execute first. That being said, if you need to schedule task asynchronously, but - * as soon as possible, `asap` scheduler is your best bet. - * - * ## Example - * Compare async and asap scheduler< - * ```ts - * import { asapScheduler, asyncScheduler } from 'rxjs'; - * - * asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first... - * asapScheduler.schedule(() => console.log('asap')); - * - * // Logs: - * // "asap" - * // "async" - * // ... but 'asap' goes first! - * ``` - */ - -export const asapScheduler = new AsapScheduler(AsapAction); - -/** - * @deprecated Renamed to {@link asapScheduler}. Will be removed in v8. - */ -export const asap = asapScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/async.ts b/node_modules/rxjs/src/internal/scheduler/async.ts deleted file mode 100644 index 76f9dc8..0000000 --- a/node_modules/rxjs/src/internal/scheduler/async.ts +++ /dev/null @@ -1,56 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -/** - * - * Async Scheduler - * - * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span> - * - * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript - * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating - * in intervals. - * - * If you just want to "defer" task, that is to perform it right after currently - * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`), - * better choice will be the {@link asapScheduler} scheduler. - * - * ## Examples - * Use async scheduler to delay task - * ```ts - * import { asyncScheduler } from 'rxjs'; - * - * const task = () => console.log('it works!'); - * - * asyncScheduler.schedule(task, 2000); - * - * // After 2 seconds logs: - * // "it works!" - * ``` - * - * Use async scheduler to repeat task in intervals - * ```ts - * import { asyncScheduler } from 'rxjs'; - * - * function task(state) { - * console.log(state); - * this.schedule(state + 1, 1000); // `this` references currently executing Action, - * // which we reschedule with new state and delay - * } - * - * asyncScheduler.schedule(task, 3000, 0); - * - * // Logs: - * // 0 after 3s - * // 1 after 4s - * // 2 after 5s - * // 3 after 6s - * ``` - */ - -export const asyncScheduler = new AsyncScheduler(AsyncAction); - -/** - * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8. - */ -export const async = asyncScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts b/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts deleted file mode 100644 index 9e8339d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { TimestampProvider } from '../types'; - -interface DateTimestampProvider extends TimestampProvider { - delegate: TimestampProvider | undefined; -} - -export const dateTimestampProvider: DateTimestampProvider = { - now() { - // Use the variable rather than `this` so that the function can be called - // without being bound to the provider. - return (dateTimestampProvider.delegate || Date).now(); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts b/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts deleted file mode 100644 index d70fbf3..0000000 --- a/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import { Immediate } from '../util/Immediate'; -import type { TimerHandle } from './timerHandle'; -const { setImmediate, clearImmediate } = Immediate; - -type SetImmediateFunction = (handler: () => void, ...args: any[]) => TimerHandle; -type ClearImmediateFunction = (handle: TimerHandle) => void; - -interface ImmediateProvider { - setImmediate: SetImmediateFunction; - clearImmediate: ClearImmediateFunction; - delegate: - | { - setImmediate: SetImmediateFunction; - clearImmediate: ClearImmediateFunction; - } - | undefined; -} - -export const immediateProvider: ImmediateProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setImmediate(...args) { - const { delegate } = immediateProvider; - return (delegate?.setImmediate || setImmediate)(...args); - }, - clearImmediate(handle) { - const { delegate } = immediateProvider; - return (delegate?.clearImmediate || clearImmediate)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts b/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts deleted file mode 100644 index 032317d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import type { TimerHandle } from './timerHandle'; -type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle; -type ClearIntervalFunction = (handle: TimerHandle) => void; - -interface IntervalProvider { - setInterval: SetIntervalFunction; - clearInterval: ClearIntervalFunction; - delegate: - | { - setInterval: SetIntervalFunction; - clearInterval: ClearIntervalFunction; - } - | undefined; -} - -export const intervalProvider: IntervalProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setInterval(handler: () => void, timeout?: number, ...args) { - const { delegate } = intervalProvider; - if (delegate?.setInterval) { - return delegate.setInterval(handler, timeout, ...args); - } - return setInterval(handler, timeout, ...args); - }, - clearInterval(handle) { - const { delegate } = intervalProvider; - return (delegate?.clearInterval || clearInterval)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts b/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts deleted file mode 100644 index 873e71b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { TimestampProvider } from '../types'; - -interface PerformanceTimestampProvider extends TimestampProvider { - delegate: TimestampProvider | undefined; -} - -export const performanceTimestampProvider: PerformanceTimestampProvider = { - now() { - // Use the variable rather than `this` so that the function can be called - // without being bound to the provider. - return (performanceTimestampProvider.delegate || performance).now(); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/queue.ts b/node_modules/rxjs/src/internal/scheduler/queue.ts deleted file mode 100644 index df4e216..0000000 --- a/node_modules/rxjs/src/internal/scheduler/queue.ts +++ /dev/null @@ -1,72 +0,0 @@ -import { QueueAction } from './QueueAction'; -import { QueueScheduler } from './QueueScheduler'; - -/** - * - * Queue Scheduler - * - * <span class="informal">Put every next task on a queue, instead of executing it immediately</span> - * - * `queue` scheduler, when used with delay, behaves the same as {@link asyncScheduler} scheduler. - * - * When used without delay, it schedules given task synchronously - executes it right when - * it is scheduled. However when called recursively, that is when inside the scheduled task, - * another task is scheduled with queue scheduler, instead of executing immediately as well, - * that task will be put on a queue and wait for current one to finish. - * - * This means that when you execute task with `queue` scheduler, you are sure it will end - * before any other task scheduled with that scheduler will start. - * - * ## Examples - * Schedule recursively first, then do something - * ```ts - * import { queueScheduler } from 'rxjs'; - * - * queueScheduler.schedule(() => { - * queueScheduler.schedule(() => console.log('second')); // will not happen now, but will be put on a queue - * - * console.log('first'); - * }); - * - * // Logs: - * // "first" - * // "second" - * ``` - * - * Reschedule itself recursively - * ```ts - * import { queueScheduler } from 'rxjs'; - * - * queueScheduler.schedule(function(state) { - * if (state !== 0) { - * console.log('before', state); - * this.schedule(state - 1); // `this` references currently executing Action, - * // which we reschedule with new state - * console.log('after', state); - * } - * }, 0, 3); - * - * // In scheduler that runs recursively, you would expect: - * // "before", 3 - * // "before", 2 - * // "before", 1 - * // "after", 1 - * // "after", 2 - * // "after", 3 - * - * // But with queue it logs: - * // "before", 3 - * // "after", 3 - * // "before", 2 - * // "after", 2 - * // "before", 1 - * // "after", 1 - * ``` - */ - -export const queueScheduler = new QueueScheduler(QueueAction); - -/** - * @deprecated Renamed to {@link queueScheduler}. Will be removed in v8. - */ -export const queue = queueScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts b/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts deleted file mode 100644 index 205e016..0000000 --- a/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import type { TimerHandle } from './timerHandle'; -type SetTimeoutFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle; -type ClearTimeoutFunction = (handle: TimerHandle) => void; - -interface TimeoutProvider { - setTimeout: SetTimeoutFunction; - clearTimeout: ClearTimeoutFunction; - delegate: - | { - setTimeout: SetTimeoutFunction; - clearTimeout: ClearTimeoutFunction; - } - | undefined; -} - -export const timeoutProvider: TimeoutProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setTimeout(handler: () => void, timeout?: number, ...args) { - const { delegate } = timeoutProvider; - if (delegate?.setTimeout) { - return delegate.setTimeout(handler, timeout, ...args); - } - return setTimeout(handler, timeout, ...args); - }, - clearTimeout(handle) { - const { delegate } = timeoutProvider; - return (delegate?.clearTimeout || clearTimeout)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/timerHandle.ts b/node_modules/rxjs/src/internal/scheduler/timerHandle.ts deleted file mode 100644 index 99c0098..0000000 --- a/node_modules/rxjs/src/internal/scheduler/timerHandle.ts +++ /dev/null @@ -1 +0,0 @@ -export type TimerHandle = number | ReturnType<typeof setTimeout>; |