exupery-core-async 0.1.10 → 0.1.12

package/dist/Unsafe_Command_Result.d.ts

@@ -1,8 +1,22 @@
 import * as _et from 'exupery-core-types';
+import { Safe_Command_Result } from "./Safe_Command_Result";
 export interface Unsafe_Command_Result<E> {
     map_exception<NE>(handle_exception: ($: E) => NE): Unsafe_Command_Result<NE>;
-    if_exception_then<NE>(handle_exception: ($: E) => Unsafe_Command_Result<NE>): Unsafe_Command_Result<NE>;
+    /**
+     *
+     * executes a command when an exception has occurred,
+     * but stays in the unsafe context
+     *
+     * this is useful when you want to do some cleanup
+     * or logging in case of an exception,
+     * but still want to propagate the exception further
+     *
+     * note that this is different from `catch`,
+     * which would switch to the safe context
+     */
+    if_exception_then(handle_exception: ($: E) => Safe_Command_Result): Unsafe_Command_Result<E>;
+    catch(handle_exception: ($: E) => Safe_Command_Result): Safe_Command_Result;
     then(handle: () => Unsafe_Command_Result<E>): Unsafe_Command_Result<E>;
-    do_dictionary<E2>($: _et.Dictionary<Unsafe_Command_Result<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Unsafe_Command_Result<E>;
+    then_dictionary<E2>($: _et.Dictionary<Unsafe_Command_Result<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Unsafe_Command_Result<E>;
     __start(on_success: () => void, on_exception: ($: E) => void): void;
 }

package/dist/Unsafe_Query_Result.d.ts

@@ -4,9 +4,7 @@ export interface Unsafe_Query_Result<T, E> {
     map<NT>(handle_value: ($: T) => NT): Unsafe_Query_Result<NT, E>;
     map_exception<NE>(handle_exception: ($: E) => NE): Unsafe_Query_Result<T, NE>;
     then<NT>(handle_value: ($: T) => Unsafe_Query_Result<NT, E>): Unsafe_Query_Result<NT, E>;
-    if_exception_then<NE>(handle_exception: ($: E) => Unsafe_Query_Result<T, NE>): Unsafe_Query_Result<T, NE>;
     catch(handle_exception: ($: E) => T): Safe_Query_Result<T>;
-    catch_and_map<NT>(handle_value: ($: T) => NT, handle_exception: ($: E) => NT): Safe_Query_Result<NT>;
     execute_unsafe_command(handle_value: ($: T) => Unsafe_Command_Result<E>): Unsafe_Command_Result<E>;
     __start(on_value: ($: T) => void, on_exception: ($: E) => void): void;
 }

package/dist/execute_unsafe_command.js

@@ -31,20 +31,20 @@ class Unsafe_Command_Result_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    then(handle) {
+    if_exception_then(handle_exception) {
         return new Unsafe_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
-                this.executer.execute(() => {
-                    handle().__start(new_on_success, new_on_exception);
-                }, new_on_exception);
+                this.executer.execute(new_on_success, ($) => {
+                    handle_exception($).__start(() => new_on_exception($));
+                });
             }
         });
     }
-    if_exception_then(handle_exception) {
-        return new Unsafe_Command_Result_Class({
-            'execute': (new_on_success, new_on_exception) => {
+    catch(handle_exception) {
+        return (0, execute_safe_command_1.__execute_safe_command)({
+            'execute': (new_on_success) => {
                 this.executer.execute(new_on_success, ($) => {
-                    handle_exception($).__start(new_on_success, new_on_exception);
+                    handle_exception($).__start(new_on_success);
                 });
             }
         });
@@ -58,7 +58,16 @@ class Unsafe_Command_Result_Class {
             }
         });
     }
-    do_dictionary($, aggregate_exceptions) {
+    then(handle) {
+        return new Unsafe_Command_Result_Class({
+            'execute': (new_on_success, new_on_exception) => {
+                this.executer.execute(() => {
+                    handle().__start(new_on_success, new_on_exception);
+                }, new_on_exception);
+            }
+        });
+    }
+    then_dictionary($, aggregate_exceptions) {
         let exceptions = {};
         return __execute_unsafe_command({
             'execute': (on_success, on_exception) => {
@@ -83,16 +92,6 @@ class Unsafe_Command_Result_Class {
             }
         });
     }
-    catch(handle_exception) {
-        return (0, execute_safe_command_1.__execute_safe_command)({
-            'execute': (on_success) => {
-                this.executer.execute(on_success, ($) => {
-                    handle_exception($);
-                    on_success();
-                });
-            }
-        });
-    }
     __start(on_success, on_exception) {
         this.executer.execute(on_success, on_exception);
     }

package/dist/run_unsafe_query.js

@@ -25,15 +25,6 @@ class Unsafe_Query_Result_Class {
             }
         });
     }
-    if_exception_then(handle_exception) {
-        return new Unsafe_Query_Result_Class({
-            'execute': (new_on_value, new_on_exception) => {
-                this.executer.execute(new_on_value, ($) => {
-                    handle_exception($).__start(new_on_value, new_on_exception);
-                });
-            }
-        });
-    }
     map_exception(handle_exception) {
         return new Unsafe_Query_Result_Class({
             'execute': (on_value, on_exception) => {
@@ -52,17 +43,6 @@ class Unsafe_Query_Result_Class {
             }
         });
     }
-    catch_and_map(handle_value, handle_exception) {
-        return (0, run_safe_query_1.__run_safe_query)({
-            'execute': (on_value) => {
-                this.executer.execute(($) => {
-                    on_value(handle_value($));
-                }, ($) => {
-                    on_value(handle_exception($));
-                });
-            }
-        });
-    }
     execute_unsafe_command(handle_value) {
         return (0, execute_unsafe_command_1.__execute_unsafe_command)({
             'execute': (on_success, on_exception) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-async",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "async types for Exupery",