exupery-core-async 0.3.7 → 0.3.8

package/dist/index.d.ts

@@ -7,6 +7,17 @@ export * from "./algorithms/query/create_unguaranteed_query";
 export * from "./algorithms/procedure/initialize_guaranteed_procedure";
 export * from "./algorithms/procedure/initialize_unguaranteed_procedure";
 export * from "./shorthands";
+export * from "./procedure/assert_async";
+export * from "./procedure/assert_sync";
+export * from "./procedure/conditional_async";
+export * from "./procedure/conditional_multiple";
+export * from "./procedure/conditional_sync";
+export * from "./procedure/sequence";
+export * from "./procedure/three_steps";
+export * from "./procedure/two_steps";
+export * from "./procedure/unguaranteed_procedure_dictionary";
+export * from "./query/transform_query";
+export * from "./query/unguaranteed_query_dictionary";
 export declare const query: {
     guaranteed: {
         'create result': <T>($: T) => _et.Guaranteed_Query_Promise<T>;

package/dist/index.js

@@ -25,6 +25,19 @@ __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);
+// procedure exports
+__exportStar(require("./procedure/assert_async"), exports);
+__exportStar(require("./procedure/assert_sync"), exports);
+__exportStar(require("./procedure/conditional_async"), exports);
+__exportStar(require("./procedure/conditional_multiple"), exports);
+__exportStar(require("./procedure/conditional_sync"), exports);
+__exportStar(require("./procedure/sequence"), exports);
+__exportStar(require("./procedure/three_steps"), exports);
+__exportStar(require("./procedure/two_steps"), exports);
+__exportStar(require("./procedure/unguaranteed_procedure_dictionary"), exports);
+// query exports
+__exportStar(require("./query/transform_query"), exports);
+__exportStar(require("./query/unguaranteed_query_dictionary"), exports);
 const create_guaranteed_query_1 = require("./algorithms/query/create_guaranteed_query");
 const create_unguaranteed_query_1 = require("./algorithms/query/create_unguaranteed_query");
 exports.query = {

package/dist/procedure/assert_async.d.ts

@@ -0,0 +1,3 @@
+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.Unguaranteed_Query_Promise<boolean, Assertion_Error>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Assert_Async_Error<Assertion_Error, Procedure_Error>>;

package/dist/procedure/assert_async.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert_async = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const assert_async = (assertion, procedure) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            assertion.__start(($) => {
+                if ($) {
+                    procedure.__start(on_success, ($) => {
+                        on_exception(['procedure error', $]);
+                    });
+                }
+                else {
+                    on_exception(['assertion failed', null]);
+                }
+            }, ($) => {
+                on_exception(['assertion error', $]);
+            });
+        }
+    });
+};
+exports.assert_async = assert_async;

package/dist/procedure/assert_sync.d.ts

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

package/dist/procedure/assert_sync.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert_sync = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const assert_sync = (assertion, procedure) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            if (!assertion) {
+                on_exception(['assertion failed', null]);
+                return;
+            }
+            procedure.__start(on_success, ($) => {
+                on_exception(['procedure error', $]);
+            });
+        }
+    });
+};
+exports.assert_sync = assert_sync;

package/dist/procedure/conditional_async.d.ts

@@ -0,0 +1,4 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+export type Conditional_Async_Error<Precondition_Error, Procedure_Error> = ['precondition', Precondition_Error] | ['procedure', Procedure_Error];
+export declare const conditional_async: <Precondition_Error, Procedure_Error>(precondition: Basic_Unguaranteed_Query_Promise<boolean, Precondition_Error>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Conditional_Async_Error<Precondition_Error, Procedure_Error>>;

package/dist/procedure/conditional_async.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditional_async = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const conditional_async = (precondition, procedure) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            precondition.__start(($) => {
+                if ($) {
+                    procedure.__start(on_success, (e) => {
+                        on_exception(['procedure', e]);
+                    });
+                }
+                else {
+                    on_success();
+                }
+            }, ($) => {
+                on_exception(['precondition', $]);
+            });
+        }
+    });
+};
+exports.conditional_async = conditional_async;

package/dist/procedure/conditional_multiple.d.ts

@@ -0,0 +1,4 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+export type Conditional_Multiple_Error<Precondition_Error, Procedure_Error> = ['preconditions', _et.Dictionary<Precondition_Error>] | ['procedure', Procedure_Error];
+export declare const conditional_multiple: <Precondition_Error, Procedure_Error>(preconditions: _et.Dictionary<Basic_Unguaranteed_Query_Promise<boolean, Precondition_Error>>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Conditional_Multiple_Error<Precondition_Error, Procedure_Error>>;

package/dist/procedure/conditional_multiple.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditional_multiple = void 0;
+const unguaranteed_query_dictionary_1 = require("../query/unguaranteed_query_dictionary");
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const conditional_multiple = (preconditions, procedure) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            (0, unguaranteed_query_dictionary_1.unguaranteed_query_dictionary)(preconditions).__start(($) => {
+                let has_errors = false;
+                $.map(($) => {
+                    if (!$) {
+                        has_errors = true;
+                    }
+                });
+                if (!has_errors) {
+                    // all preconditions passed
+                    procedure.__start(on_success, (e) => {
+                        on_exception(['procedure', e]);
+                    });
+                }
+                else {
+                    //the preconditions failed, so we are *successfully* skipping the procedure
+                    on_success();
+                }
+            }, ($) => {
+                on_exception(['preconditions', $]);
+            });
+        }
+    });
+};
+exports.conditional_multiple = conditional_multiple;

package/dist/procedure/conditional_sync.d.ts

