@fncts/observable 0.0.1

package/Observable/definition.d.ts

@@ -0,0 +1,32 @@
+import { ObservableInput, Subscribable } from "@fncts/observable/Observable";
+import { Operator } from "@fncts/observable/Operator";
+import { Subscriber, isSubscriber, SafeSubscriber } from "@fncts/observable/Subscriber";
+import { Finalizer, Subscription } from "@fncts/observable/Subscription";
+import { Observer } from "@fncts/observable/Observer";
+import { Cause } from "@fncts/base/data/Cause";
+import { noop } from "@fncts/observable/internal/util";
+export declare namespace Observable {
+    type TypeOf<X> = X extends ObservableInput<any, infer A> ? A : never;
+    type ErrorOf<X> = X extends ObservableInput<infer E, any> ? E : never;
+}
+export declare const ObservableTypeId: unique symbol;
+export declare type ObservableTypeId = typeof ObservableTypeId;
+/**
+ * @tsplus type fncts.observable.Observable
+ * @tsplus companion fncts.observable.ObservableOps
+ */
+export declare class Observable<E, A> implements Subscribable<E, A> {
+    readonly _E: () => E;
+    readonly _A: () => A;
+    readonly [ObservableTypeId]: ObservableTypeId;
+    protected source: Observable<any, any> | undefined;
+    protected operator: Operator<E, A> | undefined;
+    constructor(subscribe?: (this: Observable<E, A>, subscriber: Subscriber<E, A>) => Finalizer);
+    lift<E1, A1>(operator: Operator<E1, A1>): Observable<E1, A1>;
+    subscribe(observer?: Partial<Observer<E, A>>): Subscription;
+    subscribe(observer?: (value: A) => void): Subscription;
+    protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer;
+    protected subscribeInternal(subscriber: Subscriber<E, A>): Finalizer;
+}
+export declare const EMPTY: Observable<never, never>;
+export declare function isObservable(u: unknown): u is Observable<unknown, unknown>;

package/Observable/dom/animationFrames.d.ts

@@ -0,0 +1,6 @@
+import { TimestampProvider } from "@fncts/observable/internal/timestampProvider";
+import { Observable } from "@fncts/observable/Observable";
+export declare function animationFrames(timestampProvider?: TimestampProvider): Observable<never, {
+    timestamp: number;
+    elapsed: number;
+}>;

package/Observable/instances.d.ts

@@ -0,0 +1 @@
+export {};

package/Observable.d.ts

@@ -0,0 +1,19 @@
+export * from "./Observable/api.js";
+export * from "./Observable/definition.js";
+export * from "./Observable/instances.js";
+export * from "./Observable/api/connect.js";
+export * from "./Observable/api/connectable.js";
+export * from "./Observable/api/fromCallback.js";
+export * from "./Observable/api/fromEvent.js";
+export * from "./Observable/api/index.js";
+export * from "./Observable/api/race.js";
+export * from "./Observable/api/raceWith.js";
+export * from "./Observable/api/repeatWhen.js";
+export * from "./Observable/api/retryWhen.js";
+export * from "./Observable/api/share.js";
+export * from "./Observable/api/window.js";
+export * from "./Observable/api/windowCount.js";
+export * from "./Observable/api/windowTime.js";
+export * from "./Observable/api/windowToggle.js";
+export * from "./Observable/api/windowWhen.js";
+export * from "./Observable/dom/animationFrames.js";

package/Observer.d.ts

@@ -0,0 +1,6 @@
+import { Cause } from "@fncts/base/data/Cause";
+export interface Observer<E, A> {
+    next: (value: A) => void;
+    error: (err: Cause<E>) => void;
+    complete: () => void;
+}

package/Operator.d.ts

