@vkontakte/videoplayer-shared 1.0.86-dev.fcdd1bac.0 → 1.0.86

package/package.json

@@ -1,32 +1,55 @@
 {
   "name": "@vkontakte/videoplayer-shared",
-  "version": "1.0.86-dev.fcdd1bac.0",
+  "version": "1.0.86",
   "author": "vk.com",
   "description": "Shared code for vk.com videoplayer",
   "homepage": "https://vk.com",
   "license": "GPL-3.0",
+  "main": "./esnext.cjs",
   "module": "./esnext.esm.js",
   "types": "./types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
-      "import": "./esnext.esm.js"
+      "import": "./esnext.esm.js",
+      "require": "./esnext.cjs"
     },
     "./evergreen": {
       "types": "./types/index.d.ts",
-      "import": "./evergreen.esm.js"
+      "import": "./evergreen.esm.js",
+      "require": "./evergreen.cjs"
     },
     "./esnext": {
       "types": "./types/index.d.ts",
-      "import": "./esnext.esm.js"
+      "import": "./esnext.esm.js",
+      "require": "./esnext.cjs"
+    },
+    "./es2024": {
+      "types": "./types/index.d.ts",
+      "import": "./es2024.esm.js",
+      "require": "./es2024.cjs"
+    },
+    "./es2018": {
+      "types": "./types/index.d.ts",
+      "import": "./es2018.esm.js",
+      "require": "./es2018.cjs"
     },
     "./es2015": {
       "types": "./types/index.d.ts",
-      "import": "./es2015.esm.js"
-    }
+      "import": "./es2015.esm.js",
+      "require": "./es2015.cjs"
+    },
+    "./evergreen.esm.js": "./evergeen.esm.js",
+    "./esnext.esm.js": "./esnext.esm.js",
+    "./esnext.cjs": "./esnext.cjs",
+    "./es2018.esm.js": "./es2018.esm.js",
+    "./es2018.cjs": "./es2018.cjs",
+    "./es2015.esm.js": "./es2015.esm.js",
+    "./es2015.cjs": "./es2015.cjs"
   },
   "files": [
+    "*.cjs",
     "*.esm.js",
     "**/*.d.ts"
   ],

package/types/AppTracer/AppTracer.d.ts

@@ -0,0 +1,25 @@
+import type { ISubscription } from "../reactive";
+import type { ITracerError, ITracerErrorData } from "@apptracer/sdk/lite";
+import type { AppTracerSdk, IAppTracerContext, IAppTracerEnvParams, IAppTracerOptions, IComponentName } from "./types";
+import type { IError } from "../types";
+export declare class AppTracer {
+	protected static readonly tracerErrorMap: Map<IComponentName, ITracerError>;
+	protected static appTracerModule: typeof AppTracerSdk | null;
+	protected static loadPromise: Promise<unknown> | null;
+	private readonly dynamicImportTimeout;
+	private readonly componentName;
+	private readonly subscription;
+	private readonly options;
+	private readonly envParams;
+	private readonly context?;
+	/**
+	* на каждый `componentName` создаётся 1 уникальный экземпляр трейсера.
+	* пересоздать его уже будет нельзя
+	*/
+	constructor(componentName: IComponentName, options: IAppTracerOptions, envParams: IAppTracerEnvParams, context?: IAppTracerContext);
+	error(error: IError, errorData?: Partial<Pick<ITracerErrorData, "severity">>): void;
+	addSubscription(item: Parameters<ISubscription["add"]>[0]): void;
+	destroy(): void;
+	private init;
+	private loadModule;
+}

package/types/AppTracer/constants.d.ts

@@ -0,0 +1 @@
+export declare const APP_TOKEN = "gW5EerTD5QhAnsbpF7Hd2NSMRteYIUUMjFbSyI68Pf5";

package/types/AppTracer/index.d.ts

@@ -0,0 +1,2 @@
+export { AppTracer } from "./AppTracer";
+export type { IAppTracerOptions, IAppTracerEnvParams, IAppTracerContext } from "./types";

