@signaltree/core 9.3.0 → 9.5.1

package/dist/lib/markers/async-query.js

@@ -0,0 +1,134 @@
+import { signal, inject, DestroyRef, effect, untracked } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { registerMarkerProcessor } from '../internals/materialize-markers.js';
+import { Subject } from '../../Subject.js';
+import { debounceTime } from '../../debounceTime.js';
+import { tap } from '../../tap.js';
+import { filter } from '../../filter.js';
+import { distinctUntilChanged } from '../../distinctUntilChanged.js';
+import { switchMap } from '../../switchMap.js';
+import { isObservable } from '../../isObservable.js';
+import { Observable } from '../../Observable.js';
+import { of } from '../../of.js';
+
+const ASYNC_QUERY_MARKER = Symbol('ASYNC_QUERY_MARKER');
+let asyncQueryRegistered = false;
+function asyncQuery(config) {
+  if (!asyncQueryRegistered) {
+    asyncQueryRegistered = true;
+    registerMarkerProcessor(isAsyncQueryMarker, createAsyncQuerySignal);
+  }
+  return {
+    [ASYNC_QUERY_MARKER]: true,
+    config
+  };
+}
+function isAsyncQueryMarker(value) {
+  return value !== null && typeof value === 'object' && ASYNC_QUERY_MARKER in value && value[ASYNC_QUERY_MARKER] === true;
+}
+function createAsyncQuerySignal(marker) {
+  const {
+    initialInput,
+    initialResult,
+    query,
+    debounce = 0,
+    filter: predicate,
+    equal = Object.is
+  } = marker.config;
+  const inputSignal = signal(initialInput);
+  const resultsSignal = signal(initialResult);
+  const loadingSignal = signal(false);
+  const errorSignal = signal(null);
+  let destroyed = false;
+  const trigger$ = new Subject();
+  let destroyRef = null;
+  try {
+    destroyRef = inject(DestroyRef, {
+      optional: true
+    }) ?? null;
+  } catch {
+    destroyRef = null;
+  }
+  destroyRef?.onDestroy(() => {
+    destroyed = true;
+    trigger$.complete();
+  });
+  const pipeline$ = trigger$.pipe(debounce > 0 ? debounceTime(debounce) : tap(), predicate ? filter(predicate) : tap(), distinctUntilChanged(equal), tap(() => {
+    loadingSignal.set(true);
+    errorSignal.set(null);
+  }), switchMap(input => {
+    try {
+      const r = query(input);
+      if (isObservable(r)) {
+        return r;
+      }
+      return new Observable(subscriber => {
+        r.then(v => {
+          subscriber.next(v);
+          subscriber.complete();
+        }, err => subscriber.error(err));
+      });
+    } catch (err) {
+      return of(undefined).pipe(tap(() => {
+        errorSignal.set(err);
+        loadingSignal.set(false);
+      }));
+    }
+  }), tap({
+    next: value => {
+      if (destroyed) return;
+      resultsSignal.set(value);
+      loadingSignal.set(false);
+    },
+    error: err => {
+      if (destroyed) return;
+      errorSignal.set(err);
+      loadingSignal.set(false);
+    }
+  }));
+  (destroyRef ? pipeline$.pipe(takeUntilDestroyed(destroyRef)) : pipeline$).subscribe({
+    error: err => {
+      if (destroyed) return;
+      errorSignal.set(err);
+      loadingSignal.set(false);
+    }
+  });
+  try {
+    effect(() => {
+      const v = inputSignal();
+      if (v === undefined) return;
+      untracked(() => trigger$.next(v));
+    }, {
+      manualCleanup: false
+    });
+  } catch {}
+  const fn = () => resultsSignal();
+  Object.defineProperty(fn, 'input', {
+    value: inputSignal
+  });
+  Object.defineProperty(fn, 'results', {
+    value: resultsSignal.asReadonly()
+  });
+  Object.defineProperty(fn, 'data', {
+    value: resultsSignal.asReadonly()
+  });
+  Object.defineProperty(fn, 'loading', {
+    value: loadingSignal.asReadonly()
+  });
+  Object.defineProperty(fn, 'error', {
+    value: errorSignal.asReadonly()
+  });
+  fn.rerun = () => {
+    const cur = inputSignal();
+    if (cur !== undefined) trigger$.next(cur);
+  };
+  fn.reset = () => {
+    loadingSignal.set(false);
+    errorSignal.set(null);
+    resultsSignal.set(initialResult);
+    inputSignal.set(initialInput);
+  };
+  return fn;
+}
+
+export { ASYNC_QUERY_MARKER, asyncQuery, createAsyncQuerySignal, isAsyncQueryMarker };

