@signaltree/core 9.2.2 → 9.5.0

package/dist/innerFrom.js

@@ -0,0 +1,145 @@
+import { __values, __awaiter, __generator, __asyncValues } from 'tslib';
+import { isArrayLike } from './isArrayLike.js';
+import { isPromise } from './isPromise.js';
+import { Observable } from './Observable.js';
+import { isInteropObservable } from './isInteropObservable.js';
+import { isAsyncIterable } from './isAsyncIterable.js';
+import { createInvalidObservableTypeError } from './throwUnobservableError.js';
+import { isIterable } from './isIterable.js';
+import { isReadableStreamLike, readableStreamLikeToAsyncGenerator } from './isReadableStreamLike.js';
+import { isFunction } from './isFunction.js';
+import { reportUnhandledError } from './reportUnhandledError.js';
+import { observable } from './observable2.js';
+
+function innerFrom(input) {
+    if (input instanceof Observable) {
+        return input;
+    }
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return fromInteropObservable(input);
+        }
+        if (isArrayLike(input)) {
+            return fromArrayLike(input);
+        }
+        if (isPromise(input)) {
+            return fromPromise(input);
+        }
+        if (isAsyncIterable(input)) {
+            return fromAsyncIterable(input);
+        }
+        if (isIterable(input)) {
+            return fromIterable(input);
+        }
+        if (isReadableStreamLike(input)) {
+            return fromReadableStreamLike(input);
+        }
+    }
+    throw createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+    return new Observable(function (subscriber) {
+        var obs = obj[observable]();
+        if (isFunction(obs.subscribe)) {
+            return obs.subscribe(subscriber);
+        }
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    });
+}
+function fromArrayLike(array) {
+    return new Observable(function (subscriber) {
+        for (var i = 0; i < array.length && !subscriber.closed; i++) {
+            subscriber.next(array[i]);
+        }
+        subscriber.complete();
+    });
+}
+function fromPromise(promise) {
+    return new Observable(function (subscriber) {
+        promise
+            .then(function (value) {
+            if (!subscriber.closed) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+        }, function (err) { return subscriber.error(err); })
+            .then(null, reportUnhandledError);
+    });
+}
+function fromIterable(iterable) {
+    return new Observable(function (subscriber) {
+        var e_1, _a;
+        try {
+            for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                var value = iterable_1_1.value;
+                subscriber.next(value);
+                if (subscriber.closed) {
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        subscriber.complete();
+    });
+}
+function fromAsyncIterable(asyncIterable) {
+    return new Observable(function (subscriber) {
+        process(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+    });
+}
+function fromReadableStreamLike(readableStream) {
+    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process(asyncIterable, subscriber) {
+    var asyncIterable_1, asyncIterable_1_1;
+    var e_2, _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var value, e_2_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 11]);
+                    asyncIterable_1 = __asyncValues(asyncIterable);
+                    _b.label = 1;
+                case 1: return [4, asyncIterable_1.next()];
+                case 2:
+                    if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                    value = asyncIterable_1_1.value;
+                    subscriber.next(value);
+                    if (subscriber.closed) {
+                        return [2];
+                    }
+                    _b.label = 3;
+                case 3: return [3, 1];
+                case 4: return [3, 11];
+                case 5:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3, 11];
+                case 6:
+                    _b.trys.push([6, , 9, 10]);
+                    if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                    return [4, _a.call(asyncIterable_1)];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [3, 10];
+                case 9:
+                    if (e_2) throw e_2.error;
+                    return [7];
+                case 10: return [7];
+                case 11:
+                    subscriber.complete();
+                    return [2];
+            }
+        });
+    });
+}
+
+export { fromArrayLike, fromAsyncIterable, fromInteropObservable, fromIterable, fromPromise, fromReadableStreamLike, innerFrom };

package/dist/intervalProvider.js

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

package/dist/isArrayLike.js

@@ -0,0 +1,3 @@
+var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+export { isArrayLike };

package/dist/isAsyncIterable.js

