exupery-core-internals 0.1.3 → 0.1.5

package/dist/imp/private/create_asynchronous_processes_monitor.d.ts

@@ -0,0 +1,15 @@
+export type I_Async_Monitor = {
+    readonly 'report process started': () => void;
+    readonly 'report process finished': () => void;
+};
+/**
+ * this function helps in keeping track of ongoing async operations
+ * async operations are registered and when finished reported as such.
+ * when all ongoing operations are finished the onEnd callback is called
+ *
+ * this function is specifically useful for async map functions
+ *
+ * @param callback this callback creates a scope within which the counter is provided
+ * @param onEnd this callback will be called when all ongoing operations are finished
+ */
+export declare function create_asynchronous_processes_monitor(monitoring_phase: ($: I_Async_Monitor) => void, on_all_finished: () => void): void;

package/dist/imp/private/{create_async_registry.js → create_asynchronous_processes_monitor.js}

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_async_registry = create_async_registry;
+exports.create_asynchronous_processes_monitor = create_asynchronous_processes_monitor;
 /**
- * this function provides a callback with a counter as parameter
- * when the counter reaches 0, the onEnd callback is called
+ * this function helps in keeping track of ongoing async operations
+ * async operations are registered and when finished reported as such.
+ * when all ongoing operations are finished the onEnd callback is called
  *
  * this function is specifically useful for async map functions
  *
  * @param callback this callback creates a scope within which the counter is provided
- * @param onEnd this callback will be called when the counter reaches 0
+ * @param onEnd this callback will be called when all ongoing operations are finished
  */
-function create_async_registry(registration_phase, on_all_finished) {
+function create_asynchronous_processes_monitor(monitoring_phase, on_all_finished) {
     let counter = 0;
     /*
      * we need to keep track of if the registration phase is ended or not.
@@ -31,14 +32,14 @@ function create_async_registry(registration_phase, on_all_finished) {
             }
         }
     }
-    registration_phase({
-        register: () => {
+    monitoring_phase({
+        'report process started': () => {
             if (on_all_finished_has_been_called) {
                 throw new Error("CORE: async call done after context is ready");
             }
             counter += 1;
         },
-        report_finished: () => {
+        'report process finished': () => {
             if (counter === 0) {
                 throw new Error("CORE: decrement while counter is 0");
             }

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

@@ -1,4 +1,4 @@
-import * as pt from "exupery-core-types";
+import * as _et from "exupery-core-types";
 /**
  * returns a Exupery array
  * why is this not the constructor? to call a constructor, you have to use the keyword 'new'. Exupery doesn't use the concept of a class so that keyword should be avoided
@@ -6,4 +6,4 @@ import * as pt from "exupery-core-types";
  * @param source An array literal
  * @returns
  */
-export declare function array_literal<T>(source: readonly T[]): pt.Array<T>;
+export declare function array_literal<T>(source: readonly T[]): _et.Array<T>;

package/dist/imp/public/array_literal.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.array_literal = array_literal;
-const create_async_registry_1 = require("../private/create_async_registry");
-const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+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,34 +20,54 @@ class Array_Class {
             return $v(entry);
         }));
     }
