synstate 0.1.1 → 1.0.0

package/dist/core/create/source.d.mts

@@ -19,30 +19,25 @@ import { type InitializedSourceObservable, type SourceObservable } from '../type
  *
  * const count$ = source<number>();
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * count$.subscribe((value) => {
- *   mut_history.push(value);
+ *   valueHistory.push(value);
  * });
  *
  * count$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * count$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  *
  * count$.next(3); // logs: 3
  *
- * assert.deepStrictEqual(mut_history, [1, 2, 3]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
  * ```
  */
-export declare function source<A>(initialValue: A): InitializedSourceObservable<A>;
-export declare function source<A>(): SourceObservable<A>;
-/**
- * Alias for `source()`. Creates a new Observable source.
- * @see source
- */
-export declare const subject: typeof source;
+export declare function source<const A>(initialValue: A): InitializedSourceObservable<A>;
+export declare function source<const A>(): SourceObservable<A>;
 //# sourceMappingURL=source.d.mts.map

package/dist/core/create/source.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"source.d.mts","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAE3E,wBAAgB,MAAM,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAMjD;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAS,CAAC"}
+{"version":3,"file":"source.d.mts","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,MAAM,CAAC,KAAK,CAAC,CAAC,EAC5B,YAAY,EAAE,CAAC,GACd,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAElC,wBAAgB,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC"}

package/dist/core/create/source.mjs

@@ -5,11 +5,6 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
 function source(...args) {
     return new SourceObservableClass(...args);
 }
-/**
- * Alias for `source()`. Creates a new Observable source.
- * @see source
- */
-const subject = source; // alias
 class SourceObservableClass extends RootObservableClass {
     constructor(...args) {
         super({
@@ -25,5 +20,5 @@ class SourceObservableClass extends RootObservableClass {
     }
 }
 
-export { source, subject };
+export { source };
 //# sourceMappingURL=source.mjs.map

package/dist/core/create/source.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkDM,SAAU,MAAM,CAAI,GAAG,IAAkB,EAAA;AAC7C,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA;;;AAGG;AACI,MAAM,OAAO,GAAG,OAAO;AAE9B,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}
+{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAoDM,SAAU,MAAM,CAAU,GAAG,IAAkB,EAAA;AACnD,IAAA,OAAO,IAAI,qBAAqB,CAAI,GAAG,IAAI,CAAC;AAC9C;AAEA,MAAM,qBACJ,SAAQ,mBAAsB,CAAA;AAG9B,IAAA,WAAA,CAAY,GAAG,IAAkB,EAAA;AAC/B,QAAA,KAAK,CAAC;AACJ,YAAA,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI;kBAC7B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;kBACrB,QAAQ,CAAC,IAAI;AAClB,SAAA,CAAC;IACJ;AAEA,IAAA,IAAI,CAAC,SAAY,EAAA;QACf,IAAI,IAAI,CAAC,WAAW;YAAE;AAEtB,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IAC7B;AACD;;;;"}

package/dist/core/create/timer.d.mts

@@ -19,12 +19,12 @@ import { type TimerObservable } from '../types/index.mjs';
  *
  * const delayed$ = timer(100);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   delayed$.subscribe(
  *     () => {
- *       mut_history.push(1);
+ *       valueHistory.push(1);
  *     },
  *     () => {
  *       resolve();
@@ -32,8 +32,10 @@ import { type TimerObservable } from '../types/index.mjs';
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  * ```
  */
-export declare const timer: (milliSeconds: number, startManually?: boolean) => TimerObservable;
+export declare const timer: (milliSeconds: number, options?: Readonly<{
+    startManually?: boolean;
+}>) => TimerObservable;
 //# sourceMappingURL=timer.d.mts.map

package/dist/core/create/timer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,MAAM,EACpB,gBAAe,OAAe,KAC7B,eAAwE,CAAC"}
+{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,MAAM,EACpB,UAAU,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eACsE,CAAC"}

package/dist/core/create/timer.mjs

@@ -22,12 +22,12 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *
  * const delayed$ = timer(100);
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * await new Promise<void>((resolve) => {
  *   delayed$.subscribe(
  *     () => {
- *       mut_history.push(1);
+ *       valueHistory.push(1);
  *     },
  *     () => {
  *       resolve();
@@ -35,10 +35,10 @@ import { RootObservableClass } from '../class/root-observable-class.mjs';
  *   );
  * });
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  * ```
  */
-const timer = (milliSeconds, startManually = false) => new TimerObservableClass(milliSeconds, startManually);
+const timer = (milliSeconds, options) => new TimerObservableClass(milliSeconds, options?.startManually ?? false);
 class TimerObservableClass extends RootObservableClass {
     #milliSeconds;
     #mut_timerId;
@@ -55,18 +55,17 @@ class TimerObservableClass extends RootObservableClass {
     start() {
         if (this.#mut_isStarted) {
             console.warn('cannot start twice');
-            return this;
+            return;
         }
         this.#mut_isStarted = true;
         if (this.isCompleted) {
             console.warn('cannot restart stopped TimerObservable');
-            return this;
+            return;
         }
         this.#mut_timerId = setTimeout(() => {
             this.startUpdate(0);
             this.complete();
         }, this.#milliSeconds);
-        return this;
     }
     #resetTimer() {
         if (this.#mut_timerId !== undefined) {

package/dist/core/create/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACI,MAAM,KAAK,GAAG,CACnB,YAAoB,EACpB,aAAA,GAAyB,KAAK,KACV,IAAI,oBAAoB,CAAC,YAAY,EAAE,aAAa;AAE1E,MAAM,oBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAsB,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;AAElC,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC;AAEtD,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnB,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;AAEtB,QAAA,OAAO,IAAI;IACb;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}
+{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,KAAK,GAAG,CACnB,YAAoB,EACpB,OAEE,KAEF,IAAI,oBAAoB,CAAC,YAAY,EAAE,OAAO,EAAE,aAAa,IAAI,KAAK;AAExE,MAAM,oBACJ,SAAQ,mBAAsB,CAAA;AAGrB,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,cAAc;IAEd,WAAA,CAAY,YAAoB,EAAE,aAAsB,EAAA;QACtD,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;AAEtC,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;AAEjC,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;QAE3B,IAAI,CAAC,aAAa,EAAE;YAClB,IAAI,CAAC,KAAK,EAAE;QACd;IACF;IAEA,KAAK,GAAA;AACH,QAAA,IAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAA,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC;YAElC;QACF;AAEA,QAAA,IAAI,CAAC,cAAc,GAAG,IAAI;AAE1B,QAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,YAAA,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC;YAEtD;QACF;AAEA,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnB,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/index.d.mts

@@ -2,6 +2,6 @@ export * from './class/index.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';
+export * from './predefined/index.mjs';
 export * from './types/index.mjs';
-export * from './utils/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/core/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

package/dist/core/index.mjs

@@ -4,34 +4,41 @@ export { RootObservableClass } from './class/root-observable-class.mjs';
 export { combine, combineLatest } from './combine/combine.mjs';
 export { merge } from './combine/merge.mjs';
 export { zip } from './combine/zip.mjs';
-export { fromArray } from './create/from-array.mjs';
+export { counter } from './create/counter.mjs';
+export { fromAbortablePromise } from './create/from-abortable-promise.mjs';
 export { fromPromise } from './create/from-promise.mjs';
 export { fromSubscribable } from './create/from-subscribable.mjs';
-export { interval } from './create/interval.mjs';
-export { of } from './create/of.mjs';
-export { source, subject } from './create/source.mjs';
+export { just } from './create/just.mjs';
+export { source } from './create/source.mjs';
 export { timer } from './create/timer.mjs';
-export { auditTime } from './operators/audit-time.mjs';
-export { debounceTime } from './operators/debounce-time.mjs';
+export { audit } from './operators/audit.mjs';
+export { debounce } from './operators/debounce.mjs';
 export { filter } from './operators/filter.mjs';
-export { attachIndex, getKey, map, mapOptional, mapResultErr, mapResultOk, mapTo, mapWithIndex, pluck, unwrapOptional, unwrapResultErr, unwrapResultOk, withIndex } from './operators/map-with-index.mjs';
+export { map } from './operators/map.mjs';
 export { flatMap, mergeMap } from './operators/merge-map.mjs';
 export { pairwise } from './operators/pairwise.mjs';
 export { scan } from './operators/scan.mjs';
 export { distinctUntilChanged, skipIfNoChange } from './operators/skip-if-no-change.mjs';
 export { skipUntil } from './operators/skip-until.mjs';
-export { skip, skipWhile } from './operators/skip-while.mjs';
+export { skipWhile } from './operators/skip-while.mjs';
 export { switchMap } from './operators/switch-map.mjs';
 export { takeUntil } from './operators/take-until.mjs';
-export { take, takeWhile } from './operators/take-while.mjs';
-export { throttleTime } from './operators/throttle-time.mjs';
+export { takeWhile } from './operators/take-while.mjs';
+export { throttle } from './operators/throttle.mjs';
 export { withBuffered, withBufferedFrom } from './operators/with-buffered-from.mjs';
 export { withCurrentValueFrom, withLatestFrom } from './operators/with-current-value-from.mjs';
 export { withInitialValue } from './operators/with-initial-value.mjs';
+export { attachIndex, withIndex } from './predefined/operators/attach-index.mjs';
+export { mapOptional } from './predefined/operators/map-optional.mjs';
+export { mapResultErr } from './predefined/operators/map-result-err.mjs';
+export { mapResultOk } from './predefined/operators/map-result-ok.mjs';
+export { mapTo } from './predefined/operators/map-to.mjs';
+export { getKey, pluck } from './predefined/operators/pluck.mjs';
+export { skip } from './predefined/operators/skip.mjs';
+export { take } from './predefined/operators/take.mjs';
+export { unwrapOptional } from './predefined/operators/unwrap-optional.mjs';
+export { unwrapResultErr } from './predefined/operators/unwrap-result-err.mjs';
+export { unwrapResultOk } from './predefined/operators/unwrap-result-ok.mjs';
 import 'ts-data-forge';
 export { isChildObservable, isManagerObservable, isRootObservable } from './types/observable.mjs';
-export { issueObservableId, issueSubscriberId, issueUpdaterSymbol } from './utils/id-maker.mjs';
-export { maxDepth } from './utils/max-depth.mjs';
-export { toSubscriber } from './utils/observable-utils.mjs';
-export { binarySearch, halfInt } from './utils/utils.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/core/operators/audit.d.mts

@@ -0,0 +1,97 @@
+import { type KeepInitialValueOperator } from '../types/index.mjs';
+/**
+ * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.
+ *
+ * Unlike `throttle` which emits the first value, `audit` emits the last value.
+ *
+ * @template A - The type of values from the source
+ * @param milliSeconds - The audit time window in milliseconds
+ * @returns An operator that audits emissions from the observable
+ *
+ * @example
+ * ```ts
+ * //  Timeline (250ms audit):
+ * //
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->
+ * //  audited$               2           3                   11          14   (emitted at end of window)
+ * //
+ * //  Explanation:
+ * //  - audit emits the LAST value received during each time window
+ * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST
+ * //  - Useful when you want the most recent value after a burst of events
+ *
+ * const input$ = source<number>();
+ *
+ * const audited$ = input$.pipe(audit(250));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * audited$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
+ *
+ * input$.next(0);
+ *
+ * await sleep(200);
+ *
+ * input$.next(2);
+ *
+ * assert.deepStrictEqual(valueHistory, []);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2]);
+ *
+ * input$.next(3);
+ *
+ * await sleep(300);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3]);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * input$.next(12);
+ *
+ * await sleep(100);
+ *
+ * input$.next(13);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(14);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);
+ * ```
+ */
+export declare const audit: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
+//# sourceMappingURL=audit.d.mts.map

package/dist/core/operators/audit.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.mts","sourceRoot":"","sources":["../../../src/core/operators/audit.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/audit.mjs

@@ -0,0 +1,144 @@
+import { Optional } from 'ts-data-forge';
+import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.
+ *
+ * Unlike `throttle` which emits the first value, `audit` emits the last value.
+ *
+ * @template A - The type of values from the source
+ * @param milliSeconds - The audit time window in milliseconds
+ * @returns An operator that audits emissions from the observable
+ *
+ * @example
+ * ```ts
+ * //  Timeline (250ms audit):
+ * //
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->
+ * //  audited$               2           3                   11          14   (emitted at end of window)
+ * //
+ * //  Explanation:
+ * //  - audit emits the LAST value received during each time window
+ * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST
+ * //  - Useful when you want the most recent value after a burst of events
+ *
+ * const input$ = source<number>();
+ *
+ * const audited$ = input$.pipe(audit(250));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * audited$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
+ *
+ * input$.next(0);
+ *
+ * await sleep(200);
+ *
+ * input$.next(2);
+ *
+ * assert.deepStrictEqual(valueHistory, []);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2]);
+ *
+ * input$.next(3);
+ *
+ * await sleep(300);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3]);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * input$.next(12);
+ *
+ * await sleep(100);
+ *
+ * input$.next(13);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(14);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11]);
+ *
+ * await sleep(100);
+ *
+ * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);
+ * ```
+ */
+const audit = (milliSeconds) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+((parentObservable) => new AuditObservableClass(parentObservable, milliSeconds));
+class AuditObservableClass extends AsyncChildObservableClass {
+    #milliSeconds;
+    #mut_timerId;
+    #mut_isSkipping;
+    constructor(parentObservable, milliSeconds) {
+        super({
+            parents: [parentObservable],
+            initialValue: parentObservable.getSnapshot(),
+        });
+        this.#mut_isSkipping = false;
+        this.#mut_timerId = undefined;
+        this.#milliSeconds = milliSeconds;
+    }
+    tryUpdate(updateToken) {
+        const par = this.parents[0];
+        if (par.updateToken !== updateToken ||
+            Optional.isNone(par.getSnapshot()) ||
+            this.#mut_isSkipping) {
+            return; // skip update
+        }
+        // set timer
+        this.#mut_isSkipping = true;
+        this.#mut_timerId = setTimeout(() => {
+            const sn = par.getSnapshot();
+            if (Optional.isNone(sn))
+                return;
+            this.startUpdate(sn.value);
+            this.#mut_isSkipping = false;
+        }, this.#milliSeconds);
+    }
+    #resetTimer() {
+        if (this.#mut_timerId !== undefined) {
+            clearTimeout(this.#mut_timerId);
+        }
+    }
+    complete() {
+        this.#resetTimer();
+        super.complete();
+    }
+}
+
+export { audit };
+//# sourceMappingURL=audit.mjs.map

package/dist/core/operators/audit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6FG;AACI,MAAM,KAAK,GAAG,CACnB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,oBAAoB,CACtB,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,oBACJ,SAAQ,yBAA0C,CAAA;AAGzC,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAE5B,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;YAClC,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;;AAGA,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;AAE3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,YAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE;AAEzB,YAAA,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC;AAE1B,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/debounce.d.mts

@@ -0,0 +1,88 @@
+import { type KeepInitialValueOperator } from '../types/index.mjs';
+/**
+ * Delays emissions from the source observable until a specified time has passed without another emission.
+ * Useful for handling user input events like typing or scrolling.
+ *
+ * @template A - The type of values from the source
+ * @param milliSeconds - The debounce duration in milliseconds
+ * @returns An operator that debounces the observable
+ *
+ * @example
+ * ```ts
+ * //  Timeline (250ms debounce):
+ * //
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //                               |- 250ms ->                         |- 250ms ->
+ * //  debounced$                   3                                             14   (emitted after 250ms silence)
+ * //
+ * //  Explanation:
+ * //  - debounce emits the latest value AFTER a quiet period with no new emissions
+ * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission
+ * //  - Useful for search-as-you-type and form validation
+ *
+ * const input$ = source<number>();
+ *
+ * const debounced$ = input$.pipe(debounce(250));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * debounced$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
+ *
+ * input$.next(0);
+ *
+ * await sleep(200);
+ *
+ * input$.next(2);
+ *
+ * await sleep(100);
+ *
+ * input$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, []);
+ *
+ * await sleep(300);
+ *
+ * assert.deepStrictEqual(valueHistory, [3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * await sleep(100);
+ *
+ * input$.next(12);
+ *
+ * await sleep(100);
+ *
+ * input$.next(13);
+ *
+ * await sleep(100);
+ *
+ * input$.next(14);
+ *
+ * assert.deepStrictEqual(valueHistory, [3]);
+ *
+ * await sleep(300);
+ *
+ * assert.deepStrictEqual(valueHistory, [3, 14]);
+ * ```
+ */
+export declare const debounce: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
+//# sourceMappingURL=debounce.d.mts.map

package/dist/core/operators/debounce.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}