@@ -0,0 +1,7 @@
+import { isFunction } from './isFunction.js';
+
+function isAsyncIterable(obj) {
+    return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+
+export { isAsyncIterable };

package/dist/isFunction.js

@@ -0,0 +1,5 @@
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+export { isFunction };

package/dist/isInteropObservable.js

@@ -0,0 +1,8 @@
+import { observable } from './observable2.js';
+import { isFunction } from './isFunction.js';
+
+function isInteropObservable(input) {
+    return isFunction(input[observable]);
+}
+
+export { isInteropObservable };

package/dist/isIterable.js

@@ -0,0 +1,8 @@
+import { iterator } from './iterator.js';
+import { isFunction } from './isFunction.js';
+
+function isIterable(input) {
+    return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+
+export { isIterable };

package/dist/isObservable.js

@@ -0,0 +1,8 @@
+import { Observable } from './Observable.js';
+import { isFunction } from './isFunction.js';
+
+function isObservable(obj) {
+    return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
+}
+
+export { isObservable };

package/dist/isPromise.js

@@ -0,0 +1,7 @@
+import { isFunction } from './isFunction.js';
+
+function isPromise(value) {
+    return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+
+export { isPromise };

package/dist/isReadableStreamLike.js

@@ -0,0 +1,40 @@
+import { __asyncGenerator, __generator, __await } from 'tslib';
+import { isFunction } from './isFunction.js';
+
+function readableStreamLikeToAsyncGenerator(readableStream) {
+    return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+        var reader, _a, value, done;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = readableStream.getReader();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, , 9, 10]);
+                    _b.label = 2;
+                case 2:
+                    return [4, __await(reader.read())];
+                case 3:
+                    _a = _b.sent(), value = _a.value, done = _a.done;
+                    if (!done) return [3, 5];
+                    return [4, __await(void 0)];
+                case 4: return [2, _b.sent()];
+                case 5: return [4, __await(value)];
+                case 6: return [4, _b.sent()];
+                case 7:
+                    _b.sent();
+                    return [3, 2];
+                case 8: return [3, 10];
+                case 9:
+                    reader.releaseLock();
+                    return [7];
+                case 10: return [2];
+            }
+        });
+    });
+}
+function isReadableStreamLike(obj) {
+    return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+
+export { isReadableStreamLike, readableStreamLikeToAsyncGenerator };

package/dist/isScheduler.js

@@ -0,0 +1,7 @@
+import { isFunction } from './isFunction.js';
+
+function isScheduler(value) {
+    return value && isFunction(value.schedule);
+}
+
+export { isScheduler };

package/dist/iterator.js

@@ -0,0 +1,9 @@
+function getSymbolIterator() {
+    if (typeof Symbol !== 'function' || !Symbol.iterator) {
+        return '@@iterator';
+    }
+    return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+
+export { getSymbolIterator, iterator };

package/dist/lib/internals/intercept-leaf-signals.js

@@ -1,3 +1,5 @@
+import { getActiveWriteContext } from '../write-context.js';
+
 function interceptLeafSignals(root, onWrite, options = {}) {
   const restorers = [];
   const seen = new WeakSet();
@@ -38,13 +40,13 @@ function interceptLeafSignals(root, onWrite, options = {}) {
           const prev = original();
           originalSet(value);
           const next = original();
-          if (next !== prev) onWrite(childPath, next, prev);
+          if (next !== prev) onWrite(childPath, next, prev, getActiveWriteContext());
         };
         original.update = updater => {
           const prev = original();
           originalUpdate(updater);
           const next = original();
-          if (next !== prev) onWrite(childPath, next, prev);
+          if (next !== prev) onWrite(childPath, next, prev, getActiveWriteContext());
         };
         continue;
       }

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/lib/write-context.js

@@ -0,0 +1,15 @@
+let activeContext;
+function withWriteContext(meta, fn) {
+  const previous = activeContext;
+  activeContext = meta;
+  try {
+    return fn();
+  } finally {
+    activeContext = previous;
+  }
+}
+function getActiveWriteContext() {
+  return activeContext;
+}
+
+export { getActiveWriteContext, withWriteContext };

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 };