@angular/core 16.0.0-next.4 → 16.0.0-next.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "16.0.0-next.4",
+  "version": "16.0.0-next.6",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",
@@ -16,19 +16,21 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/core.mjs",
-      "es2020": "./fesm2020/core.mjs",
-      "es2015": "./fesm2015/core.mjs",
-      "node": "./fesm2015/core.mjs",
-      "default": "./fesm2020/core.mjs"
+      "esm2022": "./esm2022/core.mjs",
+      "esm": "./esm2022/core.mjs",
+      "default": "./fesm2022/core.mjs"
+    },
+    "./rxjs-interop": {
+      "types": "./rxjs-interop/index.d.ts",
+      "esm2022": "./esm2022/rxjs-interop/rxjs-interop.mjs",
+      "esm": "./esm2022/rxjs-interop/rxjs-interop.mjs",
+      "default": "./fesm2022/rxjs-interop.mjs"
     },
     "./testing": {
       "types": "./testing/index.d.ts",
-      "esm2020": "./esm2020/testing/testing.mjs",
-      "es2020": "./fesm2020/testing.mjs",
-      "es2015": "./fesm2015/testing.mjs",
-      "node": "./fesm2015/testing.mjs",
-      "default": "./fesm2020/testing.mjs"
+      "esm2022": "./esm2022/testing/testing.mjs",
+      "esm": "./esm2022/testing/testing.mjs",
+      "default": "./fesm2022/testing.mjs"
     }
   },
   "dependencies": {
@@ -66,11 +68,7 @@
   },
   "schematics": "./schematics/collection.json",
   "sideEffects": false,
-  "fesm2020": "./fesm2020/core.mjs",
-  "fesm2015": "./fesm2015/core.mjs",
-  "esm2020": "./esm2020/core.mjs",
+  "module": "./fesm2022/core.mjs",
   "typings": "./index.d.ts",
-  "module": "./fesm2015/core.mjs",
-  "es2020": "./fesm2020/core.mjs",
   "type": "module"
 }

package/rxjs-interop/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @license Angular v16.0.0-next.6
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+
+import { DestroyRef } from '@angular/core';
+import { Injector } from '@angular/core';
+import { MonoTypeOperatorFunction } from 'rxjs';
+import { Observable } from 'rxjs';
+import { Signal } from '@angular/core';
+
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * The subscription will last for the lifetime of the current injection context. That is, if
+ * `fromObservable` is called from a component context, the subscription will be cleaned up when the
+ * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s
+ * lifetime will be used (which is typically the lifetime of the application itself).
+ *
+ * If the `Observable` does not produce a value before the `Signal` is read, the `Signal` will throw
+ * an error. To avoid this, use a synchronous `Observable` (potentially created with the `startWith`
+ * operator) or pass an initial value to `fromObservable` as the second argument.
+ *
+ * `fromObservable` must be called in an injection context.
+ */
+export declare function fromObservable<T>(source: Observable<T>): Signal<T>;
+
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * The subscription will last for the lifetime of the current injection context. That is, if
+ * `fromObservable` is called from a component context, the subscription will be cleaned up when the
+ * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s
+ * lifetime will be used (which is typically the lifetime of the application itself).
+ *
+ * Before the `Observable` emits its first value, the `Signal` will return the configured
+ * `initialValue`. If the `Observable` is known to produce a value before the `Signal` will be read,
+ * `initialValue` does not need to be passed.
+ *
+ * `fromObservable` must be called in an injection context.
+ *
+ * @developerPreview
+ */
+export declare function fromObservable<T, U extends T | null | undefined>(source: Observable<T>, initialValue: U): Signal<T | U>;
+
+/**
+ * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ *
+ * `fromSignal` must be called in an injection context.
+ *
+ * @developerPreview
+ */
+export declare function fromSignal<T>(source: Signal<T>, options?: FromSignalOptions): Observable<T>;
+
+/**
+ * Options for `fromSignal`.
+ *
+ * @developerPreview
+ */
+export declare interface FromSignalOptions {
+    /**
+     * The `Injector` to use when creating the effect.
+     *
+     * If this isn't specified, the current injection context will be used.
+     */
+    injector?: Injector;
+}
+
+/**
+ * Operator which completes the Observable when the calling context (component, directive, service,
+ * etc) is destroyed.
+ *
+ * @param destroyRef optionally, the `DestroyRef` representing the current context. This can be
+ *     passed explicitly to use `takeUntilDestroyed` outside of an injection context. Otherwise, the
+ * current `DestroyRef` is injected.
+ *
+ * @developerPreview
+ */
+export declare function takeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>;
+
+export { }