exupery-core-async 0.3.3 → 0.3.5

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

@@ -8,5 +8,4 @@ type Executer = {
  * @returns
  */
 export declare function __create_guaranted_procedure(executer: Executer): Guaranteed_Procedure_Promise;
-export declare const initialize_no_op_guaranteed_procedure: () => Guaranteed_Procedure_Promise;
 export {};

package/dist/algorithms/procedure/initialize_guaranteed_procedure.js

@@ -1,23 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_no_op_guaranteed_procedure = void 0;
 exports.__create_guaranted_procedure = __create_guaranted_procedure;
-class Guaranteed_Procedure_Class {
+class Guaranteed_Procedure_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    x_execute(get_action, get_parameters, get_resources) {
-        return __create_guaranted_procedure({
-            'execute': (on_finished) => {
-                this.executer.execute(() => {
-                    const action = get_action();
-                    const params = get_parameters();
-                    const resources = get_resources();
-                    action(params, resources).__start(on_finished);
-                });
-            }
-        });
-    }
     __start(on_finished) {
         this.executer.execute(on_finished);
     }
@@ -28,13 +15,5 @@ class Guaranteed_Procedure_Class {
  * @returns
  */
 function __create_guaranted_procedure(executer) {
-    return new Guaranteed_Procedure_Class(executer);
+    return new Guaranteed_Procedure_Promise_Class(executer);
 }
-const initialize_no_op_guaranteed_procedure = () => {
-    return new Guaranteed_Procedure_Class({
-        'execute': (on_finished) => {
-            on_finished(); //nothing to do, call on_finished immediately
-        }
-    });
-};
-exports.initialize_no_op_guaranteed_procedure = initialize_no_op_guaranteed_procedure;

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

@@ -14,5 +14,4 @@ type Executer<E> = {
  * @returns
  */
 export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): Unguaranteed_Procedure_Promise<E>;
-export declare const initialize_no_op_unguaranteed_procedure: <E>() => Unguaranteed_Procedure_Promise<E>;
 export {};

package/dist/algorithms/procedure/initialize_unguaranteed_procedure.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_no_op_unguaranteed_procedure = void 0;
 exports.__create_unguaranteed_procedure = __create_unguaranteed_procedure;
-class Unguaranteed_Procedure_Class {
+class Unguaranteed_Procedure_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
     __start(on_success, on_exception) {
         this.executer.execute(on_success, on_exception);
     }
+    map_error(handle_error) {
+        return new Unguaranteed_Procedure_Promise_Class({
+            'execute': (on_success, on_exception) => {
+                this.executer.execute(on_success, (error) => {
+                    on_exception(handle_error(error));
+                });
+            }
+        });
+    }
 }
 /**
  * returns an {@link Async_Value }
@@ -16,13 +24,5 @@ class Unguaranteed_Procedure_Class {
  * @returns
  */
 function __create_unguaranteed_procedure(executer) {
-    return new Unguaranteed_Procedure_Class(executer);
+    return new Unguaranteed_Procedure_Promise_Class(executer);
 }
-const initialize_no_op_unguaranteed_procedure = () => {
-    return new Unguaranteed_Procedure_Class({
-        'execute': (on_success, on_exception) => {
-            on_success(); //nothing to do, call on_finished immediately
-        }
-    });
-};
-exports.initialize_no_op_unguaranteed_procedure = initialize_no_op_unguaranteed_procedure;

package/dist/algorithms/query/create_guaranteed_query.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__create_guaranteed_query = __create_guaranteed_query;
-class Guaranteed_Query_Result_Class {
+class Guaranteed_Query_Result_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
@@ -33,5 +33,5 @@ class Guaranteed_Query_Result_Class {
  * @returns
  */
 function __create_guaranteed_query(executer) {
-    return new Guaranteed_Query_Result_Class(executer);
+    return new Guaranteed_Query_Result_Promise_Class(executer);
 }

package/dist/algorithms/query/create_unguaranteed_query.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__create_unguaranteed_query = __create_unguaranteed_query;
 const create_guaranteed_query_1 = require("./create_guaranteed_query");
-class Unguaranteed_Query_Result_Class {
+class Unguaranteed_Query_Result_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
     map_(handle_value) {
-        return new Unguaranteed_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Promise_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(($) => {
                     on_value(handle_value($));
@@ -16,7 +16,7 @@ class Unguaranteed_Query_Result_Class {
         });
     }
     then(handle_value) {
-        return new Unguaranteed_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Promise_Class({
             'execute': (new_on_value, new_on_exception) => {
                 this.executer.execute(($) => {
                     handle_value($).__start(new_on_value);
@@ -25,7 +25,7 @@ class Unguaranteed_Query_Result_Class {
         });
     }
     then_unguaranteed(handle_value) {
-        return new Unguaranteed_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Promise_Class({
             'execute': (new_on_value, new_on_exception) => {
                 this.executer.execute(($) => {
                     handle_value($).__start(new_on_value, new_on_exception);
@@ -34,7 +34,7 @@ class Unguaranteed_Query_Result_Class {
         });
     }
     map_exception_(handle_exception) {
-        return new Unguaranteed_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Promise_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(on_value, ($) => {
                     on_exception(handle_exception($));
@@ -61,5 +61,5 @@ class Unguaranteed_Query_Result_Class {
  * @returns
  */
 function __create_unguaranteed_query(executer) {
-    return new Unguaranteed_Query_Result_Class(executer);
+    return new Unguaranteed_Query_Result_Promise_Class(executer);
 }

package/dist/index.d.ts

@@ -8,8 +8,6 @@ export * from "./algorithms/query/create_unguaranteed_query";
 export * from "./algorithms/procedure/initialize_guaranteed_procedure";
 export * from "./algorithms/procedure/initialize_unguaranteed_procedure";
 export * from "./shorthands";
-import { Guaranteed_Procedure_Promise } from "./types/Guaranteed_Procedure";
-import { Unguaranteed_Procedure_Promise } from "./types/Unguaranteed_Procedure";
 import { Guaranteed_Query_Promise } from "./types/Guaranteed_Query";
 import { Unguaranteed_Query_Promise } from "./types/Unguaranteed_Query";
 export declare const query: {
@@ -21,12 +19,3 @@ export declare const query: {
         'raise exception': <T, E>($: E) => Unguaranteed_Query_Promise<T, E>;
     };
 };
-export declare const command: {
-    guaranteed: {
-        initialize: () => Guaranteed_Procedure_Promise;
-    };
-    unguaranteed: {
-        initialize: <E>() => Unguaranteed_Procedure_Promise<E>;
-        'raise exception': <E>($: E) => Unguaranteed_Procedure_Promise<E>;
-    };
-};

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = exports.query = void 0;
+exports.query = void 0;
 //types
 __exportStar(require("./types/Guaranteed_Procedure"), exports);
 __exportStar(require("./types/Unguaranteed_Procedure"), exports);
@@ -27,8 +27,6 @@ __exportStar(require("./algorithms/query/create_unguaranteed_query"), exports);
 __exportStar(require("./algorithms/procedure/initialize_guaranteed_procedure"), exports);
 __exportStar(require("./algorithms/procedure/initialize_unguaranteed_procedure"), exports);
 __exportStar(require("./shorthands"), exports);
-const initialize_guaranteed_procedure_1 = require("./algorithms/procedure/initialize_guaranteed_procedure");
-const initialize_unguaranteed_procedure_1 = require("./algorithms/procedure/initialize_unguaranteed_procedure");
 const create_guaranteed_query_1 = require("./algorithms/query/create_guaranteed_query");
 const create_unguaranteed_query_1 = require("./algorithms/query/create_unguaranteed_query");
 exports.query = {
@@ -58,162 +56,3 @@ exports.query = {
         }
     },
 };
-exports.command = {
-    'guaranteed': {
-        'initialize': initialize_guaranteed_procedure_1.initialize_no_op_guaranteed_procedure
-    },
-    'unguaranteed': {
-        'initialize': initialize_unguaranteed_procedure_1.initialize_no_op_unguaranteed_procedure,
-        'raise exception': ($) => {
-            return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
-                'execute': (on_success, on_exception) => {
-                    on_exception($);
-                }
-            });
-        },
-    },
-};
-// //array
-//     map_async<NT>(
-//         handle_value: ($: T) => Safe_Query_Result<NT>
-//     ): Safe_Query_Result<Array<NT>>
-//     map_async_unsafe<NT, NE>(
-//         handle_value: ($: T) => Unsafe_Query_Result<NT, NE>
-//     ): Unsafe_Query_Result<Array<NT>, Array<NE>>
-// //dictionary
-//     /**
-//      * 
-//      * @param handle_value callback that provides an {@link Safe_Query_Result}. keys are not available.
-//      */
-//     query_safe_with_entries<NT>(
-//         handle_value: ($: T) => Safe_Query_Result<NT>
-//     ): Safe_Query_Result<Dictionary<NT>>
-//     query_unsafe_with_entries<NT, NE>(
-//         handle_value: ($: T) => Unsafe_Query_Result<NT, NE>,
-//     ): Unsafe_Query_Result<Dictionary<NT>, Dictionary<NE>>
-//     map_async<NT>(on_entry_value: ($: T) => _et.Async_Value<NT>): _et.Async_Value<_et.Dictionary<NT>> {
-//         const source = this.source
-//         const temp: { [key: string]: NT } = {}
-//         return create_Async_Value(
-//             {
-//                 'execute': (on_dictionary_value) => {
-//                     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_dictionary_value(dictionary_literal(temp))
-//                         }
-//                     )
-//                 }
-//             }
-//         )
-//     }
-//     map_async_unsafe<NT, NE>(on_entry_value: ($: T) => _et.Unsafe_Async_Value<NT, NE>): _et.Unsafe_Async_Value<_et.Dictionary<NT>, _et.Dictionary<NE>> {
-//         const source = this.source
-//         const temp_values: { [key: string]: NT } = {}
-//         const temp_exceptions: { [key: string]: NE } = {}
-//         return create_Unsafe_Async_Value(
-//             {
-//                 'execute': (
-//                     on_dictionary_value,
-//                     on_dictionary_exception,
-//                 ) => {
-//                     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_async<NT>(on_element_value: ($: T) => _et.Async_Value<NT>): _et.Async_Value<_et.Array<NT>> {
-//         const data = this.data
-//         return create_Async_Value(
-//             {
-//                 'execute': (on_array_value) => {
-//                     const temp: NT[] = []
-//                     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_array_value(array_literal(temp))
-//                         }
-//                     )
-//                 }
-//             },
-//         )
-//     }
-//     map_async_unsafe<NT, NE>(
-//         on_element_value: ($: T) => _et.Unsafe_Async_Value<NT, NE>
-//     ): _et.Unsafe_Async_Value<_et.Array<NT>, _et.Array<NE>> {
-//         const data = this.data
-//         return create_Unsafe_Async_Value(
-//             {
-//                 'execute': (
-//                     on_array_value,
-//                     on_array_exception,
-//                 ) => {
-//                     const temp_values: NT[] = []
-//                     const temp_exceptions: NE[] = []
-//                     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))
-//                             }
-//                         }
-//                     )
-//                 }
-//             },
-//         )
-//     }

package/dist/shorthands.js

@@ -110,8 +110,8 @@ var up;
      * @param query u.q
      */
     up.action = (action, query, resources) => {
-        return {
-            __start: (on_success, on_error) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_success, on_error) => {
                 //run the query
                 query.__start((query_result) => {
                     //run the action
@@ -121,7 +121,7 @@ var up;
                     });
                 }, on_error);
             }
-        };
+        });
     };
     /**
      *
@@ -129,8 +129,8 @@ var up;
      * @returns
      */
     up.sequence = (steps) => {
-        return {
-            __start: (on_success, on_error) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_success, on_error) => {
                 const length = _ei.array_literal(steps).__get_number_of_elements();
                 const runStep = (index) => {
                     if (index >= length) {
@@ -141,7 +141,7 @@ var up;
                 };
                 runStep(0);
             }
-        };
+        });
     };
     /**
      *
@@ -150,8 +150,8 @@ var up;
      * @returns
      */
     up.array = (the_array, aggregate_exceptions) => {
-        return {
-            __start: (on_success, on_error) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_success, on_error) => {
                 const exceptions = [];
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     the_array.map(($) => {
@@ -172,7 +172,7 @@ var up;
                     }
                 });
             }
-        };
+        });
     };
     /**
      *
@@ -181,8 +181,8 @@ var up;
      * @returns
      */
     up.dictionary = (the_dictionary, aggregate_exceptions) => {
-        return {
-            __start: (on_success, on_error) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_success, on_error) => {
                 const exceptions = {};
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     the_dictionary.map(($, key) => {
@@ -203,7 +203,7 @@ var up;
                     }
                 });
             }
-        };
+        });
     };
 })(up || (exports.up = up = {}));
 var upi;

package/dist/types/Guaranteed_Procedure.d.ts

@@ -1,4 +1,4 @@
 export type Guaranteed_Procedure<Parameters, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Procedure_Promise;
-export interface Guaranteed_Procedure_Promise {
+export type Guaranteed_Procedure_Promise = {
     __start: (on_finished: () => void) => void;
-}
+};

package/dist/types/Unguaranteed_Procedure.d.ts

@@ -1,4 +1,5 @@
 export type Unguaranteed_Procedure<Parameters, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Procedure_Promise<Error>;
-export interface Unguaranteed_Procedure_Promise<Error> {
+export type Unguaranteed_Procedure_Promise<Error> = {
     __start: (on_success: () => void, on_error: (error: Error) => void) => void;
-}
+    map_error<NE>(handle_error: (error: Error) => NE): Unguaranteed_Procedure_Promise<NE>;
+};

package/package.json

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