package/dist/lib/markers/async-source.js

@@ -0,0 +1,122 @@
+import { signal, inject, DestroyRef } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { registerMarkerProcessor } from '../internals/materialize-markers.js';
+import { isObservable } from '../../isObservable.js';
+
+const ASYNC_SOURCE_MARKER = Symbol('ASYNC_SOURCE_MARKER');
+let asyncSourceRegistered = false;
+function asyncSource(config) {
+  if (!asyncSourceRegistered) {
+    asyncSourceRegistered = true;
+    registerMarkerProcessor(isAsyncSourceMarker, createAsyncSourceSignal);
+  }
+  return {
+    [ASYNC_SOURCE_MARKER]: true,
+    config
+  };
+}
+function isAsyncSourceMarker(value) {
+  return value !== null && typeof value === 'object' && ASYNC_SOURCE_MARKER in value && value[ASYNC_SOURCE_MARKER] === true;
+}
+function createAsyncSourceSignal(marker) {
+  const {
+    initial,
+    load,
+    lazy = false
+  } = marker.config;
+  const dataSignal = signal(initial);
+  const loadingSignal = signal(false);
+  const errorSignal = signal(null);
+  let currentSub = null;
+  let destroyed = false;
+  let destroyRef = null;
+  try {
+    destroyRef = inject(DestroyRef, {
+      optional: true
+    }) ?? null;
+  } catch {
+    destroyRef = null;
+  }
+  destroyRef?.onDestroy(() => {
+    destroyed = true;
+    currentSub?.unsubscribe();
+    currentSub = null;
+  });
+  function runLoad() {
+    if (destroyed) return;
+    currentSub?.unsubscribe();
+    currentSub = null;
+    loadingSignal.set(true);
+    errorSignal.set(null);
+    let result;
+    try {
+      result = load();
+    } catch (err) {
+      loadingSignal.set(false);
+      errorSignal.set(err);
+      return;
+    }
+    if (isObservable(result)) {
+      const obs = destroyRef ? result.pipe(takeUntilDestroyed(destroyRef)) : result;
+      currentSub = obs.subscribe({
+        next: value => {
+          if (destroyed) return;
+          dataSignal.set(value);
+        },
+        error: err => {
+          if (destroyed) return;
+          errorSignal.set(err);
+          loadingSignal.set(false);
+        },
+        complete: () => {
+          if (destroyed) return;
+          loadingSignal.set(false);
+        }
+      });
+    } else {
+      result.then(value => {
+        if (destroyed) return;
+        dataSignal.set(value);
+        loadingSignal.set(false);
+      }, err => {
+        if (destroyed) return;
+        errorSignal.set(err);
+        loadingSignal.set(false);
+      });
+    }
+  }
+  if (!lazy) {
+    runLoad();
+  }
+  const fn = () => dataSignal();
+  Object.defineProperty(fn, 'data', {
+    value: dataSignal.asReadonly()
+  });
+  Object.defineProperty(fn, 'loading', {
+    value: loadingSignal.asReadonly()
+  });
+  Object.defineProperty(fn, 'error', {
+    value: errorSignal.asReadonly()
+  });
+  fn.refresh = () => runLoad();
+  fn.set = value => {
+    currentSub?.unsubscribe();
+    currentSub = null;
+    loadingSignal.set(false);
+    errorSignal.set(null);
+    dataSignal.set(value);
+  };
+  fn.update = updater => {
+    dataSignal.update(updater);
+  };
+  fn.reset = () => {
+    currentSub?.unsubscribe();
+    currentSub = null;
+    loadingSignal.set(false);
+    errorSignal.set(null);
+    dataSignal.set(initial);
+  };
+  return fn;
+}
+
+export { ASYNC_SOURCE_MARKER, asyncSource, createAsyncSourceSignal, isAsyncSourceMarker };