package/types/AppTracer/types.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorCategory } from "../types";
+import type * as AppTracerSdk from "@apptracer/sdk/lite";
+import type { ITracerError, ITracerErrorData, ITracerUploaderConfig } from "@apptracer/sdk/lite";
+export type { AppTracerSdk };
+export type IComponentName = string & {};
+export interface IAppTracerOptions {
+	enabled: boolean;
+	sampleRate: number;
+	whiteErrorCategoryList: ErrorCategory[];
+	blackErrorCategoryList: ErrorCategory[];
+	whiteErrorIdList: string[];
+	blackErrorIdList: string[];
+}
+export interface IAppTracerEnvParams {
+	version: ITracerUploaderConfig["versionName"];
+	env: ITracerUploaderConfig["environment"];
+}
+export type IAppTracerContext = Parameters<ITracerError["setErrorKeys"]>[0];
+export type IAppTracerErrorDataKeys = ITracerErrorData["keys"];

package/types/AppTracer/utils.d.ts

@@ -0,0 +1,5 @@
+import type { IError } from "../types";
+import type { IAppTracerErrorDataKeys } from "./types";
+export declare const mapIErrorToAppTracerErrorKeys: (error: IError) => IAppTracerErrorDataKeys;
+export declare const mapIErrorThrownToError: (error: IError) => Error;
+export declare const mapLocationData: () => Record<string, string> | undefined;

package/types/InternalsExposure/index.d.ts

@@ -0,0 +1,28 @@
+import type { ILogger } from "../Logger";
+export declare const INTERNAL_EXPOSE_GLOBAL_KEY = "__vk_vp_internals_exposure";
+export type ExposeType = "ui" | "core";
+type InternalsExposureItem = {
+	logger?: ILogger;
+	[k: string]: unknown;
+};
+export type InternalsExposureData = {
+	[playerId: string]: {
+		ui?: InternalsExposureItem;
+		core?: InternalsExposureItem;
+	};
+};
+declare global {
+	interface Window {
+		[INTERNAL_EXPOSE_GLOBAL_KEY]?: InternalsExposureData;
+	}
+}
+export declare class InternalsExposure {
+	private readonly playerId;
+	private readonly type;
+	constructor(type: ExposeType, playerId: string);
+	private getWindowObject;
+	private initWindowObjects;
+	expose(data: Record<string, unknown>): void;
+	destroy(): void;
+}
+export {};

package/types/Logger/Logger.d.ts

@@ -0,0 +1,10 @@
+import Subject from "../reactive/Subject";
+import type { ILogger, ILogInputEntry, IComponentLogger, ILogEntry } from "./types";
+export declare class Logger implements ILogger {
+	log$: Subject<ILogEntry>;
+	private logs;
+	log: (inputEntry: ILogInputEntry) => void;
+	createCustomLog<TArgs extends unknown[]>(transform: (...args: TArgs) => ILogInputEntry): (...args: TArgs) => void;
+	createComponentLog(component: string): IComponentLogger;
+	getAllLogs: () => ILogEntry[];
+}

package/types/Logger/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger } from "./Logger";
+export type { ILogger, ILogInputEntry, IComponentLogEntry, IComponentLogger, ILogEntry } from "./types";

package/types/Logger/types.d.ts

@@ -0,0 +1,29 @@
+import type { IObservable } from "../reactive/types";
+export interface ILogger {
+	log: (entry: ILogInputEntry) => void;
+	createCustomLog: <TArgs extends unknown[]>(transform: (...args: TArgs) => ILogInputEntry) => (...args: TArgs) => void;
+	createComponentLog: (component: string) => IComponentLogger;
+	getAllLogs: () => ILogEntry[];
+	log$: IObservable<ILogEntry>;
+}
+export interface ILogEntry {
+	/**
+	* Сообщение.
+	*/
+	message: string;
+	/**
+	* Компонент, в котором залогировано событие. (модуль, класс или функция)
+	*/
+	component: string;
+	/**
+	* Время, в которое случилось логируемое событие
+	*/
+	timestamp: number;
+}
+export type IComponentLogger = (entry: IComponentLogEntry) => void;
+export type ILogInputEntry = Omit<ILogEntry, "timestamp">;
+export interface IComponentLogEntry extends Omit<ILogInputEntry, "component">, IOptionalComponent {}
+interface IOptionalComponent {
+	component?: ILogInputEntry["component"];
+}
+export {};

