exupery-core-async 0.1.41 → 0.1.43

package/dist/{procedure → algorithms/procedure}/initialize_guaranteed_procedure.d.ts

@@ -1,4 +1,4 @@
-import { Guaranteed_Procedure } from "./Guaranteed_Procedure";
+import { Guaranteed_Procedure } from "../../types/Guaranteed_Procedure";
 type Executer = {
     'execute': (on_finished: () => void) => void;
 };

package/dist/{procedure → algorithms/procedure}/initialize_unguaranteed_procedure.d.ts

@@ -1,4 +1,4 @@
-import { Unguaranteed_Procedure } from "./Unguaranteed_Procedure";
+import { Unguaranteed_Procedure } from "../../types/Unguaranteed_Procedure";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called

package/dist/{query → algorithms/query}/create_guaranteed_query.d.ts

@@ -1,4 +1,4 @@
-import { _Guaranteed_Query } from "./Guaranteed_Query";
+import { _Guaranteed_Query } from "../../types/Guaranteed_Query";
 type Executer<T> = {
     'execute': (on_value: ($: T) => void) => void;
 };

package/dist/{query → algorithms/query}/create_unguaranteed_query.d.ts

@@ -1,4 +1,4 @@
-import { _Unguaranteed_Query } from "./Unguaranteed_Query";
+import { _Unguaranteed_Query } from "../../types/Unguaranteed_Query";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called

package/dist/{query → algorithms/query}/merge_2_guaranteed_queries.d.ts