@@ -0,0 +1,19 @@
+import { Subscriber } from "@fncts/observable/Subscriber";
+import { Finalizer } from "@fncts/observable/Subscription";
+import { Observer } from "@fncts/observable/Observer";
+import { Cause } from "@fncts/base/data/Cause";
+import { Observable } from "@fncts/observable/Observable";
+export interface Operator<E, A> {
+    call(subscriber: Subscriber<E, A>, source: any): Finalizer;
+}
+export declare class OperatorSubscriber<E, A> extends Subscriber<E, A> {
+    private onFinalize?;
+    constructor(destination: Subscriber<any, any>, observer: Partial<Observer<E, A>>, onFinalize?: (() => void) | undefined);
+    unsubscribe(): void;
+}
+export declare function operatorSubscriber<E, A, E1, A1>(destination: Subscriber<E1, A1>, observer: Partial<Observer<E, A>>, onFinalize?: () => void): OperatorSubscriber<E, A>;
+/**
+ * @tsplus fluent fncts.observable.Observable operate
+ * @tsplus location "@fncts/observable/Operator"
+ */
+export declare function operate_<E, A, E1, A1>(source: Observable<E, A>, f: (source: Observable<E, A>, subscriber: Subscriber<E1, A1>) => (() => void) | void): Observable<E1, A1>;

package/Scheduler.d.ts

@@ -0,0 +1,22 @@
+import { TimestampProvider } from "@fncts/observable/internal/timestampProvider";
+import { Subscription } from "@fncts/observable/Subscription";
+import { Action } from "@fncts/observable/Action";
+import { Subscriber } from "@fncts/observable/Subscriber";
+export interface SchedulerLike extends TimestampProvider {
+    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
+}
+export interface SchedulerAction<T> extends Subscription {
+    schedule(state?: T, delay?: number): Subscription;
+}
+export declare const SchedulerTypeId: unique symbol;
+export declare type SchedulerTypeId = typeof SchedulerTypeId;
+export declare class Scheduler implements SchedulerLike {
+    private actionConstructor;
+    readonly [SchedulerTypeId]: SchedulerTypeId;
+    now: () => number;
+    constructor(actionConstructor: typeof Action, now?: () => number);
+    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
+    static now: () => number;
+}
+export declare function isScheduler(u: unknown): u is Scheduler;
+export declare function caughtSchedule<E, A>(subscriber: Subscriber<E, A>, scheduler: SchedulerLike, execute: (this: SchedulerAction<any>) => void, delay?: number): Subscription;

package/Subject.d.ts

@@ -0,0 +1,48 @@
+import { Observer } from "@fncts/observable/Observer";
+import { Subscribable, Observable } from "@fncts/observable/Observable";
+import { SubscriptionLike, Finalizer, Subscription } from "@fncts/observable/Subscription";
+import { Cause } from "@fncts/base/data/Cause";
+import { Operator } from "@fncts/observable/Operator";
+import { Subscriber } from "@fncts/observable/Subscriber";
+import { Either } from "@fncts/base/data/Either";
+export interface SubjectLike<E, A> extends Observer<E, A>, Subscribable<E, A> {
+}
+export declare class Subject<E, A> extends Observable<E, A> implements SubscriptionLike {
+    closed: boolean;
+    protected observers: Array<Observer<E, A>>;
+    protected isStopped: boolean;
+    protected hasError: boolean;
+    protected thrownError: Cause<E>;
+    constructor();
+    lift<E1, B>(operator: Operator<E1, B>): Observable<E1, B>;
+    next(value: A): void;
+    error(err: Cause<E>): void;
+    complete(): void;
+    unsubscribe(): void;
+    get observed(): boolean;
+    protected throwIfClosed(): void;
+    protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer;
+    protected subscribeInternal(subscriber: Subscriber<E, A>): Subscription;
+    protected innerSubscribe(subscriber: Subscriber<E, A>): Subscription;
+    protected checkFinalizedStatuses(subscriber: Subscriber<any, any>): void;
+    asObservable(): Observable<E, A>;
+}
+export declare class AnonymousSubject<E, A> extends Subject<E, A> {
+    protected destination?: import("./Observer").Observer<E, A> | undefined;
+    constructor(destination?: import("./Observer").Observer<E, A> | undefined, source?: Observable<E, A>);
+    next(value: A): void;
+    error(err: Cause<E>): void;
+    complete(): void;
+    /** @internal */
+    protected subscribeInternal<E, A>(subscriber: Subscriber<E, A>): import("./Subscription").Subscription;
+}
+export declare class AsyncSubject<E, A> extends Subject<E, A> {
+    private value;
+    private hasValue;
+    private isComplete;
+    /** @internal */
+    protected checkFinalizedStatuses(subscriber: Subscriber<E, A>): void;
+    next(value: A): void;
+    error(err: Cause<E>): void;
+    complete(): void;
+}