package/dist/lib/rxjs-interop/rx-method.js

@@ -0,0 +1,50 @@
+import { inject, DestroyRef, Injector, isSignal } from '@angular/core';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { Subject } from '../../Subject.js';
+import { Subscription } from '../../Subscription.js';
+import { isObservable } from '../../isObservable.js';
+
+function rxMethod(generator, options) {
+  const destroyRef = options?.destroyRef ?? inject(DestroyRef);
+  const injector = options?.injector ?? inject(Injector);
+  const trigger$ = new Subject();
+  const sourceSubs = new Set();
+  let isDestroyed = false;
+  const masterSub = generator(trigger$.asObservable()).pipe(takeUntilDestroyed(destroyRef)).subscribe();
+  const fn = input => {
+    if (isDestroyed) return Subscription.EMPTY;
+    if (input === undefined) {
+      trigger$.next(undefined);
+      return Subscription.EMPTY;
+    }
+    if (isSignal(input)) {
+      const sub = toObservable(input, {
+        injector
+      }).pipe(takeUntilDestroyed(destroyRef)).subscribe(value => trigger$.next(value));
+      sourceSubs.add(sub);
+      sub.add(() => sourceSubs.delete(sub));
+      return sub;
+    }
+    if (isObservable(input)) {
+      const sub = input.pipe(takeUntilDestroyed(destroyRef)).subscribe(value => trigger$.next(value));
+      sourceSubs.add(sub);
+      sub.add(() => sourceSubs.delete(sub));
+      return sub;
+    }
+    trigger$.next(input);
+    return Subscription.EMPTY;
+  };
+  const method = fn;
+  method.destroy = () => {
+    if (isDestroyed) return;
+    isDestroyed = true;
+    masterSub.unsubscribe();
+    sourceSubs.forEach(s => s.unsubscribe());
+    sourceSubs.clear();
+    trigger$.complete();
+  };
+  destroyRef.onDestroy(() => method.destroy());
+  return method;
+}
+
+export { rxMethod };

package/dist/lift.js

@@ -0,0 +1,22 @@
+import { isFunction } from './isFunction.js';
+
+function hasLift(source) {
+    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+    return function (source) {
+        if (hasLift(source)) {
+            return source.lift(function (liftedSource) {
+                try {
+                    return init(liftedSource, this);
+                }
+                catch (err) {
+                    this.error(err);
+                }
+            });
+        }
+        throw new TypeError('Unable to lift unknown Observable type');
+    };
+}
+
+export { hasLift, operate };

package/dist/noop.js

@@ -0,0 +1,3 @@
+function noop() { }
+
+export { noop };

package/dist/observable2.js

@@ -0,0 +1,3 @@
+var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+export { observable };

package/dist/observeOn.js

@@ -0,0 +1,12 @@
+import { executeSchedule } from './executeSchedule.js';
+import { operate } from './lift.js';
+import { createOperatorSubscriber } from './OperatorSubscriber.js';
+
+function observeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return operate(function (source, subscriber) {
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+    });
+}
+
+export { observeOn };

package/dist/of.js

@@ -0,0 +1,13 @@
+import { popScheduler } from './args.js';
+import { from } from './from.js';
+
+function of() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    return from(args, scheduler);
+}
+
+export { of };

package/dist/pipe.js

@@ -0,0 +1,15 @@
+import { identity } from './identity.js';
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+    };
+}
+
+export { pipeFromArray };

package/dist/reportUnhandledError.js

@@ -0,0 +1,11 @@
+import { timeoutProvider } from './timeoutProvider.js';
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function () {
+        {
+            throw err;
+        }
+    });
+}
+
+export { reportUnhandledError };

package/dist/rxjs-interop.js