package/types/Tracer/FakeTracer.d.ts

@@ -0,0 +1,13 @@
+import type { IRootTracer, ITracer, ITracerParams } from "./types";
+import type { Attributes } from "@opentelemetry/api";
+export declare class FakeTracer implements IRootTracer {
+	private readonly fakeTraceId;
+	constructor(params?: Partial<ITracerParams>);
+	log(name: string, attributes?: Attributes): void;
+	error(name: string, attributes?: Attributes): void;
+	critical(name: string, attributes?: Attributes): void;
+	createComponentTracer(name: string): ITracer;
+	end(): void;
+	getFinishedSpans(): any | undefined;
+	getTraceId(): string;
+}

package/types/Tracer/RootTracer.d.ts

@@ -0,0 +1,10 @@
+import type { IRootTracer, ITracerParams } from "./types";
+import { Tracer } from "./Tracer";
+import type { Milliseconds } from "../utils";
+export declare class RootTracer extends Tracer implements IRootTracer {
+	private spanExporter;
+	constructor();
+	protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
+	getFinishedSpans(): any | undefined;
+	getTraceId(): string;
+}

package/types/Tracer/Tracer.d.ts

@@ -0,0 +1,25 @@
+import type { Tracer as OtlpTracer } from "@opentelemetry/sdk-trace-web";
+import type { Attributes, Context, Span } from "@opentelemetry/api";
+import type { ITracer, ITracerDynamicImports, ITracerParams } from "./types";
+import { TracerDynamicImportStatus } from "./types";
+import type { Milliseconds } from "../utils";
+export declare class Tracer implements ITracer {
+	private readonly dynamicImportTimeout;
+	protected span: Span;
+	protected context: Context;
+	protected childTracers: ITracer[];
+	protected initPromise: Promise<void>;
+	protected static rootTracer: OtlpTracer;
+	protected static dynamicImportStatus: TracerDynamicImportStatus;
+	protected static dynamicImports: ITracerDynamicImports;
+	protected static dynamicImportPromise: Promise<void>;
+	protected constructor({ name, getParentContext }: ITracerParams);
+	protected init({ name, getParentContext }: ITracerParams, startTime: Milliseconds): void;
+	private loadOpentelemetry;
+	protected isComponentTracerNotInitialized(): boolean;
+	log(name: string, attributes?: Attributes): void;
+	error(name: string, attributes?: Attributes): void;
+	critical(name: string, attributes?: Attributes): void;
+	createComponentTracer(name: string): ITracer;
+	end(): void;
+}

package/types/Tracer/TracerFactory.d.ts

@@ -0,0 +1,4 @@
+import type { IRootTracer } from "./types";
+export declare class TracerFactory {
+	static createRootTracer(isRealTracer?: boolean): IRootTracer;
+}

package/types/Tracer/index.d.ts

@@ -0,0 +1,3 @@
+export { TracerFactory } from "./TracerFactory";
+export type { ITracer, IRootTracer } from "./types";
+export { getTraceSubscriptionMethod } from "./utils";

package/types/Tracer/types.d.ts

@@ -0,0 +1,39 @@
+import type { Attributes, Context } from "@opentelemetry/api";
+import type { ReadableSpan } from "@opentelemetry/sdk-trace-web";
+import type * as TracerOpentelemetry from "@apptracer/opentelemetry";
+import type * as OpentelemetryApi from "@opentelemetry/api";
+import type * as OpentelemetrySdk from "@opentelemetry/sdk-trace-web";
+export type { TracerOpentelemetry };
+export type { OpentelemetryApi };
+export type { OpentelemetrySdk };
+export declare enum TracerDynamicImportStatus {
+	NotStarted = "not_started",
+	InProgress = "in_progress",
+	Failed = "failed",
+	Completed = "completed"
+}
+export declare enum TraceEventType {
+	Log = "log",
+	Error = "error",
+	Critical = "critical"
+}
+export interface ITracerParams {
+	name: string;
+	getParentContext?: () => Context;
+}
+export interface ITracerDynamicImports {
+	opentelemetryApi: typeof OpentelemetryApi;
+	opentelemetrySdk: typeof OpentelemetrySdk;
+	tracer: typeof TracerOpentelemetry;
+}
+export interface ITracer {
+	log: (name: string, attributes?: Attributes) => void;
+	error: (name: string, attributes?: Attributes) => void;
+	critical: (name: string, attributes?: Attributes) => void;
+	createComponentTracer: (name: string) => ITracer;
+	end: () => void;
+}
+export interface IRootTracer extends ITracer {
+	getFinishedSpans: () => ReadableSpan[] | undefined;
+	getTraceId: () => string;
+}