package/Subscriber.d.ts

@@ -0,0 +1,27 @@
+import { Subscription, isSubscription } from "@fncts/observable/Subscription";
+import { Observer } from "@fncts/observable/Observer";
+import { Cause } from "@fncts/base/data/Cause";
+import { isFunction } from "@fncts/base/util/predicates";
+import { noop } from "@fncts/observable/internal/util";
+export declare const SubscriberTypeId: unique symbol;
+export declare type SubscriberTypeId = typeof SubscriberTypeId;
+export declare class Subscriber<E, A> extends Subscription implements Observer<E, A> {
+    readonly [SubscriberTypeId]: SubscriberTypeId;
+    private isStopped;
+    protected observer: Subscriber<E, A> | Observer<E, A> | null;
+    constructor(observer?: Subscriber<E, A> | Observer<E, A>);
+    next(value: A): void;
+    error(err: Cause<E>): void;
+    complete(): void;
+    unsubscribe(): void;
+    _next(value: A): void;
+    _error(err: Cause<E>): void;
+    _complete(): void;
+}
+export declare class SafeSubscriber<E, A> extends Subscriber<E, A> {
+    constructor(observer?: Partial<Observer<E, A>> | ((value: A) => void));
+}
+export declare const EMPTY_OBSERVER: Readonly<Observer<any, any>> & {
+    closed: true;
+};
+export declare function isSubscriber(u: unknown): u is Subscriber<any, any>;

package/Subscription.d.ts

@@ -0,0 +1,41 @@
+export interface Unsubscribable {
+    readonly unsubscribe: () => void;
+}
+export interface SubscriptionLike extends Unsubscribable {
+    readonly closed: boolean;
+}
+export declare type Finalizer = Unsubscribable | (() => void) | void;
+export declare const SubscriptionTypeId: unique symbol;
+export declare type SubscriptionTypeId = typeof SubscriptionTypeId;
+/**
+ * @tsplus type fncts.observable.Subscription
+ * @tsplus companion fncts.observable.SubscriptionOps
+ */
+export declare class Subscription implements SubscriptionLike {
+    private initialFinalizer?;
+    readonly [SubscriptionTypeId]: SubscriptionTypeId;
+    closed: boolean;
+    private finalizers;
+    private parents;
+    constructor(initialFinalizer?: (() => void) | undefined);
+    unsubscribe(): void;
+    add(finalizer: Finalizer): void;
+    private hasParent;
+    private addParent;
+    private removeParent;
+    remove(finalizer: Finalizer): void;
+}
+export declare function isSubscription(u: unknown): u is Subscription;
+/**
+ * @tsplus static fncts.observable.SubscriptionOps empty
+ * @tsplus location "@fncts/observable/Subscription"
+ */
+export declare const EMPTY_SUBSCRIPTION: Subscription;
+export declare const UnsubscribeErrorTypeId: unique symbol;
+export declare type UnsubscribeErrorTypeId = typeof UnsubscribeErrorTypeId;
+export declare class UnsubscribeError {
+    readonly errors: unknown[];
+    readonly [UnsubscribeErrorTypeId]: UnsubscribeErrorTypeId;
+    constructor(errors: unknown[]);
+}
+export declare function isUnsubscribeError(u: unknown): u is UnsubscribeError;

package/_cjs/Action.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Action = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Subscription"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+class Action extends tsplus_module_1.Subscription {
+  constructor(scheduler, work) {
+    super();
+  }
+
+  schedule(state, delay = 0) {
+    return this;
+  }
+
+}
+
+exports.Action = Action;
+//# sourceMappingURL=Action.cjs.map

