@signaltree/core 9.2.2 → 9.5.0

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.2.2",
+  "version": "9.5.0",
   "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": {

package/src/index.d.ts

@@ -1,5 +1,7 @@
 export { signalTree } from './lib/signal-tree';
-export type { ISignalTree, SignalTree, SignalTreeBase, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, EnhancerCleanup, EffectsMethods, } from './lib/types';
+export type { ISignalTree, SignalTree, SignalTreeBase, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, EnhancerCleanup, EffectsMethods, UpdateMetadata, } from './lib/types';
+export { withWriteContext, getActiveWriteContext } from './lib/write-context';
+export { interceptLeafSignals } from './lib/internals/intercept-leaf-signals';
 export { entityMap } from './lib/types';
 export type { ProcessDerived, DeepMergeTree, DerivedFactory, WithDerived, } from './lib/internals/derived-types';
 export { derivedFrom, externalDerived } from './lib/internals/derived-types';
@@ -8,6 +10,8 @@ export { isDerivedMarker, type DerivedMarker, type DerivedType, } from './lib/ma
 export { status, isStatusMarker, LoadingState, type StatusMarker, type StatusSignal, type StatusConfig, } from './lib/markers/status';
 export { stored, isStoredMarker, createStorageKeys, clearStoragePrefix, type StoredMarker, type StoredSignal, type StoredOptions, } from './lib/markers/stored';
 export { form, isFormMarker, createFormSignal, validators, FORM_MARKER, type FormMarker, type FormSignal, type FormConfig, type FormFields, type FormWizard, type WizardConfig, type WizardStepConfig, type Validator, type AsyncValidator, } from './lib/markers/form';
+export { asyncSource, isAsyncSourceMarker, createAsyncSourceSignal, ASYNC_SOURCE_MARKER, type AsyncSourceMarker, type AsyncSourceSignal, type AsyncSourceConfig, type AsyncSourceLoader, } from './lib/markers/async-source';
+export { asyncQuery, isAsyncQueryMarker, createAsyncQuerySignal, ASYNC_QUERY_MARKER, type AsyncQueryMarker, type AsyncQuerySignal, type AsyncQueryConfig, type AsyncQueryFn, } from './lib/markers/async-query';
 export { registerMarkerProcessor } from './lib/internals/materialize-markers';
 export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, } from './lib/utils';
 export { getPathNotifier } from './lib/path-notifier';

package/src/lib/internals/intercept-leaf-signals.d.ts

@@ -1 +1,4 @@
-export {};
+import type { UpdateMetadata } from '../types';
+export declare function interceptLeafSignals(root: unknown, onWrite: (path: string, next: unknown, prev: unknown, meta?: UpdateMetadata) => void, options?: {
+    maxDepth?: number;
+}): () => void;

package/src/lib/markers/async-query.d.ts

@@ -0,0 +1,31 @@
+import { type Signal, type WritableSignal } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare const ASYNC_QUERY_MARKER: unique symbol;
+export type AsyncQueryFn<TInput, TResult> = (input: TInput) => Observable<TResult> | Promise<TResult>;
+export interface AsyncQueryConfig<TInput, TResult> {
+    initialInput?: TInput;
+    initialResult?: TResult;
+    query: AsyncQueryFn<TInput, TResult>;
+    debounce?: number;
+    filter?: (input: TInput) => boolean;
+    equal?: (a: TInput, b: TInput) => boolean;
+}
+export interface AsyncQueryMarker<TInput, TResult> {
+    [ASYNC_QUERY_MARKER]: true;
+    config: AsyncQueryConfig<TInput, TResult>;
+    readonly __inputType?: TInput;
+    readonly __resultType?: TResult;
+}
+export interface AsyncQuerySignal<TInput, TResult> {
+    (): TResult | undefined;
+    readonly input: WritableSignal<TInput | undefined>;
+    readonly results: Signal<TResult | undefined>;
+    readonly data: Signal<TResult | undefined>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<unknown | null>;
+    rerun(): void;
+    reset(): void;
+}
+export declare function asyncQuery<TInput, TResult>(config: AsyncQueryConfig<TInput, TResult>): AsyncQueryMarker<TInput, TResult>;
+export declare function isAsyncQueryMarker(value: unknown): value is AsyncQueryMarker<unknown, unknown>;
+export declare function createAsyncQuerySignal<TInput, TResult>(marker: AsyncQueryMarker<TInput, TResult>): AsyncQuerySignal<TInput, TResult>;

package/src/lib/markers/async-source.d.ts

