exupery-core-internals 0.1.4 → 0.1.6

package/dist/imp/public/array_literal.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.array_literal = array_literal;
 const create_asynchronous_processes_monitor_1 = require("../private/create_asynchronous_processes_monitor");
 const create_Async_Value_1 = require("./create_Async_Value");
+const create_Unsafe_Async_Value_1 = require("./create_Unsafe_Async_Value");
 const not_set_1 = require("./not_set");
 const set_1 = require("./set");
 /**
@@ -19,7 +20,7 @@ class Array_Class {
             return $v(entry);
         }));
     }
-    async_map(on_element_value) {
+    map_async(on_element_value) {
         const data = this.data;
         return (0, create_Async_Value_1.create_Async_Value)({
             'execute': (on_array_value) => {
@@ -38,6 +39,34 @@ class Array_Class {
             }
         });
     }
+    map_async_unsafe(on_element_value) {
+        const data = this.data;
+        return (0, create_Unsafe_Async_Value_1.create_Unsafe_Async_Value)({
+            'execute': (on_array_value, on_array_exception) => {
+                const temp_values = [];
+                const temp_exceptions = [];
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((registry) => {
+                    data.map(on_element_value).forEach((v) => {
+                        registry['report process started']();
+                        v.__start(($) => {
+                            temp_values.push($);
+                            registry['report process finished']();
+                        }, ($) => {
+                            temp_exceptions.push($);
+                            registry['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (temp_exceptions.length > 0) {
+                        on_array_exception(array_literal(temp_exceptions));
+                    }
+                    else {
+                        on_array_value(array_literal(temp_values));
+                    }
+                });
+            }
+        });
+    }
     //internal methods
     __for_each($i) {
         this.data.forEach(($) => {

package/dist/imp/public/create_Async_Value.js

@@ -6,6 +6,15 @@ class Async_Value_Class {
         this.executer = executer;
     }
     map(handle_value) {
+        return create_Async_Value({
+            'execute': (on_value) => {
+                this.executer.execute((value) => {
+                    on_value(handle_value(value));
+                });
+            }
+        });
+    }
+    then(handle_value) {
         return create_Async_Value({
             'execute': (on_value) => {
                 this.executer.execute((value) => {

package/dist/imp/public/create_Unsafe_Async_Value.d.ts

@@ -0,0 +1,17 @@
+import * as _et from "exupery-core-types";
+/**
+ * this function contains the body in which the async value or exception is executed
+ * after the execution, either the on_value or on_exception callback will be called
+ * @param on_value the callback to call when a value is produced
+ * @param on_exception the callback to call when an error is produced
+ */
+type Executer<T, E> = {
+    'execute': (on_value: ($: T) => void, on_exception: ($: E) => void) => void;
+};
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+export declare function create_Unsafe_Async_Value<T, E>(executer: Executer<T, E>): _et.Unsafe_Async_Value<T, E>;
+export {};

package/dist/imp/public/create_Unsafe_Async_Value.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_Unsafe_Async_Value = create_Unsafe_Async_Value;
+const create_Async_Value_1 = require("./create_Async_Value");
+class Unsafe_Async_Value_Class {
+    constructor(executer) {
+        this.executer = executer;
+    }
+    map(handle_value) {
+        return new Unsafe_Async_Value_Class({
+            'execute': (on_value, on_exception) => {
+                this.executer.execute(($) => {
+                    on_value(handle_value($));
+                }, on_exception);
+            }
+        });
+    }
+    then(handle_value) {
+        return new Unsafe_Async_Value_Class({
+            'execute': (new_on_value, new_on_exception) => {
+                this.executer.execute(($) => {
+                    handle_value($).__start(new_on_value, new_on_exception);
+                }, new_on_exception);
+            }
+        });
+    }
+    if_exception_then(handle_exception) {
+        return new Unsafe_Async_Value_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_Async_Value_Class({
+            'execute': (on_value, on_exception) => {
+                this.executer.execute(on_value, ($) => {
+                    on_exception(handle_exception($));
+                });
+            }
+        });
+    }
+    catch(handle_exception) {
+        return (0, create_Async_Value_1.create_Async_Value)({
+            'execute': (on_value) => {
+                this.executer.execute(on_value, ($) => {
+                    on_value(handle_exception($));
+                });
+            }
+        });
+    }
+    catch_and_map(handle_value, handle_exception) {
+        return (0, create_Async_Value_1.create_Async_Value)({
+            'execute': (on_value) => {
+                this.executer.execute(($) => {
+                    on_value(handle_value($));
+                }, ($) => {
+                    on_value(handle_exception($));
+                });
+            }
+        });
+    }
+    __start(on_value, on_exception) {
+        this.executer.execute(on_value, on_exception);
+    }
+}
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+function create_Unsafe_Async_Value(executer) {
+    return new Unsafe_Async_Value_Class(executer);
+}