@@ -1,4 +1,4 @@
-import { _Guaranteed_Query } from "./Guaranteed_Query";
+import { _Guaranteed_Query } from "../../types/Guaranteed_Query";
 export type Sync_Tuple_2<T1, T2> = {
     readonly 'first': T1;
     readonly 'second': T2;

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-export * from "./procedure/Guaranteed_Procedure";
-export * from "./procedure/Unguaranteed_Procedure";
-export * from "./query/Unguaranteed_Query";
-export * from "./query/Guaranteed_Query";
-export * from "./query/merge_2_guaranteed_queries";
-export * from "./query/create_guaranteed_query";
-export * from "./query/create_unguaranteed_query";
-export * from "./procedure/initialize_guaranteed_procedure";
-export * from "./procedure/initialize_unguaranteed_procedure";
-export * from "./new";
-import { Guaranteed_Procedure } from "./procedure/Guaranteed_Procedure";
-import { Unguaranteed_Procedure } from "./procedure/Unguaranteed_Procedure";
-import { _Guaranteed_Query } from "./query/Guaranteed_Query";
-import { _Unguaranteed_Query } from "./query/Unguaranteed_Query";
+export * from "./types/Guaranteed_Procedure";
+export * from "./types/Unguaranteed_Procedure";
+export * from "./types/Unguaranteed_Query";
+export * from "./types/Guaranteed_Query";
+export * from "./algorithms/query/merge_2_guaranteed_queries";
+export * from "./algorithms/query/create_guaranteed_query";
+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 } from "./types/Guaranteed_Procedure";
+import { Unguaranteed_Procedure } from "./types/Unguaranteed_Procedure";
+import { _Guaranteed_Query } from "./types/Guaranteed_Query";
+import { _Unguaranteed_Query } from "./types/Unguaranteed_Query";
 export declare const query: {
     guaranteed: {
         'create result': <T>($: T) => _Guaranteed_Query<T>;

package/dist/index.js

@@ -16,21 +16,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = exports.query = void 0;
 //types
-__exportStar(require("./procedure/Guaranteed_Procedure"), exports);
-__exportStar(require("./procedure/Unguaranteed_Procedure"), exports);
-__exportStar(require("./query/Unguaranteed_Query"), exports);
-__exportStar(require("./query/Guaranteed_Query"), exports);
+__exportStar(require("./types/Guaranteed_Procedure"), exports);
+__exportStar(require("./types/Unguaranteed_Procedure"), exports);
+__exportStar(require("./types/Unguaranteed_Query"), exports);
+__exportStar(require("./types/Guaranteed_Query"), exports);
 //functions
-__exportStar(require("./query/merge_2_guaranteed_queries"), exports);
-__exportStar(require("./query/create_guaranteed_query"), exports);
-__exportStar(require("./query/create_unguaranteed_query"), exports);
-__exportStar(require("./procedure/initialize_guaranteed_procedure"), exports);
-__exportStar(require("./procedure/initialize_unguaranteed_procedure"), exports);
-__exportStar(require("./new"), exports);
-const initialize_guaranteed_procedure_1 = require("./procedure/initialize_guaranteed_procedure");
-const initialize_unguaranteed_procedure_1 = require("./procedure/initialize_unguaranteed_procedure");
-const create_guaranteed_query_1 = require("./query/create_guaranteed_query");
-const create_unguaranteed_query_1 = require("./query/create_unguaranteed_query");
+__exportStar(require("./algorithms/query/merge_2_guaranteed_queries"), exports);
+__exportStar(require("./algorithms/query/create_guaranteed_query"), exports);
+__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 = {
     'guaranteed': {
         'create result': ($) => {

package/dist/shorthands.d.ts

@@ -0,0 +1,128 @@
+import * as _ei from 'exupery-core-internals';
+import * as _et from 'exupery-core-types';
+import { Unguaranteed } from "./types/Unguaranteed_Query";
+import { Guaranteed } from "./types/Guaranteed_Query";
+import { Guaranteed_Procedure, Guaranteed_Procedure_Initializer } from "./types/Guaranteed_Procedure";
+import { Unguaranteed_Procedure_Initializer, Unguaranteed_Procedure } from "./types/Unguaranteed_Procedure";
+import { Unguaranteed_Query_Initializer } from "./types/Unguaranteed_Query";
+import { Guaranteed_Query_Initializer } from "./types/Guaranteed_Query";
+import { Error_Handler } from "./types/Error_Handler";
+/**
+ *
+ * @param action gpi
+ * @param error_transform gt
+ */
+export declare const eh: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Error, Parameters>) => Error_Handler<Error>;
+export declare namespace gp {
+    /**
+     *
+     * @param action gpi
+     * @param query g.q
+     * @returns
+     */
+    const action: <Parameters>(action: Guaranteed_Procedure_Initializer<Parameters>, query: Guaranteed.Query_<Parameters>) => Guaranteed_Procedure;
+}
+export declare namespace gq {
+    /**
+     *
+     * @param query_result qr
+     * @returns
+     */
+    const fixed: <Query_Result>(query_result: Query_Result) => Guaranteed.Query_<Query_Result>;
+    /**
+     *
+     * @param the_query gqi
+     * @param parameters g.q
+     * @param result_transformation gt
+     * @returns
+     */
+    const g: <Result_After_Transformation, Parameters, Query_Result>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Guaranteed.Query_<Parameters>, result_transformation: _ei.Guaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation>) => Guaranteed.Query_<Result_After_Transformation>;
+}
+export declare namespace gt {
+    /**
+     *
+     * @param the_transformation gt
+     * @returns
+     */
+    const g: <In, Out>(the_transformation: _ei.Guaranteed_Transformation_Without_Parameters<In, Out>) => _ei.Guaranteed_Transformation_Without_Parameters<In, Out>;
+}
+export declare namespace up {
+    /**
+     *
+     * @param action upi
+     * @param query u.q
+     */
+    const action: <Error, Parameters>(action: Unguaranteed_Procedure_Initializer<Parameters, Error>, query: Unguaranteed.Query<Parameters, Error>) => Unguaranteed_Procedure<Error>;
+    /**
+     *
+     * @param steps up[]
+     * @returns
+     */
+    const sequence: <Error>(steps: Unguaranteed_Procedure<Error>[]) => Unguaranteed_Procedure<Error>;
+    /**
+     *
+     * @param the_array up[]
+     * @param aggregate_exceptions gt
+     * @returns
+     */
+    const array: <Error, Element_Error>(the_array: _et.Array<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Guaranteed_Transformation_Without_Parameters<_et.Array<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
+    /**
+     *
+     * @param the_dictionary dict<up>
+     * @param aggregate_exceptions gt
+     * @returns
+     */
+    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Guaranteed_Transformation_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
+}
+export declare namespace upi {
+    /**
+     *
+     * @param action gpi
+     */
+    const g: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
+    /**
+     *
+     * @param action upi
+     */
+    const u: <Parameters, Error, Action_Error>(action: Unguaranteed_Procedure_Initializer<Parameters, Action_Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
+}
+export declare namespace uq {
+    /**
+     *
+     * @param query_result qr
+     * @returns
+     */
+    const fixed: <Query_Result, Error>(query_result: Query_Result) => Unguaranteed.Query<Query_Result, Error>;
+    /**
+     * unguaranteed query
+     * @param the_query uqi
+     * @param parameters u.q
+     * @param result_transformation ut
+     * @param error_transform gt
+     * @param error_handler eh
+     * @returns
+     */
+    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error>(the_query: Unguaranteed_Query_Initializer<Parameters, Query_Result, Query_Error>, parameters: Unguaranteed.Query<Parameters, Error>, result_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
+    /**
+     * guaranteed query
+     * @param the_query gqi
+     * @param parameters u.q
+     * @param result_transformation ut
+     */
+    const g: <Result_After_Transformation, Error, Parameters, Query_Result>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Unguaranteed.Query<Parameters, Error>, result_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation, Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
+}
+export declare namespace ut {
+    /**
+     *
+     * @param the_transformation ut
+     * @param error_transform  gt
+     * @param error_handler  eh
+     * @returns
+     */
+    const u: <In, Out, Error, Transformation_Error>(the_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Transformation_Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Transformation_Error, Error>, error_handler?: Error_Handler<Transformation_Error>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
+    /**
+     *
+     * @param the_transformation gt
+     */
+    const g: <In, Out, Error>(the_transformation: _ei.Guaranteed_Transformation_Without_Parameters<In, Out>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
+}

package/dist/shorthands.js

@@ -0,0 +1,326 @@
+"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.ut = exports.uq = exports.upi = exports.up = exports.gt = exports.gq = exports.gp = exports.eh = void 0;
+const _ei = __importStar(require("exupery-core-internals"));
+const initialize_unguaranteed_procedure_1 = require("./algorithms/procedure/initialize_unguaranteed_procedure");
+const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
+/**
+ *
+ * @param action gpi
+ * @param error_transform gt
+ */
+const eh = (action, error_transform) => {
+    return ($) => {
+        action(error_transform($)).__start(() => { });
+    };
+};
+exports.eh = eh;
+var gp;
+(function (gp) {
+    /**
+     *
+     * @param action gpi
+     * @param query g.q
+     * @returns
+     */
+    gp.action = (action, query) => {
+        return {
+            __start: (on_finished) => {
+                //run the query
+                query.__start((query_result) => {
+                    //run the action
+                    action(query_result).__start(on_finished);
+                });
+            }
+        };
+    };
+})(gp || (exports.gp = gp = {}));
+var gq;
+(function (gq) {
+    /**
+     *
+     * @param query_result qr
+     * @returns
+     */
+    gq.fixed = (query_result) => {
+        return {
+            __start: (on_finished) => {
+                on_finished(query_result);
+            }
+        };
+    };
+    /**
+     *
+     * @param the_query gqi
+     * @param parameters g.q
+     * @param result_transformation gt
+     * @returns
+     */
+    gq.g = (the_query, parameters, result_transformation) => {
+        return {
+            __start: (on_finished) => {
+                parameters.__start((qr_in) => {
+                    the_query(qr_in).__start((result) => {
+                        on_finished(result_transformation(result));
+                    });
+                });
+            }
+        };
+    };
+})(gq || (exports.gq = gq = {}));
+var gt;
+(function (gt) {
+    /**
+     *
+     * @param the_transformation gt
+     * @returns
+     */
+    gt.g = (the_transformation) => {
+        return ($) => the_transformation($);
+    };
+})(gt || (exports.gt = gt = {}));
+var up;
+(function (up) {
+    /**
+     *
+     * @param action upi
+     * @param query u.q
+     */
+    up.action = (action, query) => {
+        return {
+            __start: (on_success, on_error) => {
+                //run the query
+                query.__start((query_result) => {
+                    //run the action
+                    action(query_result).__start(on_success, (error) => {
+                        //transform the error
+                        on_error(error);
+                    });
+                }, on_error);
+            }
+        };
+    };
+    /**
+     *
+     * @param steps up[]
+     * @returns
+     */
+    up.sequence = (steps) => {
+        return {
+            __start: (on_success, on_error) => {
+                const length = _ei.array_literal(steps).__get_length();
+                const runStep = (index) => {
+                    if (index >= length) {
+                        on_success();
+                        return;
+                    }
+                    steps[index].__start(() => runStep(index + 1), on_error);
+                };
+                runStep(0);
+            }
+        };
+    };
+    /**
+     *
+     * @param the_array up[]
+     * @param aggregate_exceptions gt
+     * @returns
+     */
+    up.array = (the_array, aggregate_exceptions) => {
+        return {
+            __start: (on_success, on_error) => {
+                const exceptions = [];
+                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
+                    the_array.map(($) => {
+                        monitor['report process started']();
+                        $.__start(() => {
+                            monitor['report process finished']();
+                        }, (e) => {
+                            exceptions.push(e);
+                            monitor['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (exceptions.length === 0) {
+                        on_success();
+                    }
+                    else {
+                        on_error(aggregate_exceptions(_ei.array_literal(exceptions)));
+                    }
+                });
+            }
+        };
+    };
+    /**
+     *
+     * @param the_dictionary dict<up>
+     * @param aggregate_exceptions gt
+     * @returns
+     */
+    up.dictionary = (the_dictionary, aggregate_exceptions) => {
+        return {
+            __start: (on_success, on_error) => {
+                const exceptions = {};
+                (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) => {
+                            exceptions[key] = e;
+                            monitor['report process finished']();
+                        });
+                    });
+                }, () => {
+                    if (Object.keys(exceptions).length === 0) {
+                        on_success();
+                    }
+                    else {
+                        on_error(aggregate_exceptions(_ei.dictionary_literal(exceptions)));
+                    }
+                });
+            }
+        };
+    };
+})(up || (exports.up = up = {}));
+var upi;
+(function (upi) {
+    /**
+     *
+     * @param action gpi
+     */
+    upi.g = (action) => ($) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_succes, on_error) => {
+                action($).__start(on_succes);
+            }
+        });
+    };
+    /**
+     *
+     * @param action upi
+     */
+    upi.u = (action, error_transform, error_handler) => ($) => {
+        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+            'execute': (on_succes, on_error) => {
+                action($).__start(on_succes, (error) => {
+                    if (error_handler !== undefined) {
+                        error_handler(error);
+                    }
+                    on_error(error_transform(error));
+                });
+            }
+        });
+    };
+})(upi || (exports.upi = upi = {}));
+var uq;
+(function (uq) {
+    /**
+     *
+     * @param query_result qr
+     * @returns
+     */
+    uq.fixed = (query_result) => {
+        return {
+            __start: (on_success, on_error) => {
+                on_success(query_result);
+            }
+        };
+    };
+    /**
+     * unguaranteed query
+     * @param the_query uqi
+     * @param parameters u.q
+     * @param result_transformation ut
+     * @param error_transform gt
+     * @param error_handler eh
+     * @returns
+     */
+    uq.u = (the_query, parameters, result_transformation, error_transform, error_handler) => {
+        return {
+            __start: (on_success, on_error) => {
+                parameters.__start((qr_in) => {
+                    the_query(qr_in).__start((result) => {
+                        result_transformation(result).process((x) => on_success(x), on_error);
+                    }, (error) => {
+                        if (error_handler !== undefined) {
+                            error_handler(error);
+                        }
+                        on_error(error_transform(error));
+                    });
+                }, on_error);
+            }
+        };
+    };
+    /**
+     * guaranteed query
+     * @param the_query gqi
+     * @param parameters u.q
+     * @param result_transformation ut
+     */
+    uq.g = (the_query, parameters, result_transformation) => {
+        return {
+            __start: (on_success, on_error) => {
+                parameters.__start((x) => {
+                    the_query(x).__start(($) => {
+                        result_transformation($).process((x) => on_success(x), on_error);
+                    });
+                }, on_error);
+            }
+        };
+    };
+})(uq || (exports.uq = uq = {}));
+var ut;
+(function (ut) {
+    /**
+     *
+     * @param the_transformation ut
+     * @param error_transform  gt
+     * @param error_handler  eh
+     * @returns
+     */
+    ut.u = (the_transformation, error_transform, error_handler) => {
+        return ($) => {
+            const result = the_transformation($);
+            return result.map((out) => out, (transformation_error) => {
+                //run the error handler
+                if (error_handler !== undefined) {
+                    error_handler(transformation_error);
+                }
+                return error_transform(transformation_error);
+            });
+        };
+    };
+    /**
+     *
+     * @param the_transformation gt
+     */
+    ut.g = (the_transformation) => {
+        return ($) => {
+            return _ei.transformation.successful(the_transformation($));
+        };
+    };
+})(ut || (exports.ut = ut = {}));

