@fncts/observable 0.0.1

package/index.d.ts

@@ -0,0 +1,14 @@
+export * as action from "@fncts/observable/Action";
+export * as animationFrameAction from "@fncts/observable/AnimationFrameAction";
+export * as animationFrameScheduler from "@fncts/observable/AnimationFrameScheduler";
+export * as asyncAction from "@fncts/observable/AsyncAction";
+export * as asyncScheduler from "@fncts/observable/AsyncScheduler";
+export * as behaviorSubject from "@fncts/observable/BehaviorSubject";
+export * as observable from "@fncts/observable/Observable";
+export * as notification from "@fncts/observable/Observable";
+export * as observer from "@fncts/observable/Observer";
+export * as operator from "@fncts/observable/Operator";
+export * as scheduler from "@fncts/observable/Scheduler";
+export * as subject from "@fncts/observable/Subject";
+export * as subscriber from "@fncts/observable/Subscriber";
+export * as subscription from "@fncts/observable/Subscription";

package/internal/animationFrameProvider.d.ts

@@ -0,0 +1,12 @@
+import { Subscription } from "@fncts/observable/Subscription";
+interface AnimationFrameProvider {
+    schedule(callback: FrameRequestCallback): Subscription;
+    requestAnimationFrame: typeof requestAnimationFrame;
+    cancelAnimationFrame: typeof cancelAnimationFrame;
+    delegate: {
+        requestAnimationFrame: typeof requestAnimationFrame;
+        cancelAnimationFrame: typeof cancelAnimationFrame;
+    } | undefined;
+}
+export declare const animationFrameProvider: AnimationFrameProvider;
+export {};

package/internal/args.d.ts

@@ -0,0 +1,3 @@
+import { SchedulerLike } from "@fncts/observable/Scheduler";
+export declare function popNumber(args: any[], defaultValue: number): number;
+export declare function popScheduler(args: any[]): SchedulerLike | undefined;

package/internal/intervalProvider.d.ts

@@ -0,0 +1,12 @@
+declare type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => number;
+declare type ClearIntervalFunction = (handle: number) => void;
+interface IntervalProvider {
+    setInterval: SetIntervalFunction;
+    clearInterval: ClearIntervalFunction;
+    delegate: {
+        setInterval: SetIntervalFunction;
+        clearInterval: ClearIntervalFunction;
+    } | undefined;
+}
+export declare const intervalProvider: IntervalProvider;
+export {};

package/internal/performanceTimestampProvider.d.ts

@@ -0,0 +1,6 @@
+import type { TimestampProvider } from "./timestampProvider";
+interface PerformanceTimestampProvider extends TimestampProvider {
+    delegate: TimestampProvider | undefined;
+}
+export declare const performanceTimestampProvider: PerformanceTimestampProvider;
+export {};

package/internal/timeoutProvider.d.ts

@@ -0,0 +1,12 @@
+declare type SetTimeoutFunction = (handler: () => void, timeout?: number, ...args: any[]) => number;
+declare type ClearTimeoutFunction = (handle: number) => void;
+interface TimeoutProvider {
+    setTimeout: SetTimeoutFunction;
+    clearTimeout: ClearTimeoutFunction;
+    delegate: {
+        setTimeout: SetTimeoutFunction;
+        clearTimeout: ClearTimeoutFunction;
+    } | undefined;
+}
+export declare const timeoutProvider: TimeoutProvider;
+export {};

package/internal/timestampProvider.d.ts

@@ -0,0 +1,7 @@
+export interface TimestampProvider {
+    now(): number;
+}
+export interface DateTimestampProvider extends TimestampProvider {
+    delegate: TimestampProvider | undefined;
+}
+export declare const dateTimestampProvider: DateTimestampProvider;

package/internal/util.d.ts

@@ -0,0 +1,28 @@
+export declare function arrayRemove<T>(arr: T[] | undefined | null, item: T): void;
+export declare function noop(): void;
+export declare function isAsyncIterable(u: any): u is AsyncIterable<any>;
+export declare function isArrayLike(u: any): u is ArrayLike<any>;
+export declare function isPromiseLike(u: any): u is PromiseLike<any>;
+export declare function isValidDate(u: unknown): u is Date;
+export declare function reportUnhandledError(err: unknown): number;
+export declare function arrayOrObject<T, O extends Record<string, T>>(args: ReadonlyArray<T> | [O] | [ReadonlyArray<T>]): {
+    args: ReadonlyArray<T>;
+    keys: ReadonlyArray<string> | null;
+};
+interface ReadableStreamDefaultReaderLike<T> {
+    read(): PromiseLike<{
+        done: false;
+        value: T;
+    } | {
+        done: true;
+        value?: undefined;
+    }>;
+    releaseLock(): void;
+}
+export interface ReadableStreamLike<T> {
+    getReader(): ReadableStreamDefaultReaderLike<T>;
+}
+export declare function readableStreamToAsyncGenerator<A>(readableStream: ReadableStreamLike<A>): AsyncGenerator<A>;
+export declare function isReadableStream<A>(u: any): u is ReadableStreamLike<A>;
+export declare type Init<A extends ReadonlyArray<unknown>> = A extends [...infer Init, infer Last] ? Init : never;
+export {};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@fncts/observable",
+  "version": "0.0.1",
+  "dependencies": {
+    "@fncts/base": "0.0.12"
+  },
+  "exports": {
+    "./*": {
+      "import": "./_mjs/*.mjs",
+      "require": "./_cjs/*.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}