@@ -0,0 +1 @@
+export { rxMethod } from './lib/rxjs-interop/rx-method.js';

package/dist/scheduleArray.js

@@ -0,0 +1,20 @@
+import { Observable } from './Observable.js';
+
+function scheduleArray(input, scheduler) {
+    return new Observable(function (subscriber) {
+        var i = 0;
+        return scheduler.schedule(function () {
+            if (i === input.length) {
+                subscriber.complete();
+            }
+            else {
+                subscriber.next(input[i++]);
+                if (!subscriber.closed) {
+                    this.schedule();
+                }
+            }
+        });
+    });
+}
+
+export { scheduleArray };

package/dist/scheduleAsyncIterable.js

@@ -0,0 +1,25 @@
+import { Observable } from './Observable.js';
+import { executeSchedule } from './executeSchedule.js';
+
+function scheduleAsyncIterable(input, scheduler) {
+    if (!input) {
+        throw new Error('Iterable cannot be null');
+    }
+    return new Observable(function (subscriber) {
+        executeSchedule(subscriber, scheduler, function () {
+            var iterator = input[Symbol.asyncIterator]();
+            executeSchedule(subscriber, scheduler, function () {
+                iterator.next().then(function (result) {
+                    if (result.done) {
+                        subscriber.complete();
+                    }
+                    else {
+                        subscriber.next(result.value);
+                    }
+                });
+            }, 0, true);
+        });
+    });
+}
+
+export { scheduleAsyncIterable };

package/dist/scheduleIterable.js

@@ -0,0 +1,34 @@
+import { Observable } from './Observable.js';
+import { iterator } from './iterator.js';
+import { isFunction } from './isFunction.js';
+import { executeSchedule } from './executeSchedule.js';
+
+function scheduleIterable(input, scheduler) {
+    return new Observable(function (subscriber) {
+        var iterator$1;
+        executeSchedule(subscriber, scheduler, function () {
+            iterator$1 = input[iterator]();
+            executeSchedule(subscriber, scheduler, function () {
+                var _a;
+                var value;
+                var done;
+                try {
+                    (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                }
+                catch (err) {
+                    subscriber.error(err);
+                    return;
+                }
+                if (done) {
+                    subscriber.complete();
+                }
+                else {
+                    subscriber.next(value);
+                }
+            }, 0, true);
+        });
+        return function () { return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+    });
+}
+
+export { scheduleIterable };

package/dist/scheduleObservable.js

@@ -0,0 +1,9 @@
+import { innerFrom } from './innerFrom.js';
+import { observeOn } from './observeOn.js';
+import { subscribeOn } from './subscribeOn.js';
+
+function scheduleObservable(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+export { scheduleObservable };

package/dist/schedulePromise.js

@@ -0,0 +1,9 @@
+import { innerFrom } from './innerFrom.js';
+import { observeOn } from './observeOn.js';
+import { subscribeOn } from './subscribeOn.js';
+
+function schedulePromise(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+export { schedulePromise };

package/dist/scheduleReadableStreamLike.js

@@ -0,0 +1,8 @@
+import { scheduleAsyncIterable } from './scheduleAsyncIterable.js';
+import { readableStreamLikeToAsyncGenerator } from './isReadableStreamLike.js';
+
+function scheduleReadableStreamLike(input, scheduler) {
+    return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+}
+
+export { scheduleReadableStreamLike };

package/dist/scheduled.js

@@ -0,0 +1,39 @@
+import { scheduleObservable } from './scheduleObservable.js';
+import { schedulePromise } from './schedulePromise.js';
+import { scheduleArray } from './scheduleArray.js';
+import { scheduleIterable } from './scheduleIterable.js';
+import { scheduleAsyncIterable } from './scheduleAsyncIterable.js';
+import { isInteropObservable } from './isInteropObservable.js';
+import { isPromise } from './isPromise.js';
+import { isArrayLike } from './isArrayLike.js';
+import { isIterable } from './isIterable.js';
+import { isAsyncIterable } from './isAsyncIterable.js';
+import { createInvalidObservableTypeError } from './throwUnobservableError.js';
+import { isReadableStreamLike } from './isReadableStreamLike.js';
+import { scheduleReadableStreamLike } from './scheduleReadableStreamLike.js';
+
+function scheduled(input, scheduler) {
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return scheduleObservable(input, scheduler);
+        }
+        if (isArrayLike(input)) {
+            return scheduleArray(input, scheduler);
+        }
+        if (isPromise(input)) {
+            return schedulePromise(input, scheduler);
+        }
+        if (isAsyncIterable(input)) {
+            return scheduleAsyncIterable(input, scheduler);
+        }
+        if (isIterable(input)) {
+            return scheduleIterable(input, scheduler);
+        }
+        if (isReadableStreamLike(input)) {
+            return scheduleReadableStreamLike(input, scheduler);
+        }
+    }
+    throw createInvalidObservableTypeError(input);
+}
+
+export { scheduled };

package/dist/subscribeOn.js

@@ -0,0 +1,10 @@
+import { operate } from './lift.js';
+
+function subscribeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return operate(function (source, subscriber) {
+        subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+    });
+}
+
+export { subscribeOn };

package/dist/switchMap.js

@@ -0,0 +1,26 @@
+import { innerFrom } from './innerFrom.js';
+import { operate } from './lift.js';
+import { createOperatorSubscriber } from './OperatorSubscriber.js';
+
+function switchMap(project, resultSelector) {
+    return operate(function (source, subscriber) {
+        var innerSubscriber = null;
+        var index = 0;
+        var isComplete = false;
+        var checkComplete = function () { return isComplete && !innerSubscriber && subscriber.complete(); };
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+            innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
+            var innerIndex = 0;
+            var outerIndex = index++;
+            innerFrom(project(value, outerIndex)).subscribe((innerSubscriber = createOperatorSubscriber(subscriber, function (innerValue) { return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue); }, function () {
+                innerSubscriber = null;
+                checkComplete();
+            })));
+        }, function () {
+            isComplete = true;
+            checkComplete();
+        }));
+    });
+}
+
+export { switchMap };

