@signaltree/core 9.3.0 → 9.5.1

package/src/index.d.ts

@@ -10,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/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

@@ -1,4 +1,6 @@
 import { Signal, WritableSignal } from '@angular/core';
+import { AsyncQueryMarker, AsyncQuerySignal } from './markers/async-query';
+import { AsyncSourceMarker, AsyncSourceSignal } from './markers/async-source';
 import { FormMarker, FormSignal } from './markers/form';
 import { StatusMarker, StatusSignal } from './markers/status';
 import { StoredMarker, StoredSignal } from './markers/stored';
@@ -30,7 +32,7 @@ export interface NodeAccessor<T> {
     (updater: (current: T) => T): void;
 }
 export type TreeNode<T> = {
-    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends StatusMarker<infer Err> ? StatusSignal<Err> : T[K] extends StoredMarker<infer V> ? StoredSignal<V> : T[K] extends FormMarker<infer F> ? FormSignal<F> : T[K] extends Primitive ? CallableWritableSignal<T[K]> : T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends Date | RegExp | Map<any, any> | Set<any> | Error | ((...args: unknown[]) => unknown) ? CallableWritableSignal<T[K]> : T[K] extends object ? NodeAccessor<T[K]> & TreeNode<T[K]> : CallableWritableSignal<T[K]>;
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends StatusMarker<infer Err> ? StatusSignal<Err> : T[K] extends StoredMarker<infer V> ? StoredSignal<V> : T[K] extends FormMarker<infer F> ? FormSignal<F> : T[K] extends AsyncSourceMarker<infer V> ? AsyncSourceSignal<V> : T[K] extends AsyncQueryMarker<infer In, infer Out> ? AsyncQuerySignal<In, Out> : T[K] extends Primitive ? CallableWritableSignal<T[K]> : T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends Date | RegExp | Map<any, any> | Set<any> | Error | ((...args: unknown[]) => unknown) ? CallableWritableSignal<T[K]> : T[K] extends object ? NodeAccessor<T[K]> & TreeNode<T[K]> : CallableWritableSignal<T[K]>;
 };
 export interface ISignalTree<T> extends NodeAccessor<T> {
     readonly state: TreeNode<T>;

package/src/rxjs-interop.d.ts

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