package/dist/types/Error_Handler.d.ts

@@ -0,0 +1 @@
+export type Error_Handler<Error> = (error: Error) => void;

package/dist/types/Guaranteed_Procedure.d.ts

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

package/dist/{query → types}/Guaranteed_Query.d.ts

@@ -15,3 +15,8 @@ export interface _Guaranteed_Query<T> {
     __start(on_value: ($: T) => void): void;
 }
 export type Guaranteed_Query_Initializer<Parameters, Result> = ($: Parameters) => _Guaranteed_Query<Result>;
+export declare namespace Guaranteed {
+    type Query_<Result> = {
+        __start: (on_finished: (result: Result) => void) => void;
+    };
+}

package/dist/{procedure → types}/Unguaranteed_Procedure.d.ts

@@ -1,4 +1,4 @@
-export type Unguaranteed_Procedure_Initializer<Params, Error> = ($: Params) => Unguaranteed_Procedure<Error>;
+export type Unguaranteed_Procedure_Initializer<Parameters, Error> = ($: Parameters) => Unguaranteed_Procedure<Error>;
 export interface Unguaranteed_Procedure<Error> {
     __start: (on_success: () => void, on_error: (error: Error) => void) => void;
 }

package/dist/{query → types}/Unguaranteed_Query.d.ts

