@politie/sherlock-rxjs 3.4.14 → 3.4.16

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@politie/sherlock-rxjs",
-    "version": "3.4.14",
+    "version": "3.4.16",
     "description": "An extension to Sherlock that provides interop with RxJS.",
     "main": "sherlock-rxjs.cjs.js",
     "module": "sherlock-rxjs.esm.js",
@@ -38,7 +38,7 @@
         "tslib": "^2.2.0"
     },
     "peerDependencies": {
-        "@politie/sherlock": "3.4.14",
-        "rxjs": "^5.4.0 || ^6.0.0"
+        "@politie/sherlock": "3.4.16",
+        "rxjs": "^5.4.0 || ^6.0.0 || ^7.0.0 "
     }
 }

package/rxjs.d.ts

@@ -1,5 +1,5 @@
 import { Derivable, ReactorOptions } from '@politie/sherlock';
-import { Observable, Subscribable } from 'rxjs';
+import { Observable } from 'rxjs';
 /**
  * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions
  * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.
@@ -7,4 +7,4 @@ import { Observable, Subscribable } from 'rxjs';
  * @param options Partial `ReactorOptions`.
  */
 export declare function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V>;
-export declare function fromObservable<V>(observable: Subscribable<V>): Derivable<V>;
+export declare function fromObservable<V>(observable: Observable<V>): Derivable<V>;

package/sherlock-rxjs.cjs.js