-    async_map($v) {
-        // const elements = source.map($v)
-        // let _isGuaranteedToReturnAResult = true
-        // source.forEach(($) => {
-        //     if ($)
-        // })
-        function array(array, $v) {
-            const mapped = array.map($v);
-            return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)({
-                'execute': (on_value) => {
-                    const temp = [];
-                    (0, create_async_registry_1.create_async_registry)((registry) => {
-                        mapped.forEach((v) => {
-                            registry.register();
-                            v.__start((v) => {
-                                temp.push(v);
-                                registry.report_finished();
-                            });
+    map_async(on_element_value) {
+        const data = this.data;
+        return (0, create_Async_Value_1.create_Async_Value)({
+            'execute': (on_array_value) => {
+                const temp = [];
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((registry) => {
+                    data.map(on_element_value).forEach((v) => {
+                        registry['report process started']();
+                        v.__start((v) => {
+                            temp.push(v);
+                            registry['report process finished']();
                         });
-                    }, () => {
-                        on_value(array_literal(temp));
                     });
-                }
-            });
-        }
-        return array(this.data, $v);
+                }, () => {
+                    on_array_value(array_literal(temp));
+                });
+            }
+        });
+    }
+    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(($) => {
             $i($);

package/dist/imp/public/{cast_to_async_value_imp.d.ts → create_Async_Value.d.ts}

@@ -7,4 +7,4 @@ export type Executer<T> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function cast_to_async_value_imp<T>(executer: Executer<T>): pt.Async_Value<T>;
+export declare function create_Async_Value<T>(executer: Executer<T>): pt.Async_Value<T>;

package/dist/imp/public/{cast_to_async_value_imp.js → create_Async_Value.js}

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cast_to_async_value_imp = cast_to_async_value_imp;
+exports.create_Async_Value = create_Async_Value;
 class Async_Value_Class {
     constructor(executer) {
         this.executer = executer;
     }
     map(handle_value) {
-        return cast_to_async_value_imp({
+        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) => {
                     handle_value(value).__start(on_value);
@@ -23,6 +32,6 @@ class Async_Value_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function cast_to_async_value_imp(executer) {
+function create_Async_Value(executer) {
     return new Async_Value_Class(executer);
 }

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dictionary_literal = dictionary_literal;
-const create_async_registry_1 = require("../private/create_async_registry");
-const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+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,32 +22,52 @@ class Dictionary {
             };
         }));
     }
-    async_map($v) {
-        function imp(dictionary_as_array, $v) {
-            const mapped = dictionary_as_array.map(($) => {
-                return {
-                    key: $.key,
-                    value: $v($.value),
-                };
-            });
-            return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)({
-                'execute': (on_value) => {
-                    const temp = {};
-                    (0, create_async_registry_1.create_async_registry)((counter) => {
-                        mapped.map(($) => {
-                            counter.register();
-                            $.value.__start((nv) => {
-                                temp[$.key] = nv;
-                                counter.report_finished();
-                            });
+    map_async(on_entry_value) {
+        const source = this.source;
+        const temp = {};
+        return (0, create_Async_Value_1.create_Async_Value)({
+            'execute': (on_dictionary_value) => {
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((counter) => {
+                    source.map(($) => {
+                        counter['report process started']();
+                        on_entry_value($.value).__start((nv) => {
+                            temp[$.key] = nv;
+                            counter['report process finished']();
                         });
-                    }, () => {
-                        on_value(dictionary_literal(temp));
                     });
-                }
-            });
-        }
-        return imp(this.source, $v);
+                }, () => {
+                    on_dictionary_value(dictionary_literal(temp));
+                });
+            }
+        });
+    }
+    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(($) => {

package/dist/imp/public/make_async.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.make_async = make_async;
-const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+const create_Async_Value_1 = require("./create_Async_Value");
 /**
  * converts a regular value to a {@link Async_Value}
  * @param $ the value
  * @returns
  */
 function make_async($) {
-    return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)({
+    return (0, create_Async_Value_1.create_Async_Value)({
         'execute': (on_value) => {
             on_value($);
         }

package/dist/imp/public/resolve_async_tuple_2.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolve_async_tuple_2 = resolve_async_tuple_2;
-const cast_to_async_value_imp_1 = require("./cast_to_async_value_imp");
+const create_Async_Value_1 = require("./create_Async_Value");
 function resolve_async_tuple_2(first, second) {
-    return (0, cast_to_async_value_imp_1.cast_to_async_value_imp)({
+    return (0, create_Async_Value_1.create_Async_Value)({
         'execute': (on_value) => {
             let element_1_is_set = false;
             let element_2_is_set = false;

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export * from "./imp/public/switch_state";
 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/cast_to_async_value_imp";
+export * from "./imp/public/create_Async_Value";
 export * from "./imp/public/set";
 export * from "./imp/public/not_set";
 export * from "./imp/public/Error";

package/dist/index.js

@@ -24,7 +24,7 @@ __exportStar(require("./imp/public/switch_state"), exports);
 __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/cast_to_async_value_imp"), exports);
+__exportStar(require("./imp/public/create_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.3",
+  "version": "0.1.5",
   "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"

package/dist/imp/private/create_async_registry.d.ts

@@ -1,14 +0,0 @@
-export type I_Async_Registry = {
-    readonly 'register': () => void;
-    readonly 'report_finished': () => void;
-};
-/**
- * this function provides a callback with a counter as parameter
- * when the counter reaches 0, the onEnd callback is called
- *
- * this function is specifically useful for async map functions
- *
- * @param callback this callback creates a scope within which the counter is provided
- * @param onEnd this callback will be called when the counter reaches 0
- */
-export declare function create_async_registry(registration_phase: ($: I_Async_Registry) => void, on_all_finished: () => void): void;