@@ -8,3 +8,8 @@ export interface _Unguaranteed_Query<T, E> {
     __start(on_value: ($: T) => void, on_exception: ($: E) => void): void;
 }
 export type Unguaranteed_Query_Initializer<Parameters, Result, Error> = ($: Parameters) => _Unguaranteed_Query<Result, Error>;
+export declare namespace Unguaranteed {
+    type Query<Result, Error> = {
+        __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
+    };
+}

package/dist/types/Unguaranteed_Query.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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

package/dist/new.d.ts

@@ -1,102 +0,0 @@
-import * as _ei from 'exupery-core-internals';
-import * as _et from 'exupery-core-types';
-import { Guaranteed_Procedure, Guaranteed_Procedure_Initializer } from "./procedure/Guaranteed_Procedure";
-import { Unguaranteed_Procedure_Initializer, Unguaranteed_Procedure } from "./procedure/Unguaranteed_Procedure";
-import { Unguaranteed_Query_Initializer } from "./query/Unguaranteed_Query";
-import { Guaranteed_Query_Initializer } from "./query/Guaranteed_Query";
-export type Error_Handler<Error> = (error: Error) => void;
-export declare namespace Unguaranteed {
-    type Query<Result, Error> = {
-        __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
-    };
-}
-export declare namespace Guaranteed {
-    type Query<Result> = {
-        __start: (on_finished: (result: Result) => void) => void;
-    };
-}
-export declare namespace ut {
-    const u: <In, Out, Error>(the_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
-    const g: <In, Out, Error>(the_transformation: _ei.Guaranteed_Transformation_Without_Parameters<In, Out>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
-}
-export declare namespace gt {
-    const g: <In, Out>(the_transformation: _ei.Guaranteed_Transformation_Without_Parameters<In, Out>) => _ei.Guaranteed_Transformation_Without_Parameters<In, Out>;
-}
-/**
- *
- * @param action a_my_action
- * @param error_transform ($) => ....
- */
-export declare const eh: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Error, Parameters>) => Error_Handler<Error>;
-export declare namespace u {
-    namespace a {
-        /**
-         *
-         * @param action a_my_action
-         */
-        const g: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
-        /**
-         *
-         * @param action a_my_action
-         */
-        const u: <Parameters, Error, Action_Error>(action: Unguaranteed_Procedure_Initializer<Parameters, Action_Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
-    }
-    namespace q {
-        const fixed: <Query_Result, Error>(query_result: Query_Result) => Unguaranteed.Query<Query_Result, Error>;
-        /**
-         * unguaranteed query
-         * @param the_query q_my_query
-         * @param parameters u.q.*(...)
-         * @param result_transformation u.t.*()
-         * @param error_transform ($) => ...
-         * @param error_handler eh(...)
-         * @returns
-         */
-        const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error>(the_query: Unguaranteed_Query_Initializer<Parameters, Query_Result, Query_Error>, parameters: Unguaranteed.Query<Parameters, Error>, result_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
-        /**
-         * guaranteed query
-         * @param the_query q_my_query
-         * @param parameters u.q.*()
-         * @param result_transformation ($) => ...
-         */
-        const g: <Result_After_Transformation, Error, Parameters, Query_Result>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Unguaranteed.Query<Parameters, Error>, result_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation, Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
-    }
-    namespace t {
-        /**
-         *
-         * @param the_transformation ($) => _ea.Unguaranteed_Transformation_Result
-         * @param error_transform  ($) => ...
-         * @param error_handler  eh()
-         * @returns
-         */
-        const u: <In, Out, Error, Transformation_Error>(the_transformation: _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Transformation_Error>, error_transform: _ei.Guaranteed_Transformation_Without_Parameters<Transformation_Error, Error>, error_handler?: Error_Handler<Transformation_Error>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
-        /**
-         *
-         * @param the_transformation ($) => ...
-         */
-        const g: <In, Out, Error>(the_transformation: _ei.Guaranteed_Transformation_Without_Parameters<In, Out>) => _ei.Unguaranteed_Transformation_Without_Parameters<In, Out, Error>;
-    }
-    namespace p {
-        /**
-         *
-         * @param action u.a.*(...)
-         * @param query u.q.*(...)
-         */
-        const action: <Error, Parameters>(action: Unguaranteed_Procedure_Initializer<Parameters, Error>, query: Unguaranteed.Query<Parameters, Error>) => Unguaranteed_Procedure<Error>;
-        const sequence: <Error>(steps: Unguaranteed_Procedure<Error>[]) => Unguaranteed_Procedure<Error>;
-        const array: <Error, Element_Error>(the_array: _et.Array<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Guaranteed_Transformation_Without_Parameters<_et.Array<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
-        const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Guaranteed_Transformation_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
-    }
-}
-export declare namespace g {
-    namespace a {
-        const g: <Parameters>(action: Guaranteed_Procedure_Initializer<Parameters>) => Guaranteed_Procedure_Initializer<Parameters>;
-    }
-    namespace q {
-        const fixed: <Query_Result>(query_result: Query_Result) => Guaranteed.Query<Query_Result>;
-        const g: <Result_After_Transformation, Parameters, Query_Result>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Guaranteed.Query<Parameters>, result_transformation: _ei.Guaranteed_Transformation_Without_Parameters<Query_Result, Result_After_Transformation>) => Guaranteed.Query<Result_After_Transformation>;
-    }
-    namespace p {
-        const action: <Parameters>(action: Guaranteed_Procedure_Initializer<Parameters>, query: Guaranteed.Query<Parameters>) => Guaranteed_Procedure;
-    }
-}

package/dist/new.js

@@ -1,307 +0,0 @@
-"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.g = exports.u = exports.eh = exports.gt = exports.ut = void 0;
-const _ei = __importStar(require("exupery-core-internals"));
-const initialize_unguaranteed_procedure_1 = require("./procedure/initialize_unguaranteed_procedure");
-const initialize_guaranteed_procedure_1 = require("./procedure/initialize_guaranteed_procedure");
-const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
-var ut;
-(function (ut) {
-    ut.u = (the_transformation) => {
-        return the_transformation;
-    };
-    ut.g = (the_transformation) => {
-        return ($) => _ei.transformation.successful(the_transformation($));
-    };
-})(ut || (exports.ut = ut = {}));
-var gt;
-(function (gt) {
-    gt.g = (the_transformation) => {
-        return ($) => the_transformation($);
-    };
-})(gt || (exports.gt = gt = {}));
-/**
- *
- * @param action a_my_action
- * @param error_transform ($) => ....
- */
-const eh = (action, error_transform) => {
-    return ($) => {
-        action(error_transform($)).__start(() => { });
-    };
-};
-exports.eh = eh;
-var u;
-(function (u_1) {
-    let a;
-    (function (a) {
-        /**
-         *
-         * @param action a_my_action
-         */
-        a.g = (action) => ($) => {
-            return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
-                'execute': (on_succes, on_error) => {
-                    action($).__start(on_succes);
-                }
-            });
-        };
-        /**
-         *
-         * @param action a_my_action
-         */
-        a.u = (action, error_transform, error_handler) => ($) => {
-            return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
-                'execute': (on_succes, on_error) => {
-                    action($).__start(on_succes, (error) => {
-                        if (error_handler !== undefined) {
-                            error_handler(error);
-                        }
-                        on_error(error_transform(error));
-                    });
-                }
-            });
-        };
-    })(a = u_1.a || (u_1.a = {}));
-    let q;
-    (function (q) {
-        q.fixed = (query_result) => {
-            return {
-                __start: (on_success, on_error) => {
-                    on_success(query_result);
-                }
-            };
-        };
-        /**
-         * unguaranteed query
-         * @param the_query q_my_query
-         * @param parameters u.q.*(...)
-         * @param result_transformation u.t.*()
-         * @param error_transform ($) => ...
-         * @param error_handler eh(...)
-         * @returns
-         */
-        q.u = (the_query, parameters, result_transformation, error_transform, error_handler) => {
-            return {
-                __start: (on_success, on_error) => {
-                    parameters.__start((qr_in) => {
-                        the_query(qr_in).__start((result) => {
-                            result_transformation(result).process((x) => on_success(x), on_error);
-                        }, (error) => {
-                            if (error_handler !== undefined) {
-                                error_handler(error);
-                            }
-                            on_error(error_transform(error));
-                        });
-                    }, on_error);
-                }
-            };
-        };
-        /**
-         * guaranteed query
-         * @param the_query q_my_query
-         * @param parameters u.q.*()
-         * @param result_transformation ($) => ...
-         */
-        q.g = (the_query, parameters, result_transformation) => {
-            return {
-                __start: (on_success, on_error) => {
-                    parameters.__start((x) => {
-                        the_query(x).__start(($) => {
-                            result_transformation($).process((x) => on_success(x), on_error);
-                        });
-                    }, on_error);
-                }
-            };
-        };
-    })(q = u_1.q || (u_1.q = {}));
-    let t;
-    (function (t) {
-        /**
-         *
-         * @param the_transformation ($) => _ea.Unguaranteed_Transformation_Result
-         * @param error_transform  ($) => ...
-         * @param error_handler  eh()
-         * @returns
-         */
-        t.u = (the_transformation, error_transform, error_handler) => {
-            return ($) => {
-                const result = the_transformation($);
-                return result.map((out) => out, (transformation_error) => {
-                    //run the error handler
-                    if (error_handler !== undefined) {
-                        error_handler(transformation_error);
-                    }
-                    return error_transform(transformation_error);
-                });
-            };
-        };
-        /**
-         *
-         * @param the_transformation ($) => ...
-         */
-        t.g = (the_transformation) => {
-            return ($) => {
-                return _ei.transformation.successful(the_transformation($));
-            };
-        };
-    })(t = u_1.t || (u_1.t = {}));
-    let p;
-    (function (p) {
-        /**
-         *
-         * @param action u.a.*(...)
-         * @param query u.q.*(...)
-         */
-        p.action = (action, query) => {
-            return {
-                __start: (on_success, on_error) => {
-                    //run the query
-                    query.__start((query_result) => {
-                        //run the action
-                        action(query_result).__start(on_success, (error) => {
-                            //transform the error
-                            on_error(error);
-                        });
-                    }, on_error);
-                }
-            };
-        };
-        p.sequence = (steps) => {
-            return {
-                __start: (on_success, on_error) => {
-                    const length = _ei.array_literal(steps).__get_length();
-                    const runStep = (index) => {
-                        if (index >= length) {
-                            on_success();
-                            return;
-                        }
-                        steps[index].__start(() => runStep(index + 1), on_error);
-                    };
-                    runStep(0);
-                }
-            };
-        };
-        p.array = (the_array, aggregate_exceptions) => {
-            return {
-                __start: (on_success, on_error) => {
-                    const exceptions = [];
-                    (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
-                        the_array.map(($) => {
-                            monitor['report process started']();
-                            $.__start(() => {
-                                monitor['report process finished']();
-                            }, (e) => {
-                                exceptions.push(e);
-                                monitor['report process finished']();
-                            });
-                        });
-                    }, () => {
-                        if (exceptions.length === 0) {
-                            on_success();
-                        }
-                        else {
-                            on_error(aggregate_exceptions(_ei.array_literal(exceptions)));
-                        }
-                    });
-                }
-            };
-        };
-        p.dictionary = (the_dictionary, aggregate_exceptions) => {
-            return {
-                __start: (on_success, on_error) => {
-                    const exceptions = {};
-                    (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) => {
-                                exceptions[key] = e;
-                                monitor['report process finished']();
-                            });
-                        });
-                    }, () => {
-                        if (Object.keys(exceptions).length === 0) {
-                            on_success();
-                        }
-                        else {
-                            on_error(aggregate_exceptions(_ei.dictionary_literal(exceptions)));
-                        }
-                    });
-                }
-            };
-        };
-    })(p = u_1.p || (u_1.p = {}));
-})(u || (exports.u = u = {}));
-var g;
-(function (g_1) {
-    let a;
-    (function (a) {
-        a.g = (action) => ($) => {
-            return (0, initialize_guaranteed_procedure_1.__create_guaranted_procedure)({
-                'execute': (on_finished) => {
-                    action($).__start(on_finished);
-                }
-            });
-        };
-    })(a = g_1.a || (g_1.a = {}));
-    let q;
-    (function (q) {
-        q.fixed = (query_result) => {
-            return {
-                __start: (on_finished) => {
-                    on_finished(query_result);
-                }
-            };
-        };
-        q.g = (the_query, parameters, result_transformation) => {
-            return {
-                __start: (on_finished) => {
-                    parameters.__start((qr_in) => {
-                        the_query(qr_in).__start((result) => {
-                            on_finished(result_transformation(result));
-                        });
-                    });
-                }
-            };
-        };
-    })(q = g_1.q || (g_1.q = {}));
-    let p;
-    (function (p) {
-        p.action = (action, query) => {
-            return {
-                __start: (on_finished) => {
-                    //run the query
-                    query.__start((query_result) => {
-                        //run the action
-                        action(query_result).__start(on_finished);
-                    });
-                }
-            };
-        };
-    })(p = g_1.p || (g_1.p = {}));
-})(g || (exports.g = g = {}));

package/dist/procedure/Guaranteed_Procedure.d.ts

@@ -1,4 +0,0 @@
-export type Guaranteed_Procedure_Initializer<Params> = ($: Params) => Guaranteed_Procedure;
-export interface Guaranteed_Procedure {
-    __start: (on_finished: () => void) => void;
-}