package/types/Tracer/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Attributes } from "@opentelemetry/api";
+export declare const getTraceSubscriptionMethod: (log: (name: string, attributes?: Attributes) => void) => ((name: string) => (value: unknown) => void);
+export declare const replaceUnsupportedValuesByStrings: (obj?: Attributes | undefined) => Attributes;

package/types/devNull.d.ts

@@ -0,0 +1,14 @@
+type DevNullValueArray<T> = [T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?, T?];
+export interface DevNullEntry {
+	key: string;
+	json?: string;
+	strings?: DevNullValueArray<string>;
+	numbers?: DevNullValueArray<number>;
+}
+type Callback = (entry: DevNullEntry) => void;
+type TempStorage = DevNullEntry[];
+export declare const create: (ownerName: string, callback?: Callback) => Map<string, Callback | TempStorage>;
+export declare const destroy: (ownerName: string) => boolean;
+export declare const push: (ownerName: string, entry: DevNullEntry) => void;
+export declare const subscribe: (ownerName: string, callback: Callback) => void;
+export {};

package/types/env.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/types/index.d.ts

@@ -0,0 +1,11 @@
+export { VERSION } from "./env";
+export * from "./Logger";
+export * from "./Tracer";
+export * from "./utils";
+export * from "./reactive";
+export * from "./types";
+export * from "./translation";
+export * from "./InternalsExposure";
+export * as devNull from "./devNull";
+export type { DevNullEntry } from "./devNull";
+export * from "./AppTracer";

package/types/reactive/Observable.d.ts