package/dist/tap.js

@@ -0,0 +1,42 @@
+import { isFunction } from './isFunction.js';
+import { operate } from './lift.js';
+import { createOperatorSubscriber } from './OperatorSubscriber.js';
+import { identity } from './identity.js';
+
+function tap(observerOrNext, error, complete) {
+    var tapObserver = isFunction(observerOrNext) || error || complete
+        ?
+            { next: observerOrNext, error: error, complete: complete }
+        : observerOrNext;
+    return tapObserver
+        ? operate(function (source, subscriber) {
+            var _a;
+            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+            var isUnsub = true;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                var _a;
+                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                subscriber.next(value);
+            }, function () {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                subscriber.complete();
+            }, function (err) {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                subscriber.error(err);
+            }, function () {
+                var _a, _b;
+                if (isUnsub) {
+                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                }
+                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+            }));
+        })
+        :
+            identity;
+}
+
+export { tap };

package/dist/throwUnobservableError.js

@@ -0,0 +1,5 @@
+function createInvalidObservableTypeError(input) {
+    return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+
+export { createInvalidObservableTypeError };

package/dist/timeoutProvider.js

@@ -0,0 +1,17 @@
+import { __spreadArray, __read } from 'tslib';
+
+var timeoutProvider = {
+    setTimeout: function (handler, timeout) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function (handle) {
+        return (clearTimeout)(handle);
+    },
+    delegate: undefined,
+};
+
+export { timeoutProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "9.3.0",
+  "version": "9.5.1",
   "description": "Reactive JSON for Angular. JSON branches, reactive leaves. No actions. No reducers. No selectors.",
   "license": "MIT",
   "type": "module",
@@ -29,6 +29,11 @@
       "import": "./dist/storage.js",
       "default": "./dist/storage.js"
     },
+    "./rxjs-interop": {
+      "types": "./src/rxjs-interop.d.ts",
+      "import": "./dist/rxjs-interop.js",
+      "default": "./dist/rxjs-interop.js"
+    },
     "./package.json": "./package.json"
   },
   "peerDependencies": {