@@ -0,0 +1,2 @@
+import * as _et from 'exupery-core-types';
+export declare const conditional_sync: <Procedure_Error>(precondition: boolean, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Procedure_Error>;

package/dist/procedure/conditional_sync.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditional_sync = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const conditional_sync = (precondition, procedure) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            if (precondition) {
+                procedure.__start(on_success, on_exception);
+            }
+            else {
+                on_success();
+            }
+        }
+    });
+};
+exports.conditional_sync = conditional_sync;

package/dist/procedure/sequence.d.ts

@@ -0,0 +1,6 @@
+import * as _et from 'exupery-core-types';
+export type Sequence_Error<Err> = {
+    'error': Err;
+    'step': string;
+};
+export declare const sequence: <Err>(steps: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Err>>) => _et.Unguaranteed_Procedure_Promise<Sequence_Error<Err>>;

package/dist/procedure/sequence.js

@@ -0,0 +1,61 @@
+"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.sequence = void 0;
+const _ei = __importStar(require("exupery-core-internals"));
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+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 sequence = (steps) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            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_exception({
+                            'error': $,
+                            'step': key,
+                        });
+                    });
+                }, () => {
+                    on_success();
+                });
+            };
+            do_next();
+        }
+    });
+};
+exports.sequence = sequence;

package/dist/procedure/three_steps.d.ts

@@ -0,0 +1,3 @@
+import * as _et from 'exupery-core-types';
+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 declare const three_steps: <Step_1_Error, Step_2_Error, Step_3_Error>(step_1: _et.Unguaranteed_Procedure_Promise<Step_1_Error>, step_2: _et.Unguaranteed_Procedure_Promise<Step_2_Error>, step_3: _et.Unguaranteed_Procedure_Promise<Step_3_Error>) => _et.Unguaranteed_Procedure_Promise<Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error>>;

package/dist/procedure/three_steps.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.three_steps = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const three_steps = (step_1, step_2, step_3) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            step_1.__start(() => {
+                step_2.__start(() => {
+                    step_3.__start(on_success, (error) => {
+                        on_exception(['step3', error]);
+                    });
+                }, (error) => {
+                    on_exception(['step2', error]);
+                });
+            }, (error) => {
+                on_exception(['step1', error]);
+            });
+        }
+    });
+};
+exports.three_steps = three_steps;

package/dist/procedure/two_steps.d.ts

@@ -0,0 +1,3 @@
+import * as _et from 'exupery-core-types';
+export type Two_Steps_Error<Step_1_Error, Step_2_Error> = ['step1', Step_1_Error] | ['step2', Step_2_Error];
+export declare const two_steps: <Step_1_Error, Step_2_Error>(step_1: _et.Unguaranteed_Procedure_Promise<Step_1_Error>, step_2: _et.Unguaranteed_Procedure_Promise<Step_2_Error>) => _et.Unguaranteed_Procedure_Promise<Two_Steps_Error<Step_1_Error, Step_2_Error>>;

package/dist/procedure/two_steps.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.two_steps = void 0;
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const two_steps = (step_1, step_2) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            step_1.__start(() => {
+                step_2.__start(on_success, (error) => {
+                    on_exception(['step2', error]);
+                });
+            }, (error) => {
+                on_exception(['step1', error]);
+            });
+        }
+    });
+};
+exports.two_steps = two_steps;

package/dist/procedure/unguaranteed_procedure_dictionary.d.ts

@@ -0,0 +1,2 @@
+import * as _et from 'exupery-core-types';
+export declare const unguaranteed_procedure_dictionary: <Error>($: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Error>>) => _et.Unguaranteed_Procedure_Promise<_et.Dictionary<Error>>;

package/dist/procedure/unguaranteed_procedure_dictionary.js

@@ -0,0 +1,58 @@
+"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.unguaranteed_procedure_dictionary = void 0;
+const _ei = __importStar(require("exupery-core-internals"));
+const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const unguaranteed_procedure_dictionary = ($) => {
+    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+        'execute': (on_success, on_exception) => {
+            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_exception(_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();
+                });
+            });
+        }
+    });
+};
+exports.unguaranteed_procedure_dictionary = unguaranteed_procedure_dictionary;

package/dist/query/transform_query.d.ts

@@ -0,0 +1,3 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+export declare const transform_query: <In, Out, Error>(query: Basic_Unguaranteed_Query_Promise<In, Error>, transform: ($: In) => Out) => _et.Unguaranteed_Query_Promise<Out, Error>;

package/dist/query/transform_query.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform_query = void 0;
+const create_unguaranteed_query_1 = require("../algorithms/query/create_unguaranteed_query");
+const transform_query = (query, transform) => {
+    return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
+        'execute': (on_success, on_exception) => {
+            query.__start(($) => {
+                on_success(transform($));
+            }, (e) => {
+                on_exception(e);
+            });
+        }
+    });
+};
+exports.transform_query = transform_query;

package/dist/query/unguaranteed_query_dictionary.d.ts

@@ -0,0 +1,3 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+export declare const unguaranteed_query_dictionary: <Result, Error>($: _et.Dictionary<Basic_Unguaranteed_Query_Promise<Result, Error>>) => _et.Unguaranteed_Query_Promise<_et.Dictionary<Result>, _et.Dictionary<Error>>;

package/dist/query/unguaranteed_query_dictionary.js

@@ -0,0 +1,60 @@
+"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.unguaranteed_query_dictionary = void 0;
+const _ei = __importStar(require("exupery-core-internals"));
+const create_unguaranteed_query_1 = require("../algorithms/query/create_unguaranteed_query");
+const unguaranteed_query_dictionary = ($) => {
+    return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
+        'execute': (on_success, on_exception) => {
+            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_exception(_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();
+                });
+            });
+        }
+    });
+};
+exports.unguaranteed_query_dictionary = unguaranteed_query_dictionary;

package/package.json

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