package/dist/imp/public/dictionary_literal.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dictionary_literal = dictionary_literal;
 const create_asynchronous_processes_monitor_1 = require("../private/create_asynchronous_processes_monitor");
 const create_Async_Value_1 = require("./create_Async_Value");
+const create_Unsafe_Async_Value_1 = require("./create_Unsafe_Async_Value");
 const set_1 = require("./set");
 const not_set_1 = require("./not_set");
 const array_literal_1 = require("./array_literal");
@@ -21,7 +22,7 @@ class Dictionary {
             };
         }));
     }
-    async_map(on_entry_value) {
+    map_async(on_entry_value) {
         const source = this.source;
         const temp = {};
         return (0, create_Async_Value_1.create_Async_Value)({
@@ -40,6 +41,34 @@ class Dictionary {
             }
         });
     }
+    map_async_unsafe(on_entry_value) {
+        const source = this.source;
+        const temp_values = {};
+        const temp_exceptions = {};
+        return (0, create_Unsafe_Async_Value_1.create_Unsafe_Async_Value)({
+            'execute': (on_dictionary_value, on_dictionary_exception) => {
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((counter) => {
+                    source.map(($) => {
+                        counter['report process started']();
+                        on_entry_value($.value).__start((value) => {
+                            temp_values[$.key] = value;
+                            counter['report process finished']();
+                        }, (exception) => {
+                            temp_exceptions[$.key] = exception;
+                            counter['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (Object.keys(temp_exceptions).length > 0) {
+                        on_dictionary_exception(dictionary_literal(temp_exceptions));
+                    }
+                    else {
+                        on_dictionary_value(dictionary_literal(temp_values));
+                    }
+                });
+            }
+        });
+    }
     __map_with_key($v) {
         return new Dictionary(this.source.map(($) => {
             return {

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from "./imp/public/get_location_info";
 export * from "./imp/public/resolve_async_tuple_2";
 export * from "./imp/public/make_async";
 export * from "./imp/public/create_Async_Value";
+export * from "./imp/public/create_Unsafe_Async_Value";
 export * from "./imp/public/set";
 export * from "./imp/public/not_set";
 export * from "./imp/public/Error";

package/dist/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./imp/public/get_location_info"), exports);
 __exportStar(require("./imp/public/resolve_async_tuple_2"), exports);
 __exportStar(require("./imp/public/make_async"), exports);
 __exportStar(require("./imp/public/create_Async_Value"), exports);
+__exportStar(require("./imp/public/create_Unsafe_Async_Value"), exports);
 __exportStar(require("./imp/public/set"), exports);
 __exportStar(require("./imp/public/not_set"), exports);
 __exportStar(require("./imp/public/Error"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-internals",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "license": "ISC",
   "description": "",
   "author": "Corno",
@@ -15,7 +15,7 @@
     "url": "https://github.com/corno/exupery-core/issues"
   },
   "dependencies": {
-    "exupery-core-types": "^0.1.2"
+    "exupery-core-types": "^0.1.4"
   },
   "devDependencies": {
     "@types/node": "^18.15.3"