package/_cjs/Action.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.cjs","mappings":";;;;;;;;;;;;;AAAA;AACM,MAAOA,MAAP,SAAyBC,4BAAzB,CAAqC;EACzCC,YAAYC,SAAZ,EAAkCC,IAAlC,EAAqF;IACnF;EACD;;EAEMC,QAAQ,CAACC,KAAD,EAAYC,KAAK,GAAG,CAApB,EAAqB;IAClC,OAAO,IAAP;EACD;;AAPwC","names":["Action","tsplus_module_1","constructor","scheduler","work","schedule","state","delay"],"sourceRoot":"","sources":["../_src/Action.ts"],"sourcesContent":[null]}

package/_cjs/AnimationFrameAction.cjs

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnimationFrameAction = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AsyncAction"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/internal/animationFrameProvider"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class AnimationFrameAction extends tsplus_module_1.AsyncAction {
+  constructor(scheduler, work) {
+    super(scheduler, work);
+    this.scheduler = scheduler;
+    this.work = work;
+  }
+
+  requestAsyncId(scheduler, delay = 0) {
+    if (delay != null && delay > 0) {
+      return super.requestAsyncId(scheduler, delay);
+    }
+
+    scheduler.actions.push(this);
+    return scheduler.scheduled || (scheduler.scheduled = tsplus_module_2.animationFrameProvider.requestAnimationFrame(() => scheduler.flush(undefined)));
+  }
+
+  recycleAsyncId(scheduler, id, delay = 0) {
+    if (delay != null && delay > 0 || delay == null && this.delay > 0) {
+      super.recycleAsyncId(scheduler, delay);
+    }
+
+    if (scheduler.actions.length === 0) {
+      tsplus_module_2.animationFrameProvider.cancelAnimationFrame(id);
+      scheduler.scheduled = undefined;
+    }
+
+    return undefined;
+  }
+
+}
+
+exports.AnimationFrameAction = AnimationFrameAction;
+//# sourceMappingURL=AnimationFrameAction.cjs.map

package/_cjs/AnimationFrameAction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationFrameAction.cjs","mappings":";;;;;;;;;;;;;;;AAAM,MAAOA,oBAAP,SAAuCC,2BAAvC,CAAqD;EACzDC,YACYC,SADZ,EAEYC,IAFZ,EAE+D;IAE7D,MAAMD,SAAN,EAAiBC,IAAjB;IAHU;IACA;EAGX;;EAESC,cAAc,CAACF,SAAD,EAAqCG,KAAK,GAAG,CAA7C,EAA8C;IACpE,IAAIA,KAAK,IAAI,IAAT,IAAiBA,KAAK,GAAG,CAA7B,EAAgC;MAC9B,OAAO,MAAMD,cAAN,CAAqBF,SAArB,EAAgCG,KAAhC,CAAP;IACD;;IACDH,SAAS,CAACI,OAAV,CAAkBC,IAAlB,CAAuB,IAAvB;IACA,OAAQL,SAAS,CAACM,SAAV,cAAS,CAACA,SAAV,GAAwBC,uCAAuBC,qBAAvB,CAA6C,MAAMR,SAAS,CAACS,KAAV,CAAgBC,SAAhB,CAAnD,CAAxB,CAAR;EACD;;EAESC,cAAc,CAACX,SAAD,EAAqCY,EAArC,EAA+CT,KAAK,GAAG,CAAvD,EAAwD;IAC9E,IAAKA,KAAK,IAAI,IAAT,IAAiBA,KAAK,GAAG,CAA1B,IAAiCA,KAAK,IAAI,IAAT,IAAiB,KAAKA,KAAL,GAAc,CAApE,EAAwE;MACtE,MAAMQ,cAAN,CAAqBX,SAArB,EAAgCG,KAAhC;IACD;;IACD,IAAIH,SAAS,CAACI,OAAV,CAAkBS,MAAlB,KAA6B,CAAjC,EAAoC;MAClCN,uCAAuBO,oBAAvB,CAA4CF,EAA5C;MACAZ,SAAS,CAACM,SAAV,GAAsBI,SAAtB;IACD;;IACD,OAAOA,SAAP;EACD;;AAzBwD","names":["AnimationFrameAction","tsplus_module_1","constructor","scheduler","work","requestAsyncId","delay","actions","push","scheduled","tsplus_module_2","requestAnimationFrame","flush","undefined","recycleAsyncId","id","length","cancelAnimationFrame"],"sourceRoot":"","sources":["../_src/AnimationFrameAction.ts"],"sourcesContent":[null]}

