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

package/esm2022/rxjs-interop/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './src/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3J4anMtaW50ZXJvcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9pbmRleCc7XG4iXX0=

package/esm2022/rxjs-interop/public_api.mjs

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+export * from './src/index';
+// This file only reexports content of the `src` folder. Keep it that way.
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvcnhqcy1pbnRlcm9wL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7Ozs7R0FJRztBQUNILGNBQWMsYUFBYSxDQUFDO0FBRTVCLDBFQUEwRSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIEBtb2R1bGVcbiAqIEBkZXNjcmlwdGlvblxuICogRW50cnkgcG9pbnQgZm9yIGFsbCBwdWJsaWMgQVBJcyBvZiB0aGlzIHBhY2thZ2UuXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vc3JjL2luZGV4JztcblxuLy8gVGhpcyBmaWxlIG9ubHkgcmVleHBvcnRzIGNvbnRlbnQgb2YgdGhlIGBzcmNgIGZvbGRlci4gS2VlcCBpdCB0aGF0IHdheS5cbiJdfQ==

package/esm2022/rxjs-interop/rxjs-interop.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnhqcy1pbnRlcm9wLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9yeGpzLWludGVyb3Avcnhqcy1pbnRlcm9wLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/rxjs-interop/src/from_observable.mjs

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertInInjectionContext, computed, DestroyRef, inject, signal } from '@angular/core';
+export function fromObservable(source, initialValue) {
+    assertInInjectionContext(fromObservable);
+    // Note: T is the Observable value type, and U is the initial value type. They don't have to be
+    // the same - the returned signal gives values of type `T`.
+    let state;
+    if (initialValue === undefined && arguments.length !== 2) {
+        // No initial value was passed, so initially the signal is in a `NoValue` state and will throw
+        // if accessed.
+        state = signal({ kind: 0 /* StateKind.NoValue */ });
+    }
+    else {
+        // An initial value was passed, so use it.
+        state = signal({ kind: 1 /* StateKind.Value */, value: initialValue });
+    }
+    const sub = source.subscribe({
+        next: value => state.set({ kind: 1 /* StateKind.Value */, value }),
+        error: error => state.set({ kind: 2 /* StateKind.Error */, error }),
+        // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
+        // "complete".
+    });
+    // Unsubscribe when the current context is destroyed.
+    inject(DestroyRef).onDestroy(sub.unsubscribe.bind(sub));
+    // The actual returned signal is a `computed` of the `State` signal, which maps the various states
+    // to either values or errors.
+    return computed(() => {
+        const current = state();
+        switch (current.kind) {
+            case 1 /* StateKind.Value */:
+                return current.value;
+            case 2 /* StateKind.Error */:
+                throw current.error;
+            case 0 /* StateKind.NoValue */:
+                // TODO(alxhub): use a RuntimeError when we finalize the error semantics
+                throw new Error(`fromObservable() signal read before the Observable emitted`);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"from_observable.js","sourceRoot":"","sources":["../../../../../../../packages/core/rxjs-interop/src/from_observable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,wBAAwB,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAyB,MAAM,eAAe,CAAC;AAgDrH,MAAM,UAAU,cAAc,CAAe,MAAqB,EAAE,YAAgB;IAClF,wBAAwB,CAAC,cAAc,CAAC,CAAC;IAEzC,+FAA+F;IAC/F,2DAA2D;IAC3D,IAAI,KAAiC,CAAC;IACtC,IAAI,YAAY,KAAK,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;QACxD,8FAA8F;QAC9F,eAAe;QACf,KAAK,GAAG,MAAM,CAAC,EAAC,IAAI,2BAAmB,EAAC,CAAC,CAAC;KAC3C;SAAM;QACL,0CAA0C;QAC1C,KAAK,GAAG,MAAM,CAAa,EAAC,IAAI,yBAAiB,EAAE,KAAK,EAAE,YAAa,EAAC,CAAC,CAAC;KAC3E;IAED,MAAM,GAAG,GAAG,MAAM,CAAC,SAAS,CAAC;QAC3B,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAC,IAAI,yBAAiB,EAAE,KAAK,EAAC,CAAC;QACxD,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAC,IAAI,yBAAiB,EAAE,KAAK,EAAC,CAAC;QACzD,6FAA6F;QAC7F,cAAc;KACf,CAAC,CAAC;IAEH,qDAAqD;IACrD,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAExD,kGAAkG;IAClG,8BAA8B;IAC9B,OAAO,QAAQ,CAAC,GAAG,EAAE;QACnB,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC;QACxB,QAAQ,OAAO,CAAC,IAAI,EAAE;YACpB;gBACE,OAAO,OAAO,CAAC,KAAK,CAAC;YACvB;gBACE,MAAM,OAAO,CAAC,KAAK,CAAC;YACtB;gBACE,wEAAwE;gBACxE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;SACjF;IACH,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {assertInInjectionContext, computed, DestroyRef, inject, signal, Signal, WritableSignal} from '@angular/core';\nimport {Observable} from 'rxjs';\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `fromObservable` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * If the `Observable` does not produce a value before the `Signal` is read, the `Signal` will throw\n * an error. To avoid this, use a synchronous `Observable` (potentially created with the `startWith`\n * operator) or pass an initial value to `fromObservable` as the second argument.\n *\n * `fromObservable` must be called in an injection context.\n */\nexport function fromObservable<T>(source: Observable<T>): Signal<T>;\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `fromObservable` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * The subscription will last for the lifetime of the current injection context. That is, if\n * `fromObservable` is called from a component context, the subscription will be cleaned up when the\n * component is destroyed. When called outside of a component, the current `EnvironmentInjector`'s\n * lifetime will be used (which is typically the lifetime of the application itself).\n *\n * Before the `Observable` emits its first value, the `Signal` will return the configured\n * `initialValue`. If the `Observable` is known to produce a value before the `Signal` will be read,\n * `initialValue` does not need to be passed.\n *\n * `fromObservable` must be called in an injection context.\n *\n * @developerPreview\n */\nexport function fromObservable<T, U extends T|null|undefined>(\n    // fromObservable(Observable<Animal>) -> Signal<Cat>\n    source: Observable<T>, initialValue: U): Signal<T|U>;\nexport function fromObservable<T, U = never>(source: Observable<T>, initialValue?: U): Signal<T|U> {\n  assertInInjectionContext(fromObservable);\n\n  // Note: T is the Observable value type, and U is the initial value type. They don't have to be\n  // the same - the returned signal gives values of type `T`.\n  let state: WritableSignal<State<T|U>>;\n  if (initialValue === undefined && arguments.length !== 2) {\n    // No initial value was passed, so initially the signal is in a `NoValue` state and will throw\n    // if accessed.\n    state = signal({kind: StateKind.NoValue});\n  } else {\n    // An initial value was passed, so use it.\n    state = signal<State<T|U>>({kind: StateKind.Value, value: initialValue!});\n  }\n\n  const sub = source.subscribe({\n    next: value => state.set({kind: StateKind.Value, value}),\n    error: error => state.set({kind: StateKind.Error, error}),\n    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of\n    // \"complete\".\n  });\n\n  // Unsubscribe when the current context is destroyed.\n  inject(DestroyRef).onDestroy(sub.unsubscribe.bind(sub));\n\n  // The actual returned signal is a `computed` of the `State` signal, which maps the various states\n  // to either values or errors.\n  return computed(() => {\n    const current = state();\n    switch (current.kind) {\n      case StateKind.Value:\n        return current.value;\n      case StateKind.Error:\n        throw current.error;\n      case StateKind.NoValue:\n        // TODO(alxhub): use a RuntimeError when we finalize the error semantics\n        throw new Error(`fromObservable() signal read before the Observable emitted`);\n    }\n  });\n}\n\nconst enum StateKind {\n  NoValue,\n  Value,\n  Error,\n}\n\ninterface NoValueState {\n  kind: StateKind.NoValue;\n}\n\ninterface ValueState<T> {\n  kind: StateKind.Value;\n  value: T;\n}\n\ninterface ErrorState {\n  kind: StateKind.Error;\n  error: unknown;\n}\n\ntype State<T> = NoValueState|ValueState<T>|ErrorState;\n"]}

package/esm2022/rxjs-interop/src/from_signal.mjs

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertInInjectionContext, effect, inject, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+/**
+ * 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 function fromSignal(source, options) {
+    !options?.injector && assertInInjectionContext(fromSignal);
+    const injector = options?.injector ?? inject(Injector);
+    // Creating a new `Observable` allows the creation of the effect to be lazy. This allows for all
+    // references to `source` to be dropped if the `Observable` is fully unsubscribed and thrown away.
+    return new Observable(observer => {
+        const watcher = effect(() => {
+            try {
+                observer.next(source());
+            }
+            catch (err) {
+                observer.error(err);
+            }
+        }, { injector, manualCleanup: true });
+        return () => watcher.destroy();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rxjs-interop/src/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export { fromObservable } from './from_observable';
+export { fromSignal } from './from_signal';
+export { takeUntilDestroyed } from './take_until_destroyed';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3J4anMtaW50ZXJvcC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBQyxVQUFVLEVBQW9CLE1BQU0sZUFBZSxDQUFDO0FBQzVELE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB7ZnJvbU9ic2VydmFibGV9IGZyb20gJy4vZnJvbV9vYnNlcnZhYmxlJztcbmV4cG9ydCB7ZnJvbVNpZ25hbCwgRnJvbVNpZ25hbE9wdGlvbnN9IGZyb20gJy4vZnJvbV9zaWduYWwnO1xuZXhwb3J0IHt0YWtlVW50aWxEZXN0cm95ZWR9IGZyb20gJy4vdGFrZV91bnRpbF9kZXN0cm95ZWQnO1xuIl19

package/esm2022/rxjs-interop/src/take_until_destroyed.mjs

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { assertInInjectionContext, DestroyRef, inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+/**
+ * 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 function takeUntilDestroyed(destroyRef) {
+    if (!destroyRef) {
+        assertInInjectionContext(takeUntilDestroyed);
+        destroyRef = inject(DestroyRef);
+    }
+    const destroyed$ = new Observable(observer => {
+        destroyRef.onDestroy(observer.next.bind(observer));
+    });
+    return (source) => {
+        return source.pipe(takeUntil(destroyed$));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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