exupery-core-async 0.1.7 → 0.1.8

package/dist/Safe_Query_Result.d.ts

@@ -1,3 +1,5 @@
+import { Safe_Command_Result } from "./Safe_Command_Result";
+import { Unsafe_Command_Result } from "./Unsafe_Command_Result";
 /**
  * A value that will asynchronously become available.
  * Similar to the concept of a promise, but with a smaller API.
@@ -9,6 +11,8 @@ export interface Safe_Query_Result<T> {
      * @param handle_value callback that transforms the actual value into a new Async_Value
      */
     then<NT>(handle_value: ($: T) => Safe_Query_Result<NT>): Safe_Query_Result<NT>;
+    execute_safe_command(handle_value: ($: T) => Safe_Command_Result): Safe_Command_Result;
+    execute_unsafe_command<E>(handle_value: ($: T) => Unsafe_Command_Result<E>): Unsafe_Command_Result<E>;
     /**
      * This method is only to be used by resources
      */

package/dist/Unsafe_Command_Result.d.ts

@@ -1,6 +1,8 @@
+import * as _et from 'exupery-core-types';
 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>;
     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>;
     __start(on_success: () => void, on_exception: ($: E) => void): void;
 }

package/dist/execute_unsafe_command.js

@@ -1,7 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__execute_unsafe_command = __execute_unsafe_command;
+const _ei = __importStar(require("exupery-core-internals"));
 const execute_safe_command_1 = require("./execute_safe_command");
+const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
 class Unsafe_Command_Result_Class {
     constructor(executer) {
         this.executer = executer;
@@ -33,6 +58,31 @@ class Unsafe_Command_Result_Class {
             }
         });
     }
+    do_dictionary($, aggregate_exceptions) {
+        let exceptions = {};
+        return __execute_unsafe_command({
+            'execute': (on_success, on_exception) => {
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
+                    $.map(($, key) => {
+                        monitor['report process started']();
+                        $.__start(() => {
+                            monitor['report process finished']();
+                        }, (e) => {
+                            exceptions[key] = e;
+                            monitor['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (Object.keys(exceptions).length === 0) {
+                        on_success();
+                    }
+                    else {
+                        on_exception(aggregate_exceptions(_ei.dictionary_literal(exceptions)));
+                    }
+                });
+            }
+        });
+    }
     catch(handle_exception) {
         return (0, execute_safe_command_1.__execute_safe_command)({
             'execute': (on_success) => {

package/dist/index.js

@@ -102,7 +102,6 @@ exports.command = {
                             on_exception(_ei.dictionary_literal(exceptions));
                         }
                     });
-                    on_success();
                 }
             });
         }

package/dist/run_safe_query.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__run_safe_query = __run_safe_query;
+const execute_safe_command_1 = require("./execute_safe_command");
+const execute_unsafe_command_1 = require("./execute_unsafe_command");
 class Safe_Query_Result_Class {
     constructor(executer) {
         this.executer = executer;
@@ -23,6 +25,24 @@ class Safe_Query_Result_Class {
             }
         });
     }
+    execute_safe_command(handle_value) {
+        return (0, execute_safe_command_1.__execute_safe_command)({
+            'execute': (on_success) => {
+                this.executer.execute((value) => {
+                    handle_value(value).__start(on_success);
+                });
+            }
+        });
+    }
+    execute_unsafe_command(handle_value) {
+        return (0, execute_unsafe_command_1.__execute_unsafe_command)({
+            'execute': (on_success, on_exception) => {
+                this.executer.execute((value) => {
+                    handle_value(value).__start(on_success, on_exception);
+                });
+            }
+        });
+    }
     __start(on_value) {
         this.executer.execute(on_value);
     }

package/package.json

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