package/_cjs/AnimationFrameScheduler.cjs

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.animationFrameScheduler = exports.AnimationFrameScheduler = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AsyncScheduler"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AnimationFrameAction"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/* eslint-disable no-param-reassign */
+class AnimationFrameScheduler extends tsplus_module_1.AsyncScheduler {
+  flush(action) {
+    this.active = true;
+    this.scheduled = undefined;
+    const {
+      actions
+    } = this;
+    let error;
+    let index = -1;
+    action = action || actions.shift();
+    const count = actions.length;
+
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      }
+    } while (++index < count && (action = actions.shift()));
+
+    this.active = false;
+
+    if (error) {
+      while (++index < count && (action = actions.shift())) {
+        action.unsubscribe();
+      }
+
+      throw error;
+    }
+  }
+
+}
+
+exports.AnimationFrameScheduler = AnimationFrameScheduler;
+const animationFrameScheduler = /*#__PURE__*/new AnimationFrameScheduler(tsplus_module_2.AnimationFrameAction);
+exports.animationFrameScheduler = animationFrameScheduler;
+//# sourceMappingURL=AnimationFrameScheduler.cjs.map

package/_cjs/AnimationFrameScheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationFrameScheduler.cjs","mappings":";;;;;;;;;;;;;;;AAAA;AACM,MAAOA,uBAAP,SAAuCC,8BAAvC,CAAqD;EAClDC,KAAK,CAACC,MAAD,EAA0B;IACpC,KAAKC,MAAL,GAAiB,IAAjB;IACA,KAAKC,SAAL,GAAiBC,SAAjB;IAEA,MAAM;MAAEC;IAAF,IAAc,IAApB;IACA,IAAIC,KAAJ;IACA,IAAIC,KAAK,GAAW,CAAC,CAArB;IACAN,MAAM,GAAcA,MAAM,IAAII,OAAO,CAACG,KAAR,EAA9B;IACA,MAAMC,KAAK,GAASJ,OAAO,CAACK,MAA5B;;IAEA,GAAG;MACD,IAAKJ,KAAK,GAAGL,MAAM,CAACU,OAAP,CAAeV,MAAM,CAACW,KAAtB,EAA6BX,MAAM,CAACY,KAApC,CAAb,EAA2D;QACzD;MACD;IACF,CAJD,QAIS,EAAEN,KAAF,GAAUE,KAAV,KAAoBR,MAAM,GAAGI,OAAO,CAACG,KAAR,EAA7B,CAJT;;IAMA,KAAKN,MAAL,GAAc,KAAd;;IAEA,IAAII,KAAJ,EAAW;MACT,OAAO,EAAEC,KAAF,GAAUE,KAAV,KAAoBR,MAAM,GAAGI,OAAO,CAACG,KAAR,EAA7B,CAAP,EAAsD;QACpDP,MAAM,CAACa,WAAP;MACD;;MACD,MAAMR,KAAN;IACD;EACF;;AAzBwD;;;AA4BpD,MAAMS,uBAAuB,gBAAG,IAAIjB,uBAAJ,CAA2BkB,gBAACC,oBAA5B,CAAhC","names":["AnimationFrameScheduler","tsplus_module_1","flush","action","active","scheduled","undefined","actions","error","index","shift","count","length","execute","state","delay","unsubscribe","animationFrameScheduler","tsplus_module_2","AnimationFrameAction"],"sourceRoot":"","sources":["../_src/AnimationFrameScheduler.ts"],"sourcesContent":[null]}