@@ -0,0 +1,14 @@
+import type { IEmitter, IListener, IObservable, IOperator, ISubscription, IUnsubscriber } from "./types";
+export default class Observable<T> implements IObservable<T> {
+	private suppressErrors;
+	constructor(subscribe?: (emitter: IEmitter<T>) => IUnsubscriber | ISubscription | void);
+	/**
+	* @deprecated Глушить ошибки не стоит.
+	* Раньше у нас они по-умолчанию ошибочно глушились что маскировало многие исключения, в том числе грубые ошибки
+	* Этот метод нужен чтобы временно поддержать старрое поведение пока маскиуремые ошибки не исправятся
+	*/
+	setSuppressErrors(suppress: boolean): void;
+	subscribe(listener: IListener<T>, error?: IListener<Error | unknown>): ISubscription;
+	pipe<K = unknown>(...operators: IOperator<unknown, unknown>[]): IObservable<K>;
+	protected _subscribe(_emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/types/reactive/ReplaySubject.d.ts

@@ -0,0 +1,12 @@
+import type { ISubject } from "./types";
+import { type IEmitter, type ISubscription, type IUnsubscriber } from "./types";
+import SubjectMY from "./Subject";
+export default class ReplaySubject<T> extends SubjectMY<T> implements ISubject<T> {
+	private readonly bufferSize;
+	private readonly buffer;
+	private cursorEnd;
+	private cursorStart;
+	constructor(bufferSize: number);
+	next(value: T): void;
+	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/types/reactive/Subject.d.ts

@@ -0,0 +1,10 @@
+import type { IEmitter, ISubject, ISubscription, IUnsubscriber } from "./types";
+import Observable from "./Observable";
+export default class Subject<T> extends Observable<T> implements ISubject<T> {
+	protected keyCounter: number;
+	protected subscribers: Map<number, IEmitter<T>>;
+	constructor();
+	next(value: T): void;
+	error(value: T): void;
+	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/types/reactive/Subscription.d.ts

@@ -0,0 +1,6 @@
+import type { ISubscription, IUnsubscriber } from "./types";
+export default class Subscription implements ISubscription {
+	protected subscriptions: Array<(() => void) | ISubscription>;
+	unsubscribe(): void;
+	add(item: ISubscription | IUnsubscriber): ISubscription;
+}

package/types/reactive/SubscriptionRemovable.d.ts

@@ -0,0 +1,5 @@
+import Subscription from "./Subscription";
+import type { ISubscription, IUnsubscriber } from "./types";
+export default class SubscriptionRemovable extends Subscription {
+	remove(item: ISubscription | IUnsubscriber): void;
+}

package/types/reactive/ValueSubject.d.ts

@@ -0,0 +1,10 @@
+import type { IEmitter, ISubscription, IUnsubscriber, IValueSubject } from "./types";
+import Subject from "./Subject";
+export default class ValueSubject<T> extends Subject<T> implements IValueSubject<T> {
+	private value;
+	constructor(initialValue: T);
+	next(value: T): void;
+	error(value: T): void;
+	getValue(): T;
+	protected _subscribe(emitter: IEmitter<T>): IUnsubscriber | ISubscription | void;
+}

package/types/reactive/combine.d.ts

@@ -0,0 +1,7 @@
+import type { IObservable, TypeOfObservable } from "./types";
+/**
+*  Создаёт Observable, который состоит из объектов, ключами которых являются последние значения исходных Observable.
+*  Первое событие возникает тогда, когда каждый исходный Observable выдал хотя бы одно значение.
+*/
+type CombineObservables<T extends Record<string, IObservable<unknown>>> = { [key in keyof T] : TypeOfObservable<T[key]> };
+export default function combine<T extends Record<string, IObservable<unknown>>>(observables: T): IObservable<CombineObservables<T>>;

package/types/reactive/fromEvent.d.ts

@@ -0,0 +1,7 @@
+import type { IObservable } from "./types";
+interface IEventTarget {
+	addEventListener(type: string, handler: (...params: any[]) => void): void;
+	removeEventListener(type: string, handler: (...params: any[]) => void): void;
+}
+declare const _default: <T>(target: IEventTarget, eventName: string) => IObservable<T>;
+export default _default;

package/types/reactive/index.d.ts

@@ -0,0 +1,25 @@
+export { default as Subscription } from "./Subscription";
+export { default as Observable } from "./Observable";
+export { default as Subject } from "./Subject";
+export { default as ReplaySubject } from "./ReplaySubject";
+export { default as ValueSubject } from "./ValueSubject";
+export { default as combine } from "./combine";
+export { default as merge } from "./merge";
+export { default as timeout } from "./timeout";
+export { default as interval } from "./interval";
+export { default as observableFrom } from "./observableFrom";
+export { default as fromEvent } from "./fromEvent";
+export { default as SubscriptionRemovable } from "./SubscriptionRemovable";
+export { default as buffer } from "./operators/buffer";
+export { default as debounce } from "./operators/debounce";
+export { default as throttle } from "./operators/throttle";
+export { default as filter } from "./operators/filter";
+export { default as filterChanged } from "./operators/filterChanged";
+export { default as map } from "./operators/map";
+export { default as mapTo } from "./operators/mapTo";
+export { default as once } from "./operators/once";
+export { default as pairwise } from "./operators/pairwise";
+export { default as tap } from "./operators/tap";
+export { default as skip } from "./operators/skip";
+export { default as shareReplay } from "./operators/shareReplay";
+export type { ISubscription, IUnsubscriber, IObservable, ISubject, IValueSubject, IValueObservable, IListener, IEmitter, IValue, IOperator } from "./types";

package/types/reactive/interval.d.ts

@@ -0,0 +1,4 @@
+import type { Milliseconds } from "../utils";
+import type { IObservable } from "./types";
+declare const _default: (time: Milliseconds) => IObservable<void>;
+export default _default;

package/types/reactive/merge.d.ts

@@ -0,0 +1,82 @@
+import type { IObservable } from "./types";
+export default function merge<
+	T1,
+	T2
+>(v1: IObservable<T1>, v2: IObservable<T2>): IObservable<T1 | T2>;
+export default function merge<
+	T1,
+	T2,
+	T3
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>): IObservable<T1 | T2 | T3>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>): IObservable<T1 | T2 | T3 | T4>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>): IObservable<T1 | T2 | T3 | T4 | T5>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>): IObservable<T1 | T2 | T3 | T4 | T5 | T6>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+export default function merge<
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10
+>(v1: IObservable<T1>, v2: IObservable<T2>, v3: IObservable<T3>, v4: IObservable<T4>, v5: IObservable<T5>, v6: IObservable<T6>, v7: IObservable<T7>, v8: IObservable<T8>, v9: IObservable<T9>, v10: IObservable<T10>): IObservable<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+export default function merge<R>(...observables: IObservable<unknown>[]): IObservable<R>;

