exupery-core-async 0.3.33 → 0.3.35

package/dist/algorithms/{procedure/create_procedure_primed_with_resources.d.ts → command/create_command.d.ts}

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
-export type Basic_Procedure_Primed_With_Resources<Parameters, Error> = ($: Parameters) => _et.Procedure_Promise<Error>;
-export declare const __create_procedure_primed_with_resources: <Parameters, Error, Resources>(handler: Basic_Procedure_Primed_With_Resources<Parameters, Error>) => _et.Procedure_Primed_With_Resources<Parameters, Error>;
+export type Basic_Procedure_Primed_With_Resources<Parameters, Error> = ($: Parameters) => _et.Command_Promise<Error>;
+export declare const __create_procedure_primed_with_resources: <Parameters, Error, Resources>(handler: Basic_Procedure_Primed_With_Resources<Parameters, Error>) => _et.Command<Parameters, Error>;

package/dist/algorithms/{procedure/create_procedure_primed_with_resources.js → command/create_command.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__create_procedure_primed_with_resources = void 0;
-const create_procedure_promise_1 = require("./create_procedure_promise");
+const create_command_promise_1 = require("./create_command_promise");
 const __create_procedure_primed_with_resources = (handler) => {
     return {
         'execute with synchronous data without error transformation': handler,
         'execute with synchronous data': (parameters, transform_error) => {
-            return (0, create_procedure_promise_1.__create_procedure_promise)({
+            return (0, create_command_promise_1.__create_command_promise)({
                 'execute': (on_success, on_error) => {
                     handler(parameters).__start(on_success, (error) => {
                         on_error(transform_error(error));
@@ -15,7 +15,7 @@ const __create_procedure_primed_with_resources = (handler) => {
             });
         },
         'execute with asynchronous data without error transformation': (query) => {
-            return (0, create_procedure_promise_1.__create_procedure_promise)({
+            return (0, create_command_promise_1.__create_command_promise)({
                 'execute': (on_success, on_error) => {
                     query.__start(($) => {
                         handler($).__start(on_success, on_error);
@@ -24,7 +24,7 @@ const __create_procedure_primed_with_resources = (handler) => {
             });
         },
         'execute with asynchronous data': (query, transform_error) => {
-            return (0, create_procedure_promise_1.__create_procedure_promise)({
+            return (0, create_command_promise_1.__create_command_promise)({
                 'execute': (on_success, on_error) => {
                     query.__start(($) => {
                         handler($).__start(on_success, (error) => {

package/dist/algorithms/command/create_command_procedure.d.ts

@@ -0,0 +1,2 @@
+import * as _et from 'exupery-core-types';
+export declare const create_command_procedure: <Parameters, Error, Resources>(handler: ($r: Resources, $p: Parameters) => _et.Command_Promise<Error>) => _et.Command_Procedure<Parameters, Error, Resources>;

package/dist/algorithms/command/create_command_procedure.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_command_procedure = void 0;
+const create_command_1 = require("./create_command");
+const create_command_procedure = (handler) => {
+    return ($r) => (0, create_command_1.__create_procedure_primed_with_resources)(($p) => handler($r, $p));
+};
+exports.create_command_procedure = create_command_procedure;

package/dist/algorithms/{procedure/create_procedure_promise.d.ts → command/create_command_promise.d.ts}

@@ -13,5 +13,5 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_procedure_promise<E>(executer: Executer<E>): _et.Procedure_Promise<E>;
+export declare function __create_command_promise<E>(executer: Executer<E>): _et.Command_Promise<E>;
 export {};

package/dist/algorithms/{procedure/create_procedure_promise.js → command/create_command_promise.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__create_procedure_promise = __create_procedure_promise;
-class Procedure_Promise_Class {
+exports.__create_command_promise = __create_command_promise;
+class Command_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
@@ -9,7 +9,7 @@ class Procedure_Promise_Class {
         this.executer.execute(on_success, on_error);
     }
     map_error(handle_error) {
-        return new Procedure_Promise_Class({
+        return new Command_Promise_Class({
             'execute': (on_success, on_error) => {
                 this.executer.execute(on_success, (error) => {
                     on_error(handle_error(error));
@@ -23,6 +23,6 @@ class Procedure_Promise_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __create_procedure_promise(executer) {
-    return new Procedure_Promise_Class(executer);
+function __create_command_promise(executer) {
+    return new Command_Promise_Class(executer);
 }

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

@@ -0,0 +1,2 @@
+import * as _et from 'exupery-core-types';
+export declare const create_query_procedure: <Parameters, Result, Error, Resources>(handler: ($r: Resources, $p: Parameters) => _et.Query_Promise<Result, Error>) => _et.Query_Procedure<Parameters, Result, Error, Resources>;

package/dist/algorithms/query/{create_query.js → create_query_procedure.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_query = void 0;
+exports.create_query_procedure = void 0;
 const create_query_primed_with_resources_1 = require("./create_query_primed_with_resources");
-const create_query = (handler) => {
+const create_query_procedure = (handler) => {
     return ($r) => (0, create_query_primed_with_resources_1.__create_query_primed_with_resources)(($p) => handler($r, $p));
 };
-exports.create_query = create_query;
+exports.create_query_procedure = create_query_procedure;

package/dist/index.d.ts

@@ -1,13 +1,8 @@
-import * as _et from "exupery-core-types";
 export * from "./algorithms/query/create_query_promise";
 export * from "./algorithms/query/create_query_primed_with_resources";
-export * from "./algorithms/query/create_query";
-export * from "./algorithms/procedure/create_procedure";
-export * from "./algorithms/procedure/create_procedure_promise";
-export * from "./algorithms/procedure/create_procedure_primed_with_resources";
-export * from "./expressions/procedure";
-export * from "./expressions/query";
-export declare const query: {
-    'create result': <T, E>($: T) => _et.Query_Promise<T, E>;
-    'raise error': <T, E>($: E) => _et.Query_Promise<T, E>;
-};
+export * from "./algorithms/query/create_query_procedure";
+export * from "./algorithms/command/create_command_procedure";
+export * from "./algorithms/command/create_command_promise";
+export * from "./algorithms/command/create_command";
+export * from "./procedures/command";
+export * from "./procedures/query";

package/dist/index.js

@@ -14,33 +14,11 @@ 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.query = void 0;
-//types
-//functions
 __exportStar(require("./algorithms/query/create_query_promise"), exports);
 __exportStar(require("./algorithms/query/create_query_primed_with_resources"), exports);
-__exportStar(require("./algorithms/query/create_query"), 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);
-// procedure exports
-__exportStar(require("./expressions/procedure"), exports);
-// query exports
-__exportStar(require("./expressions/query"), exports);
-const create_query_promise_1 = require("./algorithms/query/create_query_promise");
-exports.query = {
-    'create result': ($) => {
-        return (0, create_query_promise_1.__create_query_promise)({
-            'execute': (on_value) => {
-                on_value($);
-            }
-        });
-    },
-    'raise error': ($) => {
-        return (0, create_query_promise_1.__create_query_promise)({
-            'execute': (on_value, on_error) => {
-                on_error($);
-            }
-        });
-    }
-};
+__exportStar(require("./algorithms/query/create_query_procedure"), exports);
+__exportStar(require("./algorithms/command/create_command_procedure"), exports);
+__exportStar(require("./algorithms/command/create_command_promise"), exports);
+__exportStar(require("./algorithms/command/create_command"), exports);
+__exportStar(require("./procedures/command"), exports);
+__exportStar(require("./procedures/query"), exports);

package/dist/procedures/command.d.ts

@@ -0,0 +1,17 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Procedure_Primed_With_Resources } from '../algorithms/command/create_command';
+export declare namespace p {
+    const array_parallel: <Error, Element_Error>(the_array: _et.Array<_et.Command_Promise<Element_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Array<Element_Error>, Error>) => _et.Command_Promise<Error>;
+    const array_serie: <Error>(array: _et.Array<_et.Command_Promise<Error>>) => _et.Command_Promise<Error>;
+    const assert_async: <Error>(assertion: _et.Query_Promise<boolean, Error>, error_if_failed: Error) => _et.Command_Promise<Error>;
+    const assert_sync: <Error>(assertion: boolean, error_if_failed: Error) => _et.Command_Promise<Error>;
+    const conditional_async: <Error>(precondition: _et.Query_Promise<boolean, Error>, procedure: _et.Command_Promise<Error>) => _et.Command_Promise<Error>;
+    const conditional_sync: <Error>(precondition: boolean, procedure: _et.Command_Promise<Error>) => _et.Command_Promise<Error>;
+    const conditional_on_processor: <Procedure_Input, Error>(precondition: _et.Process_Result<Procedure_Input, Error>, procedure: Basic_Procedure_Primed_With_Resources<Procedure_Input, Error>) => _et.Command_Promise<Error>;
+    const conditional_on_refiner: <Procedure_Input, Refinement_Error, Error>(precondition: _et.Refinement_Result<Procedure_Input, Refinement_Error>, error_transformer: _et.Transformer_Without_Parameters<Refinement_Error, Error>, procedure: Basic_Procedure_Primed_With_Resources<Procedure_Input, Error>) => _et.Command_Promise<Error>;
+    const dictionary_serie: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Command_Promise<Entry_Error>>, transform_error: _et.Transformer_Without_Parameters<_et.Key_Value_Pair<Entry_Error>, Error>) => _et.Command_Promise<Error>;
+    const dictionary_parallel: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Command_Promise<Entry_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Dictionary<Entry_Error>, Error>) => _et.Command_Promise<Error>;
+    const dictionary_parallel_without_transforming_the_error: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Command_Promise<Entry_Error>>) => _et.Command_Promise<_et.Dictionary<Entry_Error>>;
+    const execute_with_async_data: <Parameters, Error>(procedure: _et.Command<Parameters, Error>, query: _et.Query_Promise<Parameters, Error>) => _et.Command_Promise<Error>;
+    const sequence: <Error>(steps: _et.Command_Promise<Error>[]) => _et.Command_Promise<Error>;
+}

package/dist/{expressions/procedure.js → procedures/command.js}

@@ -25,12 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.p = void 0;
 const _ei = __importStar(require("exupery-core-internals"));
-const create_procedure_promise_1 = require("../algorithms/procedure/create_procedure_promise");
+const create_command_promise_1 = require("../algorithms/command/create_command_promise");
 const create_asynchronous_processes_monitor_1 = require("../create_asynchronous_processes_monitor");
 var p;
 (function (p) {
     p.array_parallel = (the_array, aggregate_errors) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 const errors = [];
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
@@ -55,7 +55,7 @@ var p;
         });
     };
     p.array_serie = (array) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 let current = 0;
                 const do_next = () => {
@@ -73,7 +73,7 @@ var p;
         });
     };
     p.assert_async = (assertion, error_if_failed) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 assertion.__start(($) => {
                     if ($) {
@@ -89,7 +89,7 @@ var p;
         });
     };
     p.assert_sync = (assertion, error_if_failed) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 if (!assertion) {
                     on_error(error_if_failed);
@@ -100,7 +100,7 @@ var p;
         });
     };
     p.conditional_async = (precondition, procedure) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 precondition.__start(($) => {
                     if ($) {
@@ -114,7 +114,7 @@ var p;
         });
     };
     p.conditional_sync = (precondition, procedure) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 if (precondition) {
                     procedure.__start(on_success, on_error);
@@ -126,7 +126,7 @@ var p;
         });
     };
     p.conditional_on_processor = (precondition, procedure) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 precondition.__extract_data(($) => {
                     procedure($).__start(on_success, on_error);
@@ -134,17 +134,19 @@ var p;
             }
         });
     };
-    p.conditional_on_refiner = (precondition, procedure) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+    p.conditional_on_refiner = (precondition, error_transformer, procedure) => {
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 precondition.process(($) => {
                     procedure($).__start(on_success, on_error);
-                }, on_error);
+                }, (e) => {
+                    on_error(error_transformer(e));
+                });
             }
         });
     };
     p.dictionary_serie = (dictionary, transform_error) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 const op_dictionary_to_list_based_on_insertion_order = (dict) => {
                     const temp = [];
@@ -176,7 +178,7 @@ var p;
         });
     };
     p.dictionary_parallel = (dictionary, aggregate_errors) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 const errors = {};
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
@@ -201,7 +203,7 @@ var p;
         });
     };
     p.dictionary_parallel_without_transforming_the_error = (dictionary) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 const errors = {};
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
@@ -226,7 +228,7 @@ var p;
         });
     };
     p.execute_with_async_data = (procedure, query) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 query.__start((query_result) => {
                     procedure['execute with synchronous data without error transformation'](query_result).__start(on_success, on_error);
@@ -235,7 +237,7 @@ var p;
         });
     };
     p.sequence = (steps) => {
-        return (0, create_procedure_promise_1.__create_procedure_promise)({
+        return (0, create_command_promise_1.__create_command_promise)({
             'execute': (on_success, on_error) => {
                 const length = _ei.array_literal(steps).__get_number_of_elements();
                 const runStep = (index) => {

package/dist/{expressions → procedures}/query.d.ts

@@ -2,6 +2,7 @@ import * as _et from 'exupery-core-types';
 export declare namespace q {
     const dictionary_parallel: <Result, Error, Entry_Error>(dictionary: _et.Dictionary<_et.Query_Promise<Result, Entry_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Dictionary<Entry_Error>, Error>) => _et.Query_Promise<_et.Dictionary<Result>, Error>;
     const dictionary_parallel_without_error_aggregation: <Result, Error>($: _et.Dictionary<_et.Query_Promise<Result, Error>>) => _et.Query_Promise<_et.Dictionary<Result>, _et.Dictionary<Error>>;
-    const fixed: <Query_Result, Error>(query_result: Query_Result) => _et.Query_Promise<Query_Result, Error>;
+    const fixed: <Result, Error>(result: Result) => _et.Query_Promise<Result, Error>;
+    const raise_error: <T, E>($: E) => _et.Query_Promise<T, E>;
     const transform: <In, Out, Error>(query: _et.Query_Promise<In, Error>, transform: ($: In) => Out) => _et.Query_Promise<Out, Error>;
 }

package/dist/{expressions → procedures}/query.js

@@ -90,10 +90,17 @@ var q;
             }
         });
     };
-    q.fixed = (query_result) => {
+    q.fixed = (result) => {
         return (0, create_query_promise_1.__create_query_promise)({
             'execute': (on_success, on_error) => {
-                on_success(query_result);
+                on_success(result);
+            }
+        });
+    };
+    q.raise_error = ($) => {
+        return (0, create_query_promise_1.__create_query_promise)({
+            'execute': (on_value, on_error) => {
+                on_error($);
             }
         });
     };

package/package.json

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

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

@@ -1,2 +0,0 @@
-import * as _et from 'exupery-core-types';
-export declare const create_procedure: <Parameters, Error, Resources>(handler: ($r: Resources, $p: Parameters) => _et.Procedure_Promise<Error>) => _et.Procedure<Parameters, Error, Resources>;

package/dist/algorithms/procedure/create_procedure.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_procedure = void 0;
-const create_procedure_primed_with_resources_1 = require("./create_procedure_primed_with_resources");
-const create_procedure = (handler) => {
-    return ($r) => (0, create_procedure_primed_with_resources_1.__create_procedure_primed_with_resources)(($p) => handler($r, $p));
-};
-exports.create_procedure = create_procedure;

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

@@ -1,2 +0,0 @@
-import * as _et from 'exupery-core-types';
-export declare const create_query: <Parameters, Result, Error, Resources>(handler: ($r: Resources, $p: Parameters) => _et.Query_Promise<Result, Error>) => _et.Query<Parameters, Result, Error, Resources>;

package/dist/expressions/procedure.d.ts

@@ -1,17 +0,0 @@
-import * as _et from 'exupery-core-types';
-import { Basic_Procedure_Primed_With_Resources } from '../algorithms/procedure/create_procedure_primed_with_resources';
-export declare namespace p {
-    const array_parallel: <Error, Element_Error>(the_array: _et.Array<_et.Procedure_Promise<Element_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Array<Element_Error>, Error>) => _et.Procedure_Promise<Error>;
-    const array_serie: <Error>(array: _et.Array<_et.Procedure_Promise<Error>>) => _et.Procedure_Promise<Error>;
-    const assert_async: <Error>(assertion: _et.Query_Promise<boolean, Error>, error_if_failed: Error) => _et.Procedure_Promise<Error>;
-    const assert_sync: <Error>(assertion: boolean, error_if_failed: Error) => _et.Procedure_Promise<Error>;
-    const conditional_async: <Error>(precondition: _et.Query_Promise<boolean, Error>, procedure: _et.Procedure_Promise<Error>) => _et.Procedure_Promise<Error>;
-    const conditional_sync: <Error>(precondition: boolean, procedure: _et.Procedure_Promise<Error>) => _et.Procedure_Promise<Error>;
-    const conditional_on_processor: <Procedure_Input, Error>(precondition: _et.Process_Result<Procedure_Input, Error>, procedure: Basic_Procedure_Primed_With_Resources<Procedure_Input, Error>) => _et.Procedure_Promise<Error>;
-    const conditional_on_refiner: <Procedure_Input, Error>(precondition: _et.Refinement_Result<Procedure_Input, Error>, procedure: Basic_Procedure_Primed_With_Resources<Procedure_Input, Error>) => _et.Procedure_Promise<Error>;
-    const dictionary_serie: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Procedure_Promise<Entry_Error>>, transform_error: _et.Transformer_Without_Parameters<_et.Key_Value_Pair<Entry_Error>, Error>) => _et.Procedure_Promise<Error>;
-    const dictionary_parallel: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Procedure_Promise<Entry_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Dictionary<Entry_Error>, Error>) => _et.Procedure_Promise<Error>;
-    const dictionary_parallel_without_transforming_the_error: <Error, Entry_Error>(dictionary: _et.Dictionary<_et.Procedure_Promise<Entry_Error>>) => _et.Procedure_Promise<_et.Dictionary<Entry_Error>>;
-    const execute_with_async_data: <Parameters, Error>(procedure: _et.Procedure_Primed_With_Resources<Parameters, Error>, query: _et.Query_Promise<Parameters, Error>) => _et.Procedure_Promise<Error>;
-    const sequence: <Error>(steps: _et.Procedure_Promise<Error>[]) => _et.Procedure_Promise<Error>;
-}