package/_cjs/AsyncAction.cjs

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AsyncAction = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Action"));
+
+var _intervalProvider = /*#__PURE__*/require("@fncts/observable/internal/intervalProvider");
+
+var _util = /*#__PURE__*/require("@fncts/observable/internal/util");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class AsyncAction extends tsplus_module_1.Action {
+  constructor(scheduler, work) {
+    super(scheduler, work);
+    this.scheduler = scheduler;
+    this.work = work;
+    this.pending = false;
+  }
+
+  schedule(state, delay = 0) {
+    if (this.closed) {
+      return this;
+    }
+
+    this.state = state;
+    const id = this.id;
+    const scheduler = this.scheduler;
+
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay);
+    }
+
+    this.pending = true;
+    this.delay = delay;
+    this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);
+    return this;
+  }
+
+  requestAsyncId(scheduler, _id, delay = 0) {
+    return _intervalProvider.intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  }
+
+  recycleAsyncId(_scheduler, id, delay = 0) {
+    if (delay != null && this.delay === delay && this.pending === false) {
+      return id;
+    }
+
+    _intervalProvider.intervalProvider.clearInterval(id);
+
+    return undefined;
+  }
+
+  execute(state, delay) {
+    if (this.closed) {
+      throw new Error("executing a cancelled action");
+    }
+
+    this.pending = false;
+    const error = this.executeInternal(state, delay);
+
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  }
+
+  executeInternal(state, _delay) {
+    let errored = false;
+    let errorValue;
+
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = true;
+      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;
+      (0, _util.arrayRemove)(actions, this);
+
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+
+      this.delay = null;
+      super.unsubscribe();
+    }
+  }
+
+}
+
+exports.AsyncAction = AsyncAction;
+//# sourceMappingURL=AsyncAction.cjs.map

package/_cjs/AsyncAction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncAction.cjs","mappings":"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","names":["AsyncAction","tsplus_module_1","constructor","scheduler","work","schedule","state","delay","closed","id","recycleAsyncId","pending","requestAsyncId","_id","intervalProvider","setInterval","flush","bind","_scheduler","clearInterval","undefined","execute","Error","error","executeInternal","_delay","errored","errorValue","e","unsubscribe","actions"],"sourceRoot":"","sources":["../_src/AsyncAction.ts"],"sourcesContent":[null]}

package/_cjs/AsyncScheduler.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncScheduler = exports.AsyncScheduler = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Scheduler"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AsyncAction"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class AsyncScheduler extends tsplus_module_1.Scheduler {
+  constructor(actionConstructor, now = tsplus_module_1.Scheduler.now) {
+    super(actionConstructor, now);
+    this.actions = [];
+    this.active = false;
+    this.scheduled = undefined;
+  }
+
+  flush(action) {
+    const {
+      actions
+    } = this;
+
+    if (this.active) {
+      actions.push(action);
+      return;
+    }
+
+    let error;
+    this.active = true;
+
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      } // eslint-disable-next-line no-param-reassign
+
+    } while (action = actions.shift());
+
+    this.active = false;
+
+    if (error) {
+      // eslint-disable-next-line no-param-reassign
+      while (action = actions.shift()) {
+        action.unsubscribe();
+      }
+
+      throw error;
+    }
+  }
+
+}
+
+exports.AsyncScheduler = AsyncScheduler;
+const asyncScheduler = /*#__PURE__*/new AsyncScheduler(tsplus_module_2.AsyncAction);
+exports.asyncScheduler = asyncScheduler;
+//# sourceMappingURL=AsyncScheduler.cjs.map