@@ -21,7 +21,11 @@ function fromObservable(observable) {
     var subscription;
     atom$.connected$.react(function () {
         if (atom$.connected && !subscription) {
-            subscription = observable.subscribe(function (value) { return atom$.set(value); }, function (err) { return atom$.setFinal(new sherlock.ErrorWrapper(err)); }, function () { return atom$.setFinal(atom$.getState()); });
+            subscription = observable.subscribe({
+                next: function (value) { return atom$.set(value); },
+                error: function (err) { return atom$.setFinal(new sherlock.ErrorWrapper(err)); },
+                complete: function () { return atom$.setFinal(atom$.getState()); },
+            });
         }
         // This is not chained with the previous as an `else` branch, because this can be true immediately after
         // the subscription occurs. Observables can complete synchronously on subscription.

package/sherlock-rxjs.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.cjs.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":["Observable","_internal","atom","ErrorWrapper"],"mappings":";;;;;;;AAGA;;;;;;SAMgB,YAAY,CAAI,SAAuB,EAAE,OAAoC;IACzF,OAAO,IAAIA,eAAU,CAAI,UAAC,UAAyB;QAC/C,OAAOC,kBAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAA,EAC/B,OAAO,EACP,cAAM,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,GAAA,CACnD,CAAC;KACL,CAAC,CAAC;AACP,CAAC;SAEe,cAAc,CAAI,UAA2B;IACzD,IAAM,KAAK,GAAGC,aAAI,CAAC,UAAU,EAAK,CAAC;IAEnC,IAAI,YAAwC,CAAC;IAC7C,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC;QACnB,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;YAClC,YAAY,GAAG,UAAU,CAAC,SAAS,CAC/B,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAA,EACzB,UAAA,GAAG,IAAI,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAIC,qBAAY,CAAC,GAAG,CAAC,CAAC,GAAA,EAC5C,cAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA,CACzC,CAAC;SACL;;;QAGD,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;YAClC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;SAC5B;KACJ,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACjB;;;;;"}
+{"version":3,"file":"sherlock-rxjs.cjs.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":["Observable","_internal","atom","ErrorWrapper"],"mappings":";;;;;;;AAGA;;;;;AAKG;AACa,SAAA,YAAY,CAAI,SAAuB,EAAE,OAAoC,EAAA;AACzF,IAAA,OAAO,IAAIA,eAAU,CAAI,UAAC,UAAyB,EAAA;AAC/C,QAAA,OAAOC,kBAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAtB,EAAsB,EAC/B,OAAO,EACP,YAAM,EAAA,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,CAA1C,EAA0C,CACnD,CAAC;AACN,KAAC,CAAC,CAAC;AACP,CAAC;AAEK,SAAU,cAAc,CAAI,UAAyB,EAAA;AACvD,IAAA,IAAM,KAAK,GAAGC,aAAI,CAAC,UAAU,EAAK,CAAC;AAEnC,IAAA,IAAI,YAAsC,CAAC;AAC3C,IAAA,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,YAAA;AACnB,QAAA,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;AAClC,YAAA,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC;AAChC,gBAAA,IAAI,EAAE,UAAA,KAAK,EAAA,EAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA,EAAA;AAC/B,gBAAA,KAAK,EAAE,UAAA,GAAG,EAAI,EAAA,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAIC,qBAAY,CAAC,GAAG,CAAC,CAAC,GAAA;AACnD,gBAAA,QAAQ,EAAE,YAAA,EAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA;AACvD,aAAA,CAAC,CAAC;AACF,SAAA;;;AAGD,QAAA,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;YAClC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;AAC5B,SAAA;AACL,KAAC,CAAC,CAAC;AAEH,IAAA,OAAO,KAAK,CAAC;AACjB;;;;;"}

package/sherlock-rxjs.cjs.min.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var n=require("@politie/sherlock"),r=require("rxjs");exports.fromObservable=function(r){var e,t=n.atom.unresolved();return t.connected$.react((function(){t.connected&&!e&&(e=r.subscribe((function(n){return t.set(n)}),(function(r){return t.setFinal(new n.ErrorWrapper(r))}),(function(){return t.setFinal(t.getState())}))),!t.connected&&e&&(e.unsubscribe(),e=void 0)})),t},exports.toObservable=function(e,t){return new r.Observable((function(r){return n._internal.Reactor.create(e,(function(n){return r.next(n)}),t,(function(){return r.closed||r.complete()}))}))};
+Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@politie/sherlock"),n=require("rxjs");exports.fromObservable=function(n){var e,t=r.atom.unresolved();return t.connected$.react((function(){t.connected&&!e&&(e=n.subscribe({next:function(r){return t.set(r)},error:function(n){return t.setFinal(new r.ErrorWrapper(n))},complete:function(){return t.setFinal(t.getState())}})),!t.connected&&e&&(e.unsubscribe(),e=void 0)})),t},exports.toObservable=function(e,t){return new n.Observable((function(n){return r._internal.Reactor.create(e,(function(r){return n.next(r)}),t,(function(){return n.closed||n.complete()}))}))};
 //# sourceMappingURL=sherlock-rxjs.cjs.min.js.map

package/sherlock-rxjs.cjs.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.cjs.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","value","set","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","next","closed","complete"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"4IAmBkCA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,WACtB,SAAAC,GAAS,OAAAP,EAAMQ,IAAID,EAAM,IACzB,SAAAE,GAAO,OAAAT,EAAMU,SAAS,IAAIC,eAAaF,GAAK,IAC5C,WAAM,OAAAT,EAAMU,SAASV,EAAMY,WAAW,MAKzCZ,EAAMK,WAAaN,IACpBA,EAAac,cACbd,OAAee,E,IAIhBd,CACX,E,8BA/BgCe,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAR,GAAS,OAAAW,EAAWI,KAAKf,EAAM,GAC/BS,GACA,WAAM,OAAAE,EAAWK,QAAUL,EAAWM,UAAU,G,GAG5D"}
+{"version":3,"file":"sherlock-rxjs.cjs.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"mIAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,IAEOjB,CACX,E,qBA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,GACTW,GACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,GAEd,GACJ","ignoreList":[]}

package/sherlock-rxjs.esm.js

@@ -17,7 +17,11 @@ function fromObservable(observable) {
     var subscription;
     atom$.connected$.react(function () {
         if (atom$.connected && !subscription) {
-            subscription = observable.subscribe(function (value) { return atom$.set(value); }, function (err) { return atom$.setFinal(new ErrorWrapper(err)); }, function () { return atom$.setFinal(atom$.getState()); });
+            subscription = observable.subscribe({
+                next: function (value) { return atom$.set(value); },
+                error: function (err) { return atom$.setFinal(new ErrorWrapper(err)); },
+                complete: function () { return atom$.setFinal(atom$.getState()); },
+            });
         }
         // This is not chained with the previous as an `else` branch, because this can be true immediately after
         // the subscription occurs. Observables can complete synchronously on subscription.

package/sherlock-rxjs.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.esm.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":[],"mappings":";;;AAGA;;;;;;SAMgB,YAAY,CAAI,SAAuB,EAAE,OAAoC;IACzF,OAAO,IAAI,UAAU,CAAI,UAAC,UAAyB;QAC/C,OAAO,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAA,EAC/B,OAAO,EACP,cAAM,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,GAAA,CACnD,CAAC;KACL,CAAC,CAAC;AACP,CAAC;SAEe,cAAc,CAAI,UAA2B;IACzD,IAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAK,CAAC;IAEnC,IAAI,YAAwC,CAAC;IAC7C,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC;QACnB,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;YAClC,YAAY,GAAG,UAAU,CAAC,SAAS,CAC/B,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAA,EACzB,UAAA,GAAG,IAAI,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,GAAA,EAC5C,cAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA,CACzC,CAAC;SACL;;;QAGD,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;YAClC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;SAC5B;KACJ,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACjB;;;;"}
+{"version":3,"file":"sherlock-rxjs.esm.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":[],"mappings":";;;AAGA;;;;;AAKG;AACa,SAAA,YAAY,CAAI,SAAuB,EAAE,OAAoC,EAAA;AACzF,IAAA,OAAO,IAAI,UAAU,CAAI,UAAC,UAAyB,EAAA;AAC/C,QAAA,OAAO,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAtB,EAAsB,EAC/B,OAAO,EACP,YAAM,EAAA,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,CAA1C,EAA0C,CACnD,CAAC;AACN,KAAC,CAAC,CAAC;AACP,CAAC;AAEK,SAAU,cAAc,CAAI,UAAyB,EAAA;AACvD,IAAA,IAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAK,CAAC;AAEnC,IAAA,IAAI,YAAsC,CAAC;AAC3C,IAAA,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,YAAA;AACnB,QAAA,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;AAClC,YAAA,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC;AAChC,gBAAA,IAAI,EAAE,UAAA,KAAK,EAAA,EAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA,EAAA;AAC/B,gBAAA,KAAK,EAAE,UAAA,GAAG,EAAI,EAAA,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,GAAA;AACnD,gBAAA,QAAQ,EAAE,YAAA,EAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA;AACvD,aAAA,CAAC,CAAC;AACF,SAAA;;;AAGD,QAAA,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;YAClC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,YAAY,GAAG,SAAS,CAAC;AAC5B,SAAA;AACL,KAAC,CAAC,CAAC;AAEH,IAAA,OAAO,KAAK,CAAC;AACjB;;;;"}

package/sherlock-rxjs.esm.min.js

@@ -1,2 +1,2 @@
-import{_internal as n,atom as r,ErrorWrapper as t}from"@politie/sherlock";import{Observable as o}from"rxjs";function u(r,t){return new o((function(o){return n.Reactor.create(r,(function(n){return o.next(n)}),t,(function(){return o.closed||o.complete()}))}))}function i(n){var o,u=r.unresolved();return u.connected$.react((function(){u.connected&&!o&&(o=n.subscribe((function(n){return u.set(n)}),(function(n){return u.setFinal(new t(n))}),(function(){return u.setFinal(u.getState())}))),!u.connected&&o&&(o.unsubscribe(),o=void 0)})),u}export{i as fromObservable,u as toObservable};
+import{_internal as n,atom as r,ErrorWrapper as t}from"@politie/sherlock";import{Observable as o}from"rxjs";function e(r,t){return new o((function(o){return n.Reactor.create(r,(function(n){return o.next(n)}),t,(function(){return o.closed||o.complete()}))}))}function u(n){var o,e=r.unresolved();return e.connected$.react((function(){e.connected&&!o&&(o=n.subscribe({next:function(n){return e.set(n)},error:function(n){return e.setFinal(new t(n))},complete:function(){return e.setFinal(e.getState())}})),!e.connected&&o&&(o.unsubscribe(),o=void 0)})),e}export{u as fromObservable,e as toObservable};
 //# sourceMappingURL=sherlock-rxjs.esm.min.js.map

package/sherlock-rxjs.esm.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.esm.min.js","names":["toObservable","derivable","options","Observable","subscriber","_internal","Reactor","create","value","next","closed","complete","fromObservable","observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","set","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"qHASgBA,EAAgBC,EAAyBC,GACrD,OAAO,IAAIC,GAAc,SAACC,GACtB,OAAOC,EAAUC,QAAQC,OAAON,GAC5B,SAAAO,GAAS,OAAAJ,EAAWK,KAAKD,EAAM,GAC/BN,GACA,WAAM,OAAAE,EAAWM,QAAUN,EAAWO,UAAU,G,GAG5D,C,SAEgBC,EAAkBC,GAC9B,IAEIC,EAFEC,EAAQC,EAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,WACtB,SAAAb,GAAS,OAAAO,EAAMO,IAAId,EAAM,IACzB,SAAAe,GAAO,OAAAR,EAAMS,SAAS,IAAIC,EAAaF,GAAK,IAC5C,WAAM,OAAAR,EAAMS,SAAST,EAAMW,WAAW,MAKzCX,EAAMK,WAAaN,IACpBA,EAAaa,cACbb,OAAec,E,IAIhBb,CACX,Q"}
+{"version":3,"file":"sherlock-rxjs.esm.min.js","names":["toObservable","derivable","options","Observable","subscriber","_internal","Reactor","create","value","next","closed","complete","fromObservable","observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","set","error","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"4GASgB,SAAAA,EAAgBC,EAAyBC,GACrD,OAAO,IAAIC,GAAc,SAACC,GACtB,OAAOC,EAAUC,QAAQC,OAAON,GAC5B,SAAAO,GAAS,OAAAJ,EAAWK,KAAKD,EAAhB,GACTN,GACA,WAAM,OAAAE,EAAWM,QAAUN,EAAWO,UAAhC,GAEd,GACJ,CAEM,SAAUC,EAAkBC,GAC9B,IAEIC,EAFEC,EAAQC,EAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCZ,KAAM,SAAAD,GAAS,OAAAO,EAAMO,IAAId,EAAM,EAC/Be,MAAO,SAAAC,GAAO,OAAAT,EAAMU,SAAS,IAAIC,EAAaF,GAAK,EACnDb,SAAU,WAAM,OAAAI,EAAMU,SAASV,EAAMY,WAAW,MAKnDZ,EAAMK,WAAaN,IACpBA,EAAac,cACbd,OAAee,EAEvB,IAEOd,CACX,Q","ignoreList":[]}

package/sherlock-rxjs.umd.js

@@ -20,7 +20,11 @@
         var subscription;
         atom$.connected$.react(function () {
             if (atom$.connected && !subscription) {
-                subscription = observable.subscribe(function (value) { return atom$.set(value); }, function (err) { return atom$.setFinal(new sherlock.ErrorWrapper(err)); }, function () { return atom$.setFinal(atom$.getState()); });
+                subscription = observable.subscribe({
+                    next: function (value) { return atom$.set(value); },
+                    error: function (err) { return atom$.setFinal(new sherlock.ErrorWrapper(err)); },
+                    complete: function () { return atom$.setFinal(atom$.getState()); },
+                });
             }
             // This is not chained with the previous as an `else` branch, because this can be true immediately after
             // the subscription occurs. Observables can complete synchronously on subscription.

package/sherlock-rxjs.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.umd.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":["Observable","_internal","atom","ErrorWrapper"],"mappings":";;;;;;IAGA;;;;;;aAMgB,YAAY,CAAI,SAAuB,EAAE,OAAoC;QACzF,OAAO,IAAIA,eAAU,CAAI,UAAC,UAAyB;YAC/C,OAAOC,kBAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAA,EAC/B,OAAO,EACP,cAAM,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,GAAA,CACnD,CAAC;SACL,CAAC,CAAC;IACP,CAAC;aAEe,cAAc,CAAI,UAA2B;QACzD,IAAM,KAAK,GAAGC,aAAI,CAAC,UAAU,EAAK,CAAC;QAEnC,IAAI,YAAwC,CAAC;QAC7C,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC;YACnB,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;gBAClC,YAAY,GAAG,UAAU,CAAC,SAAS,CAC/B,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAA,EACzB,UAAA,GAAG,IAAI,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAIC,qBAAY,CAAC,GAAG,CAAC,CAAC,GAAA,EAC5C,cAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA,CACzC,CAAC;aACL;;;YAGD,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;gBAClC,YAAY,CAAC,WAAW,EAAE,CAAC;gBAC3B,YAAY,GAAG,SAAS,CAAC;aAC5B;SACJ,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACjB;;;;;;;;;;;"}
+{"version":3,"file":"sherlock-rxjs.umd.js","sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"names":["Observable","_internal","atom","ErrorWrapper"],"mappings":";;;;;;IAGA;;;;;IAKG;IACa,SAAA,YAAY,CAAI,SAAuB,EAAE,OAAoC,EAAA;IACzF,IAAA,OAAO,IAAIA,eAAU,CAAI,UAAC,UAAyB,EAAA;IAC/C,QAAA,OAAOC,kBAAS,CAAC,OAAO,CAAC,MAAM,CAAC,SAAuC,EACnE,UAAA,KAAK,IAAI,OAAA,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAtB,EAAsB,EAC/B,OAAO,EACP,YAAM,EAAA,OAAA,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,QAAQ,EAAE,CAA1C,EAA0C,CACnD,CAAC;IACN,KAAC,CAAC,CAAC;IACP,CAAC;IAEK,SAAU,cAAc,CAAI,UAAyB,EAAA;IACvD,IAAA,IAAM,KAAK,GAAGC,aAAI,CAAC,UAAU,EAAK,CAAC;IAEnC,IAAA,IAAI,YAAsC,CAAC;IAC3C,IAAA,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,YAAA;IACnB,QAAA,IAAI,KAAK,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;IAClC,YAAA,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC;IAChC,gBAAA,IAAI,EAAE,UAAA,KAAK,EAAA,EAAI,OAAA,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA,EAAA;IAC/B,gBAAA,KAAK,EAAE,UAAA,GAAG,EAAI,EAAA,OAAA,KAAK,CAAC,QAAQ,CAAC,IAAIC,qBAAY,CAAC,GAAG,CAAC,CAAC,GAAA;IACnD,gBAAA,QAAQ,EAAE,YAAA,EAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAA;IACvD,aAAA,CAAC,CAAC;IACF,SAAA;;;IAGD,QAAA,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,YAAY,EAAE;gBAClC,YAAY,CAAC,WAAW,EAAE,CAAC;gBAC3B,YAAY,GAAG,SAAS,CAAC;IAC5B,SAAA;IACL,KAAC,CAAC,CAAC;IAEH,IAAA,OAAO,KAAK,CAAC;IACjB;;;;;;;;;;;"}

package/sherlock-rxjs.umd.min.js

@@ -1,2 +1,2 @@
-!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports,require("@politie/sherlock"),require("rxjs")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock","rxjs"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).SherlockRxjs={},e.Sherlock,e.Rx)}(this,(function(e,n,t){"use strict";e.fromObservable=function(e){var t,o=n.atom.unresolved();return o.connected$.react((function(){o.connected&&!t&&(t=e.subscribe((function(e){return o.set(e)}),(function(e){return o.setFinal(new n.ErrorWrapper(e))}),(function(){return o.setFinal(o.getState())}))),!o.connected&&t&&(t.unsubscribe(),t=void 0)})),o},e.toObservable=function(e,o){return new t.Observable((function(t){return n._internal.Reactor.create(e,(function(e){return t.next(e)}),o,(function(){return t.closed||t.complete()}))}))},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports,require("@politie/sherlock"),require("rxjs")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock","rxjs"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).SherlockRxjs={},e.Sherlock,e.Rx)}(this,(function(e,n,t){"use strict";e.fromObservable=function(e){var t,r=n.atom.unresolved();return r.connected$.react((function(){r.connected&&!t&&(t=e.subscribe({next:function(e){return r.set(e)},error:function(e){return r.setFinal(new n.ErrorWrapper(e))},complete:function(){return r.setFinal(r.getState())}})),!r.connected&&t&&(t.unsubscribe(),t=void 0)})),r},e.toObservable=function(e,r){return new t.Observable((function(t){return n._internal.Reactor.create(e,(function(e){return t.next(e)}),r,(function(){return t.closed||t.complete()}))}))},Object.defineProperty(e,"__esModule",{value:!0})}));
 //# sourceMappingURL=sherlock-rxjs.umd.min.js.map

package/sherlock-rxjs.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.umd.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","value","set","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","next","closed","complete"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscribable, Subscriber, Unsubscribable } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Subscribable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Unsubscribable | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe(\n                value => atom$.set(value),\n                err => atom$.setFinal(new ErrorWrapper(err)),\n                () => atom$.setFinal(atom$.getState()),\n            );\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"0WAmBkCA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,WACtB,SAAAC,GAAS,OAAAP,EAAMQ,IAAID,EAAM,IACzB,SAAAE,GAAO,OAAAT,EAAMU,SAAS,IAAIC,eAAaF,GAAK,IAC5C,WAAM,OAAAT,EAAMU,SAASV,EAAMY,WAAW,MAKzCZ,EAAMK,WAAaN,IACpBA,EAAac,cACbd,OAAee,E,IAIhBd,CACX,E,wBA/BgCe,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAR,GAAS,OAAAW,EAAWI,KAAKf,EAAM,GAC/BS,GACA,WAAM,OAAAE,EAAWK,QAAUL,EAAWM,UAAU,G,GAG5D,E"}
+{"version":3,"file":"sherlock-rxjs.umd.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"iWAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,IAEOjB,CACX,E,eA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,GACTW,GACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,GAEd,GACJ,E","ignoreList":[]}