13580703009

Committed 28 Feb 2025 03:27AM UTC coverage: 97.521%. Remained the same

Build # 13580703009

Build Type

push

github

Committed by

bordoley

Commit Message

s/runnable/SynchronousObservable

Coverage Stats

901 of 986 branches covered (91.38%)

Branch coverage included in aggregate %.

45 of 46 new or added lines in 22 files covered. (97.83%)

5197 of 5267 relevant lines covered (98.67%)

5531.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

29.63

/src/concurrent/Streamable/__private__/Streamable.spring.ts

import {
  include,
  init,
  mixInstanceFactory,
  props,
} from "../../../__internal__/mixins.js";
import * as Iterable from "../../../computations/Iterable.js";
import {
  AnimationStreamLike,
  AnimationStreamLike_animation,
  DeferredObservableLike,
  DeferredObservableWithSideEffectsLike,
  PauseableLike_resume,
  PureSynchronousObservableLike,
  SchedulerLike,
  StreamableLike,
  StreamableLike_stream,
} from "../../../concurrent.js";
import * as Publisher from "../../../events/Publisher.js";
import { EventListenerLike_notify, EventSourceLike } from "../../../events.js";
import {
  Function1,
  Tuple2,
  compose,
  isNumber,
  isReadonlyArray,
  none,
  pipe,
  returns,
  scale,
  tuple,
} from "../../../functions.js";
import * as Disposable from "../../../utils/Disposable.js";
import { BackpressureStrategy } from "../../../utils.js";
import * as Observable from "../../Observable.js";
import * as PauseableScheduler from "../../PauseableScheduler.js";
import type * as Streamable from "../../Streamable.js";
import * as Subject from "../../Subject.js";
import DelegatingPauseableMixin from "../../__mixins__/DelegatingPauseableMixin.js";
import StreamMixin from "../../__mixins__/StreamMixin.js";

const SpringStream_create: (
  initialValue: number,
  scheduler: SchedulerLike,
  animationScheduler: SchedulerLike,
  springOptions?: {
    readonly stiffness?: number;
    readonly damping?: number;
    readonly precision?: number;
  },
  options?: {
    readonly backpressureStrategy?: BackpressureStrategy;
    readonly replay?: number;
    readonly capacity?: number;
  },
) => AnimationStreamLike<
  Function1<
    number,
    | number
    | { from: number; to: number | ReadonlyArray<number> }
    | ReadonlyArray<number>
  >,
  number
> = /*@__PURE__*/ (() => {
  type TProperties = {
    [AnimationStreamLike_animation]: EventSourceLike<number>;
  };

  return mixInstanceFactory(
    include(StreamMixin(), DelegatingPauseableMixin),
    function AnimationStream(
      instance: TProperties,
      initialValue: number,
      scheduler: SchedulerLike,
      animationScheduler: SchedulerLike,
      springOptions?: {
        readonly stiffness?: number;
        readonly damping?: number;
        readonly precision?: number;
      },
      options?: {
        readonly backpressureStrategy?: BackpressureStrategy;
        readonly replay?: number;
        readonly capacity?: number;
      },
    ): AnimationStreamLike<
      Function1<number, number | ReadonlyArray<number>>,
      number
    > {
      const pauseableScheduler = PauseableScheduler.create(animationScheduler);

      const publisher = (instance[AnimationStreamLike_animation] =
        Publisher.create<number>());

      const accFeedbackStream = Subject.create<number>({ replay: 1 });

      const operator: Function1<
        DeferredObservableLike<
          Function1<
            number,
            | number
            | { from: number; to: number | ReadonlyArray<number> }
            | ReadonlyArray<number>
          >
        >,
        DeferredObservableWithSideEffectsLike<boolean>
      > = compose(
        Observable.withLatestFrom<
          Function1<
            number,
            | number
            | { from: number; to: number | ReadonlyArray<number> }
            | ReadonlyArray<number>
          >,
          number,
          Tuple2<
            | number
            | ReadonlyArray<number>
            | { from: number; to: number | ReadonlyArray<number> },
            number
          >
        >(accFeedbackStream, (updater, acc) => tuple(updater(acc), acc)),
        Observable.switchMap<
          Tuple2<
            | number
            | ReadonlyArray<number>
            | { from: number; to: number | ReadonlyArray<number> },
            number
          >,
          boolean
        >(
          ([updated, acc]) => {
            const initialValue =
              isNumber(updated) || isReadonlyArray(updated)
                ? acc
                : updated.from;

            const destinations = isNumber(updated)
              ? [updated]
              : isReadonlyArray(updated)
                ? updated
                : isNumber(updated.to)
                  ? [updated.to]
                  : updated.to;

            const sources = pipe(
              destinations,
              Iterable.scan<number, Tuple2<number, number>>(
                ([, prev], v) => tuple(prev, v),
                returns(tuple(initialValue, initialValue)),
              ),
              Iterable.reduce(
                (
                  animations: Array<PureSynchronousObservableLike<number>>,
                  [prev, next],
                ) => {
                  if (prev !== next) {
                    animations.push(
                      pipe(
                        Observable.spring(springOptions),
                        Observable.map(scale(prev, next)),
                      ),
                    );
                  }
                  return animations;
                },
                (): Array<PureSynchronousObservableLike<number>> => [],
              ),
            );

            return sources.length > 0
              ? pipe(
                  sources,
                  x => Observable.concatMany<number>(x),
                  Observable.notify(publisher),
                  Observable.notify(accFeedbackStream),
                  Observable.ignoreElements(),
                  Observable.subscribeOn(pauseableScheduler),
                  Observable.startWith<boolean>(true),
                  Observable.endWith<boolean>(false),
                )
              : Observable.empty();
          },

          {
            innerType: Observable.DeferredObservableWithSideEffectsType,
          },
        ),
      );

      init(
        StreamMixin<
          Function1<number, number | ReadonlyArray<number>>,
          boolean
        >(),
        instance,
        operator,
        scheduler,
        options,
      );

      init(DelegatingPauseableMixin, instance, pauseableScheduler);

      pipe(
        instance,
        Disposable.add(publisher),
        Disposable.add(accFeedbackStream),
        Disposable.add(pauseableScheduler),
      );

      instance[PauseableLike_resume]();

      accFeedbackStream[EventListenerLike_notify](initialValue);

      return instance;
    },
    props<TProperties>({
      [AnimationStreamLike_animation]: none,
    }),
  );
})();