package/_cjs/AsyncScheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncScheduler.cjs","mappings":";;;;;;;;;;;;;;;AAAM,MAAOA,cAAP,SAA8BC,yBAA9B,CAAuC;EAM3CC,YAAYC,iBAAZ,EAA8CC,MAAoBH,0BAAUG,GAA5E,EAA+E;IAC7E,MAAMD,iBAAN,EAAyBC,GAAzB;IANK,eAAmC,EAAnC;IAEP,cAAiB,KAAjB;IACA,iBAAiBC,SAAjB;EAIC;;EAEDC,KAAK,CAACC,MAAD,EAAyB;IAC5B,MAAM;MAAEC;IAAF,IAAc,IAApB;;IAEA,IAAI,KAAKC,MAAT,EAAiB;MACfD,OAAO,CAACE,IAAR,CAAaH,MAAb;MACA;IACD;;IAED,IAAII,KAAJ;IACA,KAAKF,MAAL,GAAc,IAAd;;IAEA,GAAG;MACD,IAAKE,KAAK,GAAGJ,MAAM,CAACK,OAAP,CAAeL,MAAM,CAACM,KAAtB,EAA6BN,MAAM,CAACO,KAApC,CAAb,EAA2D;QACzD;MACD,CAHA,CAID;;IACD,CALD,QAKUP,MAAM,GAAGC,OAAO,CAACO,KAAR,EALnB;;IAOA,KAAKN,MAAL,GAAc,KAAd;;IAEA,IAAIE,KAAJ,EAAW;MACT;MACA,OAAQJ,MAAM,GAAGC,OAAO,CAACO,KAAR,EAAjB,EAAoC;QAClCR,MAAM,CAACS,WAAP;MACD;;MACD,MAAML,KAAN;IACD;EACF;;AArC0C;;;AAwCtC,MAAMM,cAAc,gBAAG,IAAIjB,cAAJ,CAAkBkB,gBAACC,WAAnB,CAAvB","names":["AsyncScheduler","tsplus_module_1","constructor","actionConstructor","now","undefined","flush","action","actions","active","push","error","execute","state","delay","shift","unsubscribe","asyncScheduler","tsplus_module_2","AsyncAction"],"sourceRoot":"","sources":["../_src/AsyncScheduler.ts"],"sourcesContent":[null]}

package/_cjs/BehaviorSubject.cjs

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BehaviorSubject = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Subject"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+class BehaviorSubject extends tsplus_module_1.Subject {
+  constructor(_value) {
+    super();
+    this._value = _value;
+  }
+
+  get value() {
+    return this.getValue();
+  }
+
+  getValue() {
+    const {
+      hasError,
+      thrownError,
+      _value
+    } = this;
+
+    if (hasError) {
+      throw thrownError;
+    }
+
+    this.throwIfClosed();
+    return _value;
+  }
+
+  subscribeInternal(subscriber) {
+    const subscription = super.subscribe(subscriber);
+    !subscription.closed && subscriber.next(this._value);
+    return subscription;
+  }
+
+  next(value) {
+    super.next(this._value = value);
+  }
+
+}
+
+exports.BehaviorSubject = BehaviorSubject;
+//# sourceMappingURL=BehaviorSubject.cjs.map

package/_cjs/BehaviorSubject.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BehaviorSubject.cjs","mappings":";;;;;;;;;;;;;AAAM,MAAOA,eAAP,SAAqCC,uBAArC,CAAkD;EACtDC,YAAoBC,MAApB,EAA6B;IAC3B;IADkB;EAEnB;;EAEQ,IAALC,KAAK;IACP,OAAO,KAAKC,QAAL,EAAP;EACD;;EAEDA,QAAQ;IACN,MAAM;MAAEC,QAAF;MAAYC,WAAZ;MAAyBJ;IAAzB,IAAoC,IAA1C;;IACA,IAAIG,QAAJ,EAAc;MACZ,MAAMC,WAAN;IACD;;IACD,KAAKC,aAAL;IACA,OAAOL,MAAP;EACD;;EAESM,iBAAiB,CAACC,UAAD,EAA6B;IACtD,MAAMC,YAAY,GAAG,MAAMC,SAAN,CAAgBF,UAAhB,CAArB;IACA,CAACC,YAAY,CAACE,MAAd,IAAwBH,UAAU,CAACI,IAAX,CAAgB,KAAKX,MAArB,CAAxB;IACA,OAAOQ,YAAP;EACD;;EAEDG,IAAI,CAACV,KAAD,EAAS;IACX,MAAMU,IAAN,CAAY,KAAKX,MAAL,GAAcC,KAA1B;EACD;;AA1BqD","names":["BehaviorSubject","tsplus_module_1","constructor","_value","value","getValue","hasError","thrownError","throwIfClosed","subscribeInternal","subscriber","subscription","subscribe","closed","next"],"sourceRoot":"","sources":["../_src/BehaviorSubject.ts"],"sourcesContent":[null]}