exupery-core-async 0.3.23 → 0.3.25

package/dist/algorithms/query/create_query_primed_with_resources.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__create_query_primed_with_resources = void 0;
 const create_query_promise_1 = require("./create_query_promise");
 const __create_query_primed_with_resources = (handler) => {
-    return (parameters) => {
-        return (0, create_query_promise_1.__create_query_promise)({
-            'execute': (on_success, on_error) => {
-                handler(parameters).__start(on_success, on_error);
-            }
-        });
+    return {
+        'execute': (parameters) => {
+            return (0, create_query_promise_1.__create_query_promise)({
+                'execute': (on_success, on_error) => {
+                    handler(parameters).__start(on_success, on_error);
+                }
+            });
+        }
     };
 };
 exports.__create_query_primed_with_resources = __create_query_primed_with_resources;

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

package/dist/algorithms/query/create_query_promise.js

@@ -5,55 +5,95 @@ class Query_Result_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    then(handle_value) {
+    query_with_result(query) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_error) => {
+            'execute': (on_result, on_error) => {
                 this.executer.execute(($) => {
-                    handle_value($).__start(on_value, on_error);
+                    query.execute($).__start(on_result, on_error);
                 }, on_error);
             }
         });
     }
-    map_error(handle_error) {
+    query_with_error(query) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_error) => {
-                this.executer.execute(on_value, ($) => {
-                    on_error(handle_error($));
+            'execute': (on_result, on_error) => {
+                this.executer.execute(on_result, ($) => {
+                    query.execute($).__start(on_result, on_error);
+                });
+            }
+        });
+    }
+    query(queries) {
+        return new Query_Result_Promise_Class({
+            'execute': (on_result, on_error) => {
+                this.executer.execute(($) => {
+                    queries.result.execute($).__start(on_result, on_error);
+                }, ($) => {
+                    queries.error.execute($).__start(on_result, on_error);
                 });
             }
         });
     }
     process_result(processor) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_error) => {
+            'execute': (on_result, on_error) => {
                 this.executer.execute(($) => {
-                    processor($).__extract_data(on_value, on_error);
+                    processor($).__extract_data(on_result, on_error);
                 }, on_error);
             }
         });
     }
     process_error(processor) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_error) => {
-                this.executer.execute(on_value, ($) => {
-                    processor($).__extract_data(on_value, on_error);
+            'execute': (on_result, on_error) => {
+                this.executer.execute(on_result, ($) => {
+                    processor($).__extract_data(on_result, on_error);
                 });
             }
         });
     }
     process(processors) {
         return new Query_Result_Promise_Class({
-            'execute': (on_value, on_error) => {
+            'execute': (on_result, on_error) => {
+                this.executer.execute(($) => {
+                    processors.result($).__extract_data(on_result, on_error);
+                }, ($) => {
+                    processors.error($).__extract_data(on_result, on_error);
+                });
+            }
+        });
+    }
+    transform_result(transformer) {
+        return new Query_Result_Promise_Class({
+            'execute': (on_result, on_error) => {
+                this.executer.execute(($) => {
+                    on_result(transformer($));
+                }, on_error);
+            }
+        });
+    }
+    transform_error(transformer) {
+        return new Query_Result_Promise_Class({
+            'execute': (on_result, on_error) => {
+                this.executer.execute(on_result, ($) => {
+                    on_error(transformer($));
+                });
+            }
+        });
+    }
+    transform(transformers) {
+        return new Query_Result_Promise_Class({
+            'execute': (on_result, on_error) => {
                 this.executer.execute(($) => {
-                    processors.result($).__extract_data(on_value, on_error);
+                    on_result(transformers.result($));
                 }, ($) => {
-                    processors.error($).__extract_data(on_value, on_error);
+                    on_error(transformers.error($));
                 });
             }
         });
     }
-    __start(on_value, on_error) {
-        this.executer.execute(on_value, on_error);
+    __start(on_result, on_error) {
+        this.executer.execute(on_result, on_error);
     }
 }
 /**

package/dist/expressions/procedure.d.ts

@@ -0,0 +1,27 @@
+import * as _et from 'exupery-core-types';
+export type Assert_Async_Error<Assertion_Error, Procedure_Error> = ['assertion error', Assertion_Error] | ['assertion failed', null] | ['procedure error', Procedure_Error];
+export type Assert_Sync_Error<Procedure_Error> = ['assertion failed', null] | ['procedure error', Procedure_Error];
+export type Conditional_Async_Error<Precondition_Error, Procedure_Error> = ['precondition', Precondition_Error] | ['procedure', Procedure_Error];
+export type Conditional_Multiple_Error<Precondition_Error, Procedure_Error> = ['preconditions', _et.Dictionary<Precondition_Error>] | ['procedure', Procedure_Error];
+export type Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error> = ['step1', Step_1_Error] | ['step2', Step_2_Error] | ['step3', Step_3_Error];
+export type Two_Steps_Error<Step_1_Error, Step_2_Error> = ['step1', Step_1_Error] | ['step2', Step_2_Error];
+export type Sequence_Error<Err> = {
+    'error': Err;
+    'step': string;
+};
+export declare namespace p {
+    const array: <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 assert_async: <Assertion_Error, Procedure_Error>(assertion: _et.Query_Promise<boolean, Assertion_Error>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Assert_Async_Error<Assertion_Error, Procedure_Error>>;
+    const assert_sync: <Assertion_Error, Procedure_Error>(assertion: boolean, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Assert_Sync_Error<Procedure_Error>>;
+    const conditional_async: <Precondition_Error, Procedure_Error>(precondition: _et.Query_Promise<boolean, Precondition_Error>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Conditional_Async_Error<Precondition_Error, Procedure_Error>>;
+    const conditional_multiple: <Precondition_Error, Procedure_Error>(preconditions: _et.Dictionary<_et.Query_Promise<boolean, Precondition_Error>>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Conditional_Multiple_Error<Precondition_Error, Procedure_Error>>;
+    const conditional_sync: <Procedure_Error>(precondition: boolean, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Procedure_Error>;
+    const dictionary_sequence: <Err>(steps: _et.Dictionary<_et.Procedure_Promise<Err>>) => _et.Procedure_Promise<Sequence_Error<Err>>;
+    const dictionary: <Error>($: _et.Dictionary<_et.Procedure_Promise<Error>>) => _et.Procedure_Promise<_et.Dictionary<Error>>;
+    const dictionary_2: <Error, Element_Error>(the_dictionary: _et.Dictionary<_et.Procedure_Promise<Element_Error>>, aggregate_errors: _et.Transformer_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => _et.Procedure_Promise<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.Array<_et.Procedure_Promise<Error>>) => _et.Procedure_Promise<Error>;
+    const sequence_2: <Error>(steps: _et.Procedure_Promise<Error>[]) => _et.Procedure_Promise<Error>;
+    const three_steps: <Step_1_Error, Step_2_Error, Step_3_Error>(step_1: _et.Procedure_Promise<Step_1_Error>, step_2: _et.Procedure_Promise<Step_2_Error>, step_3: _et.Procedure_Promise<Step_3_Error>) => _et.Procedure_Promise<Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error>>;
+    const two_steps: <Step_1_Error, Step_2_Error>(step_1: _et.Procedure_Promise<Step_1_Error>, step_2: _et.Procedure_Promise<Step_2_Error>) => _et.Procedure_Promise<Two_Steps_Error<Step_1_Error, Step_2_Error>>;
+}

package/dist/expressions/procedure.js

@@ -0,0 +1,303 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 query_1 = require("./query");
+const create_asynchronous_processes_monitor_1 = require("../create_asynchronous_processes_monitor");
+var p;
+(function (p) {
+    p.array = (the_array, aggregate_errors) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                const errors = [];
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
+                    the_array.map(($) => {
+                        monitor['report process started']();
+                        $.__start(() => {
+                            monitor['report process finished']();
+                        }, (e) => {
+                            errors.push(e);
+                            monitor['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (errors.length === 0) {
+                        on_success();
+                    }
+                    else {
+                        on_error(aggregate_errors(_ei.array_literal(errors)));
+                    }
+                });
+            }
+        });
+    };
+    p.assert_async = (assertion, procedure) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                assertion.__start(($) => {
+                    if ($) {
+                        procedure.__start(on_success, ($) => {
+                            on_error(['procedure error', $]);
+                        });
+                    }
+                    else {
+                        on_error(['assertion failed', null]);
+                    }
+                }, ($) => {
+                    on_error(['assertion error', $]);
+                });
+            }
+        });
+    };
+    p.assert_sync = (assertion, procedure) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                if (!assertion) {
+                    on_error(['assertion failed', null]);
+                    return;
+                }
+                procedure.__start(on_success, ($) => {
+                    on_error(['procedure error', $]);
+                });
+            }
+        });
+    };
+    p.conditional_async = (precondition, procedure) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                precondition.__start(($) => {
+                    if ($) {
+                        procedure.__start(on_success, (e) => {
+                            on_error(['procedure', e]);
+                        });
+                    }
+                    else {
+                        on_success();
+                    }
+                }, ($) => {
+                    on_error(['precondition', $]);
+                });
+            }
+        });
+    };
+    p.conditional_multiple = (preconditions, procedure) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                query_1.q.dictionary(preconditions).__start(($) => {
+                    let has_errors = false;
+                    $.map(($) => {
+                        if (!$) {
+                            has_errors = true;
+                        }
+                    });
+                    if (!has_errors) {
+                        // all preconditions passed
+                        procedure.__start(on_success, (e) => {
+                            on_error(['procedure', e]);
+                        });
+                    }
+                    else {
+                        //the preconditions failed, so we are *successfully* skipping the procedure
+                        on_success();
+                    }
+                }, ($) => {
+                    on_error(['preconditions', $]);
+                });
+            }
+        });
+    };
+    p.conditional_sync = (precondition, procedure) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                if (precondition) {
+                    procedure.__start(on_success, on_error);
+                }
+                else {
+                    on_success();
+                }
+            }
+        });
+    };
+    p.dictionary_sequence = (steps) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                const op_dictionary_to_list_based_on_insertion_order = (dict) => {
+                    const temp = [];
+                    dict.map(($, key) => {
+                        temp.push({ key, value: $ });
+                    });
+                    return _ei.array_literal(temp);
+                };
+                const as_list = op_dictionary_to_list_based_on_insertion_order(steps);
+                let current = 0;
+                const do_next = () => {
+                    as_list.__get_element_at(current).transform(($) => {
+                        const key = $.key;
+                        current += 1;
+                        $.value.__start(() => {
+                            do_next();
+                        }, ($) => {
+                            on_error({
+                                'error': $,
+                                'step': key,
+                            });
+                        });
+                    }, () => {
+                        on_success();
+                    });
+                };
+                do_next();
+            }
+        });
+    };
+    p.dictionary = ($) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                let count_down = $.__get_number_of_entries();
+                let has_errors = false;
+                const errors = {};
+                const decrement_and_wrap_up_if_done = () => {
+                    count_down -= 1;
+                    if (count_down === 0) {
+                        if (has_errors) {
+                            on_error(_ei.dictionary_literal(errors));
+                        }
+                        else {
+                            on_success();
+                        }
+                    }
+                };
+                $.map(($, key) => {
+                    $.__start(() => {
+                        decrement_and_wrap_up_if_done();
+                    }, (e) => {
+                        has_errors = true;
+                        errors[key] = e;
+                        decrement_and_wrap_up_if_done();
+                    });
+                });
+            }
+        });
+    };
+    p.dictionary_2 = (the_dictionary, aggregate_errors) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                const errors = {};
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
+                    the_dictionary.map(($, key) => {
+                        monitor['report process started']();
+                        $.__start(() => {
+                            monitor['report process finished']();
+                        }, (e) => {
+                            errors[key] = e;
+                            monitor['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (Object.keys(errors).length === 0) {
+                        on_success();
+                    }
+                    else {
+                        on_error(aggregate_errors(_ei.dictionary_literal(errors)));
+                    }
+                });
+            }
+        });
+    };
+    p.execute_with_async_data = (procedure, query) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                query.__start((query_result) => {
+                    procedure["execute with synchronous data"](query_result).__start(on_success, on_error);
+                }, on_error);
+            }
+        });
+    };
+    p.sequence = (steps) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                let current = 0;
+                const do_next = () => {
+                    steps.__get_element_at(current).transform(($) => {
+                        current += 1;
+                        $.__start(() => {
+                            do_next();
+                        }, on_error);
+                    }, () => {
+                        on_success();
+                    });
+                };
+                do_next();
+            }
+        });
+    };
+    p.sequence_2 = (steps) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                const length = _ei.array_literal(steps).__get_number_of_elements();
+                const runStep = (index) => {
+                    if (index >= length) {
+                        on_success();
+                        return;
+                    }
+                    steps[index].__start(() => runStep(index + 1), on_error);
+                };
+                runStep(0);
+            }
+        });
+    };
+    p.three_steps = (step_1, step_2, step_3) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                step_1.__start(() => {
+                    step_2.__start(() => {
+                        step_3.__start(on_success, (error) => {
+                            on_error(['step3', error]);
+                        });
+                    }, (error) => {
+                        on_error(['step2', error]);
+                    });
+                }, (error) => {
+                    on_error(['step1', error]);
+                });
+            }
+        });
+    };
+    p.two_steps = (step_1, step_2) => {
+        return (0, create_procedure_promise_1.__create_procedure_promise)({
+            'execute': (on_success, on_error) => {
+                step_1.__start(() => {
+                    step_2.__start(on_success, (error) => {
+                        on_error(['step2', error]);
+                    });
+                }, (error) => {
+                    on_error(['step1', error]);
+                });
+            }
+        });
+    };
+})(p || (exports.p = p = {}));

package/dist/expressions/query.d.ts

@@ -0,0 +1,6 @@
+import * as _et from 'exupery-core-types';
+export declare namespace q {
+    const dictionary: <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 transform: <In, Out, Error>(query: _et.Query_Promise<In, Error>, transform: ($: In) => Out) => _et.Query_Promise<Out, Error>;
+}

package/dist/expressions/query.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.q = void 0;
+const _ei = __importStar(require("exupery-core-internals"));
+const create_query_promise_1 = require("../algorithms/query/create_query_promise");
+var q;
+(function (q) {
+    q.dictionary = ($) => {
+        return (0, create_query_promise_1.__create_query_promise)({
+            'execute': (on_success, on_error) => {
+                let count_down = $.__get_number_of_entries();
+                let has_errors = false;
+                const errors = {};
+                const results = {};
+                const decrement_and_wrap_up_if_done = () => {
+                    count_down -= 1;
+                    if (count_down === 0) {
+                        if (has_errors) {
+                            on_error(_ei.dictionary_literal(errors));
+                        }
+                        else {
+                            on_success(_ei.dictionary_literal(results));
+                        }
+                    }
+                };
+                $.map(($, key) => {
+                    $.__start(($) => {
+                        results[key] = $;
+                        decrement_and_wrap_up_if_done();
+                    }, ($) => {
+                        has_errors = true;
+                        errors[key] = $;
+                        decrement_and_wrap_up_if_done();
+                    });
+                });
+            }
+        });
+    };
+    q.fixed = (query_result) => {
+        return (0, create_query_promise_1.__create_query_promise)({
+            'execute': (on_success, on_error) => {
+                on_success(query_result);
+            }
+        });
+    };
+    q.transform = (//probably better to use the method on the query itself
+    query, transform) => {
+        return (0, create_query_promise_1.__create_query_promise)({
+            'execute': (on_success, on_error) => {
+                query.__start(($) => {
+                    on_success(transform($));
+                }, (e) => {
+                    on_error(e);
+                });
+            }
+        });
+    };
+})(q || (exports.q = q = {}));

package/dist/index.d.ts

@@ -1,25 +1,12 @@
 import * as _et from "exupery-core-types";
-export * from "./types/Basic_Query";
 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 "./shorthands";
-export * from "./procedure/assert_async";
-export * from "./procedure/assert_sync";
-export * from "./procedure/execute_with_async_data";
-export * from "./procedure/conditional_async";
-export * from "./procedure/conditional_multiple";
-export * from "./procedure/conditional_sync";
-export * from "./procedure/dictionary_sequence";
-export * from "./procedure/sequence";
-export * from "./procedure/three_steps";
-export * from "./procedure/two_steps";
-export * from "./procedure/procedure_dictionary";
-export * from "./query/transform_query";
-export * from "./query/query_dictionary";
+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>;

package/dist/index.js

@@ -16,7 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 //types
-__exportStar(require("./types/Basic_Query"), exports);
 //functions
 __exportStar(require("./algorithms/query/create_query_promise"), exports);
 __exportStar(require("./algorithms/query/create_query_primed_with_resources"), exports);
@@ -24,22 +23,10 @@ __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);
-__exportStar(require("./shorthands"), exports);
 // procedure exports
-__exportStar(require("./procedure/assert_async"), exports);
-__exportStar(require("./procedure/assert_sync"), exports);
-__exportStar(require("./procedure/execute_with_async_data"), exports);
-__exportStar(require("./procedure/conditional_async"), exports);
-__exportStar(require("./procedure/conditional_multiple"), exports);
-__exportStar(require("./procedure/conditional_sync"), exports);
-__exportStar(require("./procedure/dictionary_sequence"), exports);
-__exportStar(require("./procedure/sequence"), exports);
-__exportStar(require("./procedure/three_steps"), exports);
-__exportStar(require("./procedure/two_steps"), exports);
-__exportStar(require("./procedure/procedure_dictionary"), exports);
+__exportStar(require("./expressions/procedure"), exports);
 // query exports
-__exportStar(require("./query/transform_query"), exports);
-__exportStar(require("./query/query_dictionary"), exports);
+__exportStar(require("./expressions/query"), exports);
 const create_query_promise_1 = require("./algorithms/query/create_query_promise");
 exports.query = {
     'create result': ($) => {

package/package.json

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

package/dist/procedure/assert_async.d.ts

@@ -1,3 +0,0 @@
-import * as _et from 'exupery-core-types';
-export type Assert_Async_Error<Assertion_Error, Procedure_Error> = ['assertion error', Assertion_Error] | ['assertion failed', null] | ['procedure error', Procedure_Error];
-export declare const assert_async: <Assertion_Error, Procedure_Error>(assertion: _et.Query_Promise<boolean, Assertion_Error>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Assert_Async_Error<Assertion_Error, Procedure_Error>>;