package/types/reactive/observableFrom.d.ts

@@ -0,0 +1,3 @@
+import type { IObservable } from "./types";
+declare const _default: <T>(values: T[]) => IObservable<T>;
+export default _default;

package/types/reactive/operators/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from "../types";
+export default function buffer<T>(size: number): IOperator<T, T[]>;

package/types/reactive/operators/debounce.d.ts

@@ -0,0 +1,7 @@
+import type { Milliseconds } from "../../utils/semanticTypes";
+import type { IOperator } from "../types";
+interface DebounceConfig {
+	leading: boolean;
+	trailing: boolean;
+}
+export default function debounce<T>(time: Milliseconds, config?: DebounceConfig): IOperator<T>;

package/types/reactive/operators/filter.d.ts

@@ -0,0 +1,6 @@
+import type { IOperator } from "../types";
+export default function filter<
+	T,
+	S extends T
+>(predicate: (value: T) => value is S): IOperator<T, S>;
+export default function filter<T>(predicate: (value: T) => boolean): IOperator<T>;

package/types/reactive/operators/filterChanged.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+/**
+* Пропускает только события, содержащие значения, отличные от предыдущего
+*/
+export default function filterChanged<T>(equal?: (prev: T, next: T) => boolean): IOperator<T>;

package/types/reactive/operators/map.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+export default function map<
+	T,
+	S
+>(mapper: (value: T) => S): IOperator<T, S>;

package/types/reactive/operators/mapTo.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+export default function mapTo<
+	T,
+	S
+>(value: S): IOperator<T, S>;

package/types/reactive/operators/once.d.ts

@@ -0,0 +1,5 @@
+import type { IOperator } from "../types";
+/**
+*  Отписывается от исходного потока после получения первого события.
+*/
+export default function once<T>(): IOperator<T>;

package/types/reactive/operators/pairwise.d.ts

@@ -0,0 +1,3 @@
+import type { IOperator } from "../types";
+type IPair<T> = [previous: T, current: T];
+export default function pairwise<T>(): IOperator<T, IPair<T>>;

package/types/reactive/operators/shareReplay.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from "..";
+export default function shareReplay<T>(bufferSize?: number | undefined): IOperator<T>;

package/types/reactive/operators/skip.d.ts

@@ -0,0 +1,6 @@
+import type { IOperator } from "..";
+/**
+* Пропускает первые count событий
+* @param count
+*/
+export default function skip<T>(count: number): IOperator<T>;

package/types/reactive/operators/tap.d.ts

@@ -0,0 +1,2 @@
+import type { IOperator } from "../types";
+export default function tap<T>(effect: (value: T) => void): IOperator<T>;

package/types/reactive/operators/throttle.d.ts

@@ -0,0 +1,6 @@
+import type { IOperator } from "../types";
+interface ThrottleConfig {
+	leading: boolean;
+	trailing: boolean;
+}
+export default function throttle<T>(time: number, config?: ThrottleConfig): IOperator<T>;

package/types/reactive/timeout.d.ts

@@ -0,0 +1,4 @@
+import type { Milliseconds } from "../utils";
+import type { IObservable } from "./types";
+declare const _default: (time: Milliseconds) => IObservable<void>;
+export default _default;