@@ -0,0 +1,27 @@
+import { type Signal } from '@angular/core';
+import { type Observable } from 'rxjs';
+export declare const ASYNC_SOURCE_MARKER: unique symbol;
+export type AsyncSourceLoader<T> = () => Observable<T> | Promise<T>;
+export interface AsyncSourceConfig<T> {
+    initial?: T;
+    load: AsyncSourceLoader<T>;
+    lazy?: boolean;
+}
+export interface AsyncSourceMarker<T> {
+    [ASYNC_SOURCE_MARKER]: true;
+    config: AsyncSourceConfig<T>;
+    readonly __valueType?: T;
+}
+export interface AsyncSourceSignal<T> {
+    (): T | undefined;
+    readonly data: Signal<T | undefined>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<unknown | null>;
+    refresh(): void;
+    set(value: T): void;
+    update(updater: (current: T | undefined) => T): void;
+    reset(): void;
+}
+export declare function asyncSource<T>(config: AsyncSourceConfig<T>): AsyncSourceMarker<T>;
+export declare function isAsyncSourceMarker(value: unknown): value is AsyncSourceMarker<unknown>;
+export declare function createAsyncSourceSignal<T>(marker: AsyncSourceMarker<T>): AsyncSourceSignal<T>;

package/src/lib/markers/index.d.ts

@@ -2,3 +2,5 @@ export { isDerivedMarker, getDerivedMarkerSymbol, type DerivedMarker, type Deriv
 export { status, isStatusMarker, createStatusSignal, LoadingState, STATUS_MARKER, type StatusMarker, type StatusSignal, type StatusConfig, } from './status';
 export { stored, isStoredMarker, createStoredSignal, createStorageKeys, clearStoragePrefix, STORED_MARKER, type StoredMarker, type StoredSignal, type StoredOptions, type MigrationFn, } from './stored';
 export { form, isFormMarker, createFormSignal, validators, FORM_MARKER, type FormMarker, type FormSignal, type FormConfig, type FormFields, type FormWizard, type WizardConfig, type WizardStepConfig, type Validator, type AsyncValidator, } from './form';
+export { asyncSource, isAsyncSourceMarker, createAsyncSourceSignal, ASYNC_SOURCE_MARKER, type AsyncSourceMarker, type AsyncSourceSignal, type AsyncSourceConfig, type AsyncSourceLoader, } from './async-source';
+export { asyncQuery, isAsyncQueryMarker, createAsyncQuerySignal, ASYNC_QUERY_MARKER, type AsyncQueryMarker, type AsyncQuerySignal, type AsyncQueryConfig, type AsyncQueryFn, } from './async-query';

package/src/lib/rxjs-interop/index.d.ts

@@ -0,0 +1 @@
+export { rxMethod, type RxMethod, type RxMethodInput, } from './rx-method';

package/src/lib/rxjs-interop/rx-method.d.ts

@@ -0,0 +1,11 @@
+import { DestroyRef, Injector, type Signal } from '@angular/core';
+import { type Observable, Subscription } from 'rxjs';
+export type RxMethodInput<T> = T | Signal<T> | Observable<T>;
+export interface RxMethod<T> {
+    (...args: [T] extends [void] ? [] | [RxMethodInput<T>] : [RxMethodInput<T>]): Subscription;
+    destroy(): void;
+}
+export declare function rxMethod<T = void>(generator: (source$: Observable<T>) => Observable<unknown>, options?: {
+    destroyRef?: DestroyRef;
+    injector?: Injector;
+}): RxMethod<T>;

package/src/lib/types.d.ts

@@ -3,6 +3,14 @@ import { FormMarker, FormSignal } from './markers/form';
 import { StatusMarker, StatusSignal } from './markers/status';
 import { StoredMarker, StoredSignal } from './markers/stored';
 import { SecurityValidatorConfig } from './security/security-validator';
+export interface UpdateMetadata {
+    intent?: 'hydrate' | 'reset' | 'bulk' | 'migration' | 'user' | 'system';
+    source?: 'serialization' | 'time-travel' | 'devtools' | 'user' | 'system';
+    suppressGuardrails?: boolean;
+    correlationId?: string;
+    timestamp?: number;
+    [key: string]: unknown;
+}
 export interface TimeTravelConfig {
     enabled?: boolean;
     maxHistorySize?: number;

package/src/lib/write-context.d.ts

@@ -0,0 +1,3 @@
+import type { UpdateMetadata } from './types';
+export declare function withWriteContext<R>(meta: UpdateMetadata, fn: () => R): R;
+export declare function getActiveWriteContext(): UpdateMetadata | undefined;

package/src/rxjs-interop.d.ts

@@ -0,0 +1 @@
+export { rxMethod, type RxMethod, type RxMethodInput, } from './lib/rxjs-interop';