const Streamable_spring: Streamable.Signature["spring"] = (
  initialValue: number,
  creationOptions?: {
    readonly animationScheduler?: SchedulerLike;
    readonly stiffness?: number;
    readonly damping?: number;
    readonly precision?: number;
  },
): StreamableLike<
  Function1<
    number,
    | number
    | { from: number; to: number | ReadonlyArray<number> }
    | ReadonlyArray<number>
  >,
  boolean,
  AnimationStreamLike<Function1<number, number | ReadonlyArray<number>>, number>
> => ({
  [StreamableLike_stream]: (scheduler, options) =>
    SpringStream_create(
      initialValue,
      scheduler,
      creationOptions?.animationScheduler ?? scheduler,
      creationOptions,
      options,
    ),
});

export default Streamable_spring;

1	import {	3✔
2	include,
3	init,
4	mixInstanceFactory,
5	props,
6	} from "../../../__internal__/mixins.js";
7	import * as Iterable from "../../../computations/Iterable.js";	3✔
8	import {	3✔
9	AnimationStreamLike,
10	AnimationStreamLike_animation,
11	DeferredObservableLike,
12	DeferredObservableWithSideEffectsLike,
13	PauseableLike_resume,
14	PureSynchronousObservableLike,
15	SchedulerLike,
16	StreamableLike,
17	StreamableLike_stream,
18	} from "../../../concurrent.js";
19	import * as Publisher from "../../../events/Publisher.js";	3✔
20	import { EventListenerLike_notify, EventSourceLike } from "../../../events.js";	3✔
21	import {	3✔
22	Function1,
23	Tuple2,
24	compose,
25	isNumber,
26	isReadonlyArray,
27	none,
28	pipe,
29	returns,
30	scale,
31	tuple,
32	} from "../../../functions.js";
33	import * as Disposable from "../../../utils/Disposable.js";	3✔
34	import { BackpressureStrategy } from "../../../utils.js";
35	import * as Observable from "../../Observable.js";	3✔
36	import * as PauseableScheduler from "../../PauseableScheduler.js";	3✔
37	import type * as Streamable from "../../Streamable.js";
38	import * as Subject from "../../Subject.js";	3✔
39	import DelegatingPauseableMixin from "../../__mixins__/DelegatingPauseableMixin.js";	3✔
40	import StreamMixin from "../../__mixins__/StreamMixin.js";	3✔
41
42	const SpringStream_create: (
43	initialValue: number,
44	scheduler: SchedulerLike,
45	animationScheduler: SchedulerLike,
46	springOptions?: {
47	readonly stiffness?: number;
48	readonly damping?: number;
49	readonly precision?: number;
50	},
51	options?: {
52	readonly backpressureStrategy?: BackpressureStrategy;
53	readonly replay?: number;
54	readonly capacity?: number;
55	},
56	) => AnimationStreamLike<
57	Function1<
58	number,
59	\| number
60	\| { from: number; to: number \| ReadonlyArray<number> }
61	\| ReadonlyArray<number>
62	>,
63	number
64	> = /@__PURE__/ (() => {	3✔
65	type TProperties = {
66	[AnimationStreamLike_animation]: EventSourceLike<number>;
67	};
68
69	return mixInstanceFactory(	3✔
70	include(StreamMixin(), DelegatingPauseableMixin),
71	function AnimationStream(
72	instance: TProperties,
73	initialValue: number,
74	scheduler: SchedulerLike,
75	animationScheduler: SchedulerLike,
76	springOptions?: {
77	readonly stiffness?: number;
78	readonly damping?: number;
79	readonly precision?: number;
80	},
81	options?: {
82	readonly backpressureStrategy?: BackpressureStrategy;
83	readonly replay?: number;
84	readonly capacity?: number;
85	},
86	): AnimationStreamLike<
87	Function1<number, number \| ReadonlyArray<number>>,
88	number
89	> {
90	const pauseableScheduler = PauseableScheduler.create(animationScheduler);	×
91
92	const publisher = (instance[AnimationStreamLike_animation] =	×
93	Publisher.create<number>());
94
95	const accFeedbackStream = Subject.create<number>({ replay: 1 });	×
96
97	const operator: Function1<
98	DeferredObservableLike<
99	Function1<
100	number,
101	\| number
102	\| { from: number; to: number \| ReadonlyArray<number> }
103	\| ReadonlyArray<number>
104	>
105	>,
106	DeferredObservableWithSideEffectsLike<boolean>
107	> = compose(	×
108	Observable.withLatestFrom<
109	Function1<
110	number,
111	\| number
112	\| { from: number; to: number \| ReadonlyArray<number> }
113	\| ReadonlyArray<number>
114	>,
115	number,
116	Tuple2<
117	\| number
118	\| ReadonlyArray<number>
119	\| { from: number; to: number \| ReadonlyArray<number> },
120	number
121	>
122	>(accFeedbackStream, (updater, acc) => tuple(updater(acc), acc)),	×
123	Observable.switchMap<
124	Tuple2<
125	\| number
126	\| ReadonlyArray<number>
127	\| { from: number; to: number \| ReadonlyArray<number> },
128	number
129	>,
130	boolean
131	>(
132	([updated, acc]) => {
133	const initialValue =
134	isNumber(updated) \|\| isReadonlyArray(updated)	×
135	? acc
136	: updated.from;
137
138	const destinations = isNumber(updated)	×
139	? [updated]
140	: isReadonlyArray(updated)	×
141	? updated
142	: isNumber(updated.to)	×
143	? [updated.to]
144	: updated.to;
145
146	const sources = pipe(	×
147	destinations,
148	Iterable.scan<number, Tuple2<number, number>>(
149	([, prev], v) => tuple(prev, v),	×
150	returns(tuple(initialValue, initialValue)),
151	),
152	Iterable.reduce(
153	(
154	animations: Array<PureSynchronousObservableLike<number>>,
155	[prev, next],
156	) => {
157	if (prev !== next) {	×
158	animations.push(	×
159	pipe(
160	Observable.spring(springOptions),
161	Observable.map(scale(prev, next)),
162	),
163	);
164	}
165	return animations;	×
166	},
NEW 167	(): Array<PureSynchronousObservableLike<number>> => [],	×
168	),
169	);
170
171	return sources.length > 0	×
172	? pipe(
173	sources,
174	x => Observable.concatMany<number>(x),	×
175	Observable.notify(publisher),
176	Observable.notify(accFeedbackStream),
177	Observable.ignoreElements(),
178	Observable.subscribeOn(pauseableScheduler),
179	Observable.startWith<boolean>(true),
180	Observable.endWith<boolean>(false),
181	)
182	: Observable.empty();
183	},
184
185	{
186	innerType: Observable.DeferredObservableWithSideEffectsType,
187	},
188	),
189	);
190
191	init(	×
192	StreamMixin<
193	Function1<number, number \| ReadonlyArray<number>>,
194	boolean
195	>(),
196	instance,
197	operator,
198	scheduler,
199	options,
200	);
201
202	init(DelegatingPauseableMixin, instance, pauseableScheduler);	×
203
204	pipe(	×
205	instance,
206	Disposable.add(publisher),
207	Disposable.add(accFeedbackStream),
208	Disposable.add(pauseableScheduler),
209	);
210
211	instance[PauseableLike_resume]();	×
212
213	accFeedbackStream[EventListenerLike_notify](initialValue);	×
214
215	return instance;	×
216	},
217	props<TProperties>({
218	[AnimationStreamLike_animation]: none,
219	}),
220	);
221	})();
222
223	const Streamable_spring: Streamable.Signature["spring"] = (	3✔
224	initialValue: number,
225	creationOptions?: {
226	readonly animationScheduler?: SchedulerLike;
227	readonly stiffness?: number;
228	readonly damping?: number;
229	readonly precision?: number;
230	},
231	): StreamableLike<
232	Function1<
233	number,
234	\| number
235	\| { from: number; to: number \| ReadonlyArray<number> }
236	\| ReadonlyArray<number>
237	>,
238	boolean,
239	AnimationStreamLike<Function1<number, number \| ReadonlyArray<number>>, number>
240	> => ({	×
241	[StreamableLike_stream]: (scheduler, options) =>
242	SpringStream_create(	×
243	initialValue,
244	scheduler,
245	creationOptions?.animationScheduler ?? scheduler,	×
246	creationOptions,
247	options,
248	),
249	});
250
251	export default Streamable_spring;	3✔

bordoley / reactive-js / 13580703009

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous