exupery-core-async 0.3.19 → 0.3.20

package/dist/algorithms/procedure/create_procedure_primed_with_resources.js

@@ -7,10 +7,10 @@ const __create_procedure_primed_with_resources = (handler) => {
         'execute with synchronous data': handler,
         'execute with asynchronous data': (query) => {
             return (0, create_procedure_promise_1.__create_procedure_promise)({
-                'execute': (on_success, on_exception) => {
+                'execute': (on_success, on_error) => {
                     query.__start(($) => {
-                        handler($).__start(on_success, on_exception);
-                    }, on_exception);
+                        handler($).__start(on_success, on_error);
+                    }, on_error);
                 }
             });
         }

package/dist/algorithms/procedure/create_procedure_promise.d.ts

@@ -1,12 +1,12 @@
 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
+ * after the execution, either the on_value or on_error 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
+ * @param on_error the callback to call when an error is produced
  */
 type Executer<E> = {
-    'execute': (on_success: () => void, on_exception: ($: E) => void) => void;
+    'execute': (on_success: () => void, on_error: ($: E) => void) => void;
 };
 /**
  * returns an {@link Async_Value }

package/dist/algorithms/procedure/create_procedure_promise.js

@@ -5,14 +5,14 @@ class Procedure_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    __start(on_success, on_exception) {
-        this.executer.execute(on_success, on_exception);
+    __start(on_success, on_error) {
+        this.executer.execute(on_success, on_error);
     }
     map_error(handle_error) {
         return new Procedure_Promise_Class({
-            'execute': (on_success, on_exception) => {
+            'execute': (on_success, on_error) => {
                 this.executer.execute(on_success, (error) => {
-                    on_exception(handle_error(error));
+                    on_error(handle_error(error));
                 });
             }
         });

package/dist/algorithms/query/create_query_promise.d.ts

@@ -1,12 +1,12 @@
 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
+ * after the execution, either the on_value or on_error 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
+ * @param on_error the callback to call when an error is produced
  */
 type Executer<T, E> = {
-    'execute': (on_value: ($: T) => void, on_exception: ($: E) => void) => void;
+    'execute': (on_value: ($: T) => void, on_error: ($: E) => void) => void;
 };
 /**
  * returns an {@link Async_Value }

package/dist/algorithms/query/create_query_promise.js

@@ -5,35 +5,35 @@ class Query_Result_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    map_(handle_value) {
+    then(handle_value) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_exception) => {
+            'execute': (on_value, on_error) => {
                 this.executer.execute(($) => {
-                    on_value(handle_value($));
-                }, on_exception);
+                    handle_value($).__start(on_value, on_error);
+                }, on_error);
             }
         });
     }
-    then(handle_value) {
+    map_exception(handle_exception) {
         return new Query_Result_Promise_Class({
-            'execute': (new_on_value, new_on_exception) => {
-                this.executer.execute(($) => {
-                    handle_value($).__start(new_on_value, new_on_exception);
-                }, new_on_exception);
+            'execute': (on_value, on_error) => {
+                this.executer.execute(on_value, ($) => {
+                    on_error(handle_exception($));
+                });
             }
         });
     }
-    map_exception_(handle_exception) {
+    process(processor) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_exception) => {
-                this.executer.execute(on_value, ($) => {
-                    on_exception(handle_exception($));
-                });
+            'execute': (on_value, on_error) => {
+                this.executer.execute(($) => {
+                    processor($).__extract_data(on_value, on_error);
+                }, on_error);
             }
         });
     }
-    __start(on_value, on_exception) {
-        this.executer.execute(on_value, on_exception);
+    __start(on_value, on_error) {
+        this.executer.execute(on_value, on_error);
     }
 }
 /**

package/dist/index.d.ts

@@ -4,7 +4,6 @@ export * from "./algorithms/query/create_query_promise";
 export * from "./algorithms/procedure/create_procedure";
 export * from "./algorithms/procedure/create_procedure_promise";
 export * from "./algorithms/procedure/create_procedure_primed_with_resources";
-export * from "./process_result";
 export * from "./shorthands";
 export * from "./procedure/assert_async";
 export * from "./procedure/assert_sync";

package/dist/index.js

@@ -22,7 +22,6 @@ __exportStar(require("./algorithms/query/create_query_promise"), exports);
 __exportStar(require("./algorithms/procedure/create_procedure"), exports);
 __exportStar(require("./algorithms/procedure/create_procedure_promise"), exports);
 __exportStar(require("./algorithms/procedure/create_procedure_primed_with_resources"), exports);
-__exportStar(require("./process_result"), exports);
 __exportStar(require("./shorthands"), exports);
 // procedure exports
 __exportStar(require("./procedure/assert_async"), exports);
@@ -50,8 +49,8 @@ exports.query = {
     },
     'raise exception': ($) => {
         return (0, create_query_promise_1.__create_query_promise)({
-            'execute': (on_value, on_exception) => {
-                on_exception($);
+            'execute': (on_value, on_error) => {
+                on_error($);
             }
         });
     }

package/dist/procedure/assert_async.js

@@ -4,18 +4,18 @@ exports.assert_async = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const assert_async = (assertion, procedure) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             assertion.__start(($) => {
                 if ($) {
                     procedure.__start(on_success, ($) => {
-                        on_exception(['procedure error', $]);
+                        on_error(['procedure error', $]);
                     });
                 }
                 else {
-                    on_exception(['assertion failed', null]);
+                    on_error(['assertion failed', null]);
                 }
             }, ($) => {
-                on_exception(['assertion error', $]);
+                on_error(['assertion error', $]);
             });
         }
     });

package/dist/procedure/assert_sync.js

@@ -4,13 +4,13 @@ exports.assert_sync = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const assert_sync = (assertion, procedure) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             if (!assertion) {
-                on_exception(['assertion failed', null]);
+                on_error(['assertion failed', null]);
                 return;
             }
             procedure.__start(on_success, ($) => {
-                on_exception(['procedure error', $]);
+                on_error(['procedure error', $]);
             });
         }
     });

package/dist/procedure/conditional_async.js

@@ -4,18 +4,18 @@ exports.conditional_async = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const conditional_async = (precondition, procedure) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             precondition.__start(($) => {
                 if ($) {
                     procedure.__start(on_success, (e) => {
-                        on_exception(['procedure', e]);
+                        on_error(['procedure', e]);
                     });
                 }
                 else {
                     on_success();
                 }
             }, ($) => {
-                on_exception(['precondition', $]);
+                on_error(['precondition', $]);
             });
         }
     });

package/dist/procedure/conditional_multiple.js

@@ -5,7 +5,7 @@ const query_dictionary_1 = require("../query/query_dictionary");
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const conditional_multiple = (preconditions, procedure) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             (0, query_dictionary_1.query_dictionary)(preconditions).__start(($) => {
                 let has_errors = false;
                 $.map(($) => {
@@ -16,7 +16,7 @@ const conditional_multiple = (preconditions, procedure) => {
                 if (!has_errors) {
                     // all preconditions passed
                     procedure.__start(on_success, (e) => {
-                        on_exception(['procedure', e]);
+                        on_error(['procedure', e]);
                     });
                 }
                 else {
@@ -24,7 +24,7 @@ const conditional_multiple = (preconditions, procedure) => {
                     on_success();
                 }
             }, ($) => {
-                on_exception(['preconditions', $]);
+                on_error(['preconditions', $]);
             });
         }
     });

package/dist/procedure/conditional_sync.js

@@ -4,9 +4,9 @@ exports.conditional_sync = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const conditional_sync = (precondition, procedure) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             if (precondition) {
-                procedure.__start(on_success, on_exception);
+                procedure.__start(on_success, on_error);
             }
             else {
                 on_success();

package/dist/procedure/dictionary_sequence.js

@@ -35,7 +35,7 @@ const op_dictionary_to_list_based_on_insertion_order = (dict) => {
 };
 const dictionary_sequence = (steps) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             const as_list = op_dictionary_to_list_based_on_insertion_order(steps);
             let current = 0;
             const do_next = () => {
@@ -45,7 +45,7 @@ const dictionary_sequence = (steps) => {
                     $.value.__start(() => {
                         do_next();
                     }, ($) => {
-                        on_exception({
+                        on_error({
                             'error': $,
                             'step': key,
                         });

package/dist/procedure/execute_with_async_data.js

@@ -4,10 +4,10 @@ exports.execute_with_async_data = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const execute_with_async_data = (procedure, query) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             query.__start((query_result) => {
-                procedure["execute with synchronous data"](query_result).__start(on_success, on_exception);
-            }, on_exception);
+                procedure["execute with synchronous data"](query_result).__start(on_success, on_error);
+            }, on_error);
         }
     });
 };

package/dist/procedure/procedure_dictionary.js

@@ -28,7 +28,7 @@ const _ei = __importStar(require("exupery-core-internals"));
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const procedure_dictionary = ($) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             let count_down = $.__get_number_of_entries();
             let has_errors = false;
             const errors = {};
@@ -36,7 +36,7 @@ const procedure_dictionary = ($) => {
                 count_down -= 1;
                 if (count_down === 0) {
                     if (has_errors) {
-                        on_exception(_ei.dictionary_literal(errors));
+                        on_error(_ei.dictionary_literal(errors));
                     }
                     else {
                         on_success();

package/dist/procedure/sequence.js

@@ -4,14 +4,14 @@ exports.sequence = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const sequence = (steps) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             let current = 0;
             const do_next = () => {
                 steps.__get_element_at(current).transform(($) => {
                     current += 1;
                     $.__start(() => {
                         do_next();
-                    }, on_exception);
+                    }, on_error);
                 }, () => {
                     on_success();
                 });

package/dist/procedure/three_steps.js

@@ -4,17 +4,17 @@ exports.three_steps = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const three_steps = (step_1, step_2, step_3) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             step_1.__start(() => {
                 step_2.__start(() => {
                     step_3.__start(on_success, (error) => {
-                        on_exception(['step3', error]);
+                        on_error(['step3', error]);
                     });
                 }, (error) => {
-                    on_exception(['step2', error]);
+                    on_error(['step2', error]);
                 });
             }, (error) => {
-                on_exception(['step1', error]);
+                on_error(['step1', error]);
             });
         }
     });

package/dist/procedure/two_steps.js

@@ -4,13 +4,13 @@ exports.two_steps = void 0;
 const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
 const two_steps = (step_1, step_2) => {
     return (0, create_procedure_promise_1.__create_procedure_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             step_1.__start(() => {
                 step_2.__start(on_success, (error) => {
-                    on_exception(['step2', error]);
+                    on_error(['step2', error]);
                 });
             }, (error) => {
-                on_exception(['step1', error]);
+                on_error(['step1', error]);
             });
         }
     });

package/dist/query/query_dictionary.js

@@ -28,7 +28,7 @@ const _ei = __importStar(require("exupery-core-internals"));
 const create_query_promise_1 = require("../algorithms/query/create_query_promise");
 const query_dictionary = ($) => {
     return (0, create_query_promise_1.__create_query_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             let count_down = $.__get_number_of_entries();
             let has_errors = false;
             const errors = {};
@@ -37,7 +37,7 @@ const query_dictionary = ($) => {
                 count_down -= 1;
                 if (count_down === 0) {
                     if (has_errors) {
-                        on_exception(_ei.dictionary_literal(errors));
+                        on_error(_ei.dictionary_literal(errors));
                     }
                     else {
                         on_success(_ei.dictionary_literal(results));

package/dist/query/transform_query.js

@@ -4,11 +4,11 @@ exports.transform_query = void 0;
 const create_query_promise_1 = require("../algorithms/query/create_query_promise");
 const transform_query = (query, transform) => {
     return (0, create_query_promise_1.__create_query_promise)({
-        'execute': (on_success, on_exception) => {
+        'execute': (on_success, on_error) => {
             query.__start(($) => {
                 on_success(transform($));
             }, (e) => {
-                on_exception(e);
+                on_error(e);
             });
         }
     });

package/package.json

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

package/dist/process_result.d.ts

@@ -1,3 +0,0 @@
-import * as _et from 'exupery-core-types';
-export declare const create_process_result: <Data, Error>($: Data) => _et.Process_Result<Data, Error>;
-export declare const create_failed_process_result: <Data, Error>($: Error) => _et.Process_Result<Data, Error>;

package/dist/process_result.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_failed_process_result = exports.create_process_result = void 0;
-const create_process_result = ($) => {
-    return {
-        'transform': (transformer) => {
-            return (0, exports.create_process_result)(transformer($));
-        },
-        'transform with parameters': (transformer, parameters) => {
-            return (0, exports.create_process_result)(transformer($, parameters));
-        },
-        'refine': (refiner, map_error) => {
-            return refiner($).transform(($) => (0, exports.create_process_result)($), ($) => (0, exports.create_failed_process_result)(map_error($)));
-        },
-        'refine with parameters': (refiner, parameters, map_error) => {
-            return refiner($, parameters).transform(($) => (0, exports.create_process_result)($), ($) => (0, exports.create_failed_process_result)(map_error($)));
-        },
-        '__extract_data': (success, exception) => {
-            success($);
-        }
-    };
-};
-exports.create_process_result = create_process_result;
-const create_failed_process_result = ($) => {
-    return {
-        'transform': () => {
-            return (0, exports.create_failed_process_result)($);
-        },
-        'transform with parameters': () => {
-            return (0, exports.create_failed_process_result)($);
-        },
-        'refine': () => {
-            return (0, exports.create_failed_process_result)($);
-        },
-        'refine with parameters': () => {
-            return (0, exports.create_failed_process_result)($);
-        },
-        '__extract_data': (success, exception) => {
-            exception($);
-        }
-    };
-};
-exports.create_failed_process_result = create_failed_process_result;