exupery-core-async 0.1.24 → 0.1.25

package/dist/Safe_Procedure_Context.d.ts

@@ -0,0 +1,4 @@
+export interface Safe_Procedure_Context {
+    execute(handle: ($i: Safe_Procedure_Context) => Safe_Procedure_Context): Safe_Procedure_Context;
+    __start(on_finished: () => void): void;
+}

package/dist/Safe_Query_Result.d.ts

@@ -1,5 +1,5 @@
-import { Safe_Command_Result } from "./Safe_Command_Result";
-import { Unsafe_Command_Result } from "./Unsafe_Command_Result";
+import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
+import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
 /**
  * A value that will asynchronously become available.
  * Similar to the concept of a promise, but with a smaller API.
@@ -11,8 +11,8 @@ export interface Safe_Query_Result<T> {
      * @param handle_value callback that transforms the actual value into a new Async_Value
      */
     then<NT>(handle_value: ($: T) => Safe_Query_Result<NT>): Safe_Query_Result<NT>;
-    process_safe(handle_value: ($i: Safe_Command_Result, $: T) => Safe_Command_Result): Safe_Command_Result;
-    process_unsafe<E>(handle_value: ($i: Unsafe_Command_Result<E>, $: T) => Unsafe_Command_Result<E>): Unsafe_Command_Result<E>;
+    process_safe(handle_value: ($i: Safe_Procedure_Context, $: T) => Safe_Procedure_Context): Safe_Procedure_Context;
+    process_unsafe<E>(handle_value: ($i: Unsafe_Procedure_Context<E>, $: T) => Unsafe_Procedure_Context<E>): Unsafe_Procedure_Context<E>;
     /**
      * This method is only to be used by resources
      */

package/dist/Unsafe_Procedure_Context.d.ts

@@ -0,0 +1,24 @@
+import * as _et from 'exupery-core-types';
+import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
+export interface Unsafe_Procedure_Context<E> {
+    /**
+     *
+     * executes a command when an exception has occurred,
+     * but stays in the unsafe context
+     *
+     * this is useful when you want to do some cleanup
+     * or logging in case of an exception,
+     * but still want to propagate the exception further
+     *
+     * note that this is different from `catch`,
+     * which would switch to the safe context
+     */
+    process_exception<NE>(handle: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context, map: ($: E) => NE): Unsafe_Procedure_Context<NE>;
+    throw_exception<E>($: E): Unsafe_Procedure_Context<E>;
+    catch(handle_exception: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context): Safe_Procedure_Context;
+    execute_unsafe(handle: ($i: Unsafe_Procedure_Context<E>) => Unsafe_Procedure_Context<E>): Unsafe_Procedure_Context<E>;
+    execute(handle: ($i: Safe_Procedure_Context) => Safe_Procedure_Context): Unsafe_Procedure_Context<E>;
+    execute_dictionary_unsafe<E2>($: _et.Dictionary<Unsafe_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Unsafe_Procedure_Context<E>;
+    execute_multiple_unsafe<E2>($: _et.Array<Unsafe_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Array<E2>) => E): Unsafe_Procedure_Context<E>;
+    __start(on_success: () => void, on_exception: ($: E) => void): void;
+}

package/dist/Unsafe_Query_Result.d.ts

@@ -1,6 +1,6 @@
-import { Safe_Command_Result } from "./Safe_Command_Result";
+import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
 import { Safe_Query_Result } from "./Safe_Query_Result";
-import { Unsafe_Command_Result } from "./Unsafe_Command_Result";
+import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
 export interface Unsafe_Query_Result<T, E> {
     map<NT>(handle_value: ($: T) => NT): Unsafe_Query_Result<NT, E>;
     map_exception<NE>(handle_exception: ($: E) => NE): Unsafe_Query_Result<T, NE>;
@@ -19,6 +19,6 @@ export interface Unsafe_Query_Result<T, E> {
      * @param map_exception the handler that will map the exception of the query into a new exception value of the command's exception type
      *
      */
-    process<NE>(handle_exception: ($i: Safe_Command_Result, $: E) => Safe_Command_Result, map_exception: ($: E) => NE, handle_value: ($i: Unsafe_Command_Result<NE>, $: T) => Unsafe_Command_Result<NE>): Unsafe_Command_Result<NE>;
+    process<NE>(handle_exception: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context, map_exception: ($: E) => NE, handle_value: ($i: Unsafe_Procedure_Context<NE>, $: T) => Unsafe_Procedure_Context<NE>): Unsafe_Procedure_Context<NE>;
     __start(on_value: ($: T) => void, on_exception: ($: E) => void): void;
 }

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./Safe_Command_Result";
-export * from "./Unsafe_Command_Result";
+export * from "./Safe_Procedure_Context";
+export * from "./Unsafe_Procedure_Context";
 export * from "./Safe_Query_Result";
 export * from "./Unsafe_Query_Result";
 export * from "./merge_2_safe_query_results";
 export * from "./run_safe_query";
 export * from "./run_unsafe_query";
-export * from "./execute_safe_command";
-export * from "./execute_unsafe_command";
-import { Safe_Command_Result } from "./Safe_Command_Result";
-import { Unsafe_Command_Result } from "./Unsafe_Command_Result";
+export * from "./initialize_safe_procedure_context";
+export * from "./initialize_unsafe_procedure_context";
+import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
+import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
 import { Safe_Query_Result } from "./Safe_Query_Result";
 import { Unsafe_Query_Result } from "./Unsafe_Query_Result";
 export declare const query: {
@@ -22,10 +22,10 @@ export declare const query: {
 };
 export declare const command: {
     safe: {
-        initialize: () => Safe_Command_Result;
+        initialize: () => Safe_Procedure_Context;
     };
     unsafe: {
-        initialize: <E>() => Unsafe_Command_Result<E>;
-        'raise exception': <E>($: E) => Unsafe_Command_Result<E>;
+        initialize: <E>() => Unsafe_Procedure_Context<E>;
+        'raise exception': <E>($: E) => Unsafe_Procedure_Context<E>;
     };
 };

package/dist/index.js

@@ -15,17 +15,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = exports.query = void 0;
-__exportStar(require("./Safe_Command_Result"), exports);
-__exportStar(require("./Unsafe_Command_Result"), exports);
+__exportStar(require("./Safe_Procedure_Context"), exports);
+__exportStar(require("./Unsafe_Procedure_Context"), exports);
 __exportStar(require("./Safe_Query_Result"), exports);
 __exportStar(require("./Unsafe_Query_Result"), exports);
 __exportStar(require("./merge_2_safe_query_results"), exports);
 __exportStar(require("./run_safe_query"), exports);
 __exportStar(require("./run_unsafe_query"), exports);
-__exportStar(require("./execute_safe_command"), exports);
-__exportStar(require("./execute_unsafe_command"), exports);
-const execute_safe_command_1 = require("./execute_safe_command");
-const execute_unsafe_command_1 = require("./execute_unsafe_command");
+__exportStar(require("./initialize_safe_procedure_context"), exports);
+__exportStar(require("./initialize_unsafe_procedure_context"), exports);
+const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
+const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
 const run_safe_query_1 = require("./run_safe_query");
 const run_unsafe_query_1 = require("./run_unsafe_query");
 exports.query = {
@@ -57,12 +57,12 @@ exports.query = {
 };
 exports.command = {
     'safe': {
-        'initialize': execute_safe_command_1.initialize_safe_command
+        'initialize': initialize_safe_procedure_context_1.initialize_safe_procedure_context
     },
     'unsafe': {
-        'initialize': execute_unsafe_command_1.initialize_unsafe_command,
+        'initialize': initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context,
         'raise exception': ($) => {
-            return (0, execute_unsafe_command_1.__execute_unsafe_command)({
+            return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
                 'execute': (on_success, on_exception) => {
                     on_exception($);
                 }

package/dist/initialize_safe_procedure_context.d.ts

@@ -0,0 +1,12 @@
+import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
+type Executer = {
+    'execute': (on_finished: () => void) => void;
+};
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+export declare function __execute_safe_action(executer: Executer): Safe_Procedure_Context;
+export declare const initialize_safe_procedure_context: () => Safe_Procedure_Context;
+export {};

package/dist/{execute_safe_command.js → initialize_safe_procedure_context.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_safe_command = void 0;
-exports.__execute_safe_command = __execute_safe_command;
+exports.initialize_safe_procedure_context = void 0;
+exports.__execute_safe_action = __execute_safe_action;
 class Safe_Command_Result_Class {
     constructor(executer) {
         this.executer = executer;
     }
     execute(handle) {
-        return __execute_safe_command({
+        return __execute_safe_action({
             'execute': (on_finished) => {
                 this.executer.execute(() => {
-                    handle((0, exports.initialize_safe_command)()).__start(on_finished);
+                    handle((0, exports.initialize_safe_procedure_context)()).__start(on_finished);
                 });
             }
         });
@@ -24,14 +24,14 @@ class Safe_Command_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __execute_safe_command(executer) {
+function __execute_safe_action(executer) {
     return new Safe_Command_Result_Class(executer);
 }
-const initialize_safe_command = () => {
-    return __execute_safe_command({
-        'execute': (on_success) => {
-            on_success();
+const initialize_safe_procedure_context = () => {
+    return new Safe_Command_Result_Class({
+        'execute': (on_finished) => {
+            on_finished(); //nothing to do, call on_finished immediately
         }
     });
 };
-exports.initialize_safe_command = initialize_safe_command;
+exports.initialize_safe_procedure_context = initialize_safe_procedure_context;

package/dist/{execute_unsafe_command.d.ts → initialize_unsafe_procedure_context.d.ts}

@@ -1,4 +1,4 @@
-import { Unsafe_Command_Result } from "./Unsafe_Command_Result";
+import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
 /**
  * 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
@@ -13,6 +13,6 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __execute_unsafe_command<E>(executer: Executer<E>): Unsafe_Command_Result<E>;
-export declare const initialize_unsafe_command: <E>() => Unsafe_Command_Result<E>;
+export declare function __execute_unsafe_action<E>(executer: Executer<E>): Unsafe_Procedure_Context<E>;
+export declare const initialize_unsafe_procedure_context: <E>() => Unsafe_Procedure_Context<E>;
 export {};

package/dist/{execute_unsafe_command.js → initialize_unsafe_procedure_context.js}

@@ -23,10 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_unsafe_command = void 0;
-exports.__execute_unsafe_command = __execute_unsafe_command;
+exports.initialize_unsafe_procedure_context = void 0;
+exports.__execute_unsafe_action = __execute_unsafe_action;
 const _ei = __importStar(require("exupery-core-internals"));
-const execute_safe_command_1 = require("./execute_safe_command");
+const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
 const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
 class Unsafe_Command_Result_Class {
     constructor(executer) {
@@ -36,22 +36,22 @@ class Unsafe_Command_Result_Class {
         return new Unsafe_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(new_on_success, ($) => {
-                    handle((0, execute_safe_command_1.initialize_safe_command)(), $).__start(() => new_on_exception(map($)));
+                    handle((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), $).__start(() => new_on_exception(map($)));
                 });
             }
         });
     }
     catch(handle_exception) {
-        return (0, execute_safe_command_1.__execute_safe_command)({
+        return (0, initialize_safe_procedure_context_1.__execute_safe_action)({
             'execute': (new_on_success) => {
                 this.executer.execute(new_on_success, ($) => {
-                    handle_exception((0, execute_safe_command_1.initialize_safe_command)(), $).__start(new_on_success);
+                    handle_exception((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), $).__start(new_on_success);
                 });
             }
         });
     }
     throw_exception($) {
-        return __execute_unsafe_command({
+        return __execute_unsafe_action({
             'execute': (on_finished, on_exception) => {
                 this.executer.execute(() => {
                     on_exception($);
@@ -63,7 +63,7 @@ class Unsafe_Command_Result_Class {
         return new Unsafe_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(() => {
-                    handle((0, exports.initialize_unsafe_command)()).__start(new_on_success, new_on_exception);
+                    handle((0, exports.initialize_unsafe_procedure_context)()).__start(new_on_success, new_on_exception);
                 }, new_on_exception);
             }
         });
@@ -72,14 +72,14 @@ class Unsafe_Command_Result_Class {
         return new Unsafe_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(() => {
-                    handle((0, execute_safe_command_1.initialize_safe_command)()).__start(new_on_success);
+                    handle((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)()).__start(new_on_success);
                 }, new_on_exception);
             }
         });
     }
     execute_dictionary_unsafe($, aggregate_exceptions) {
         let exceptions = {};
-        return __execute_unsafe_command({
+        return __execute_unsafe_action({
             'execute': (on_success, on_exception) => {
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     $.map(($, key) => {
@@ -104,7 +104,7 @@ class Unsafe_Command_Result_Class {
     }
     execute_multiple_unsafe($, aggregate_exceptions) {
         let exceptions = [];
-        return __execute_unsafe_command({
+        return __execute_unsafe_action({
             'execute': (on_success, on_exception) => {
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     $.map(($) => {
@@ -136,14 +136,14 @@ class Unsafe_Command_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __execute_unsafe_command(executer) {
+function __execute_unsafe_action(executer) {
     return new Unsafe_Command_Result_Class(executer);
 }
-const initialize_unsafe_command = () => {
-    return __execute_unsafe_command({
-        'execute': (on_success) => {
-            on_success();
+const initialize_unsafe_procedure_context = () => {
+    return new Unsafe_Command_Result_Class({
+        'execute': (on_success, on_exception) => {
+            on_success(); //nothing to do, call on_finished immediately
         }
     });
 };
-exports.initialize_unsafe_command = initialize_unsafe_command;
+exports.initialize_unsafe_procedure_context = initialize_unsafe_procedure_context;

package/dist/run_safe_query.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__run_safe_query = __run_safe_query;
-const execute_safe_command_1 = require("./execute_safe_command");
-const execute_unsafe_command_1 = require("./execute_unsafe_command");
+const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
+const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
 class Safe_Query_Result_Class {
     constructor(executer) {
         this.executer = executer;
@@ -26,19 +26,19 @@ class Safe_Query_Result_Class {
         });
     }
     process_safe(handle_value) {
-        return (0, execute_safe_command_1.__execute_safe_command)({
+        return (0, initialize_safe_procedure_context_1.__execute_safe_action)({
             'execute': (on_success) => {
                 this.executer.execute((value) => {
-                    handle_value((0, execute_safe_command_1.initialize_safe_command)(), value).__start(on_success);
+                    handle_value((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), value).__start(on_success);
                 });
             }
         });
     }
     process_unsafe(handle_value) {
-        return (0, execute_unsafe_command_1.__execute_unsafe_command)({
+        return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
             'execute': (on_success, on_exception) => {
                 this.executer.execute((value) => {
-                    handle_value((0, execute_unsafe_command_1.initialize_unsafe_command)(), value).__start(on_success, on_exception);
+                    handle_value((0, initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context)(), value).__start(on_success, on_exception);
                 });
             }
         });

package/dist/run_unsafe_query.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__run_unsafe_query = __run_unsafe_query;
 const run_safe_query_1 = require("./run_safe_query");
-const execute_safe_command_1 = require("./execute_safe_command");
-const execute_unsafe_command_1 = require("./execute_unsafe_command");
+const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
+const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
 class Unsafe_Query_Result_Class {
     constructor(executer) {
         this.executer = executer;
@@ -45,12 +45,12 @@ class Unsafe_Query_Result_Class {
         });
     }
     process(handle_exception, map_exception, handle_value) {
-        return (0, execute_unsafe_command_1.__execute_unsafe_command)({
+        return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
             'execute': (on_success, on_exception) => {
                 this.executer.execute((value) => {
-                    handle_value((0, execute_unsafe_command_1.initialize_unsafe_command)(), value).__start(on_success, on_exception);
+                    handle_value((0, initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context)(), value).__start(on_success, on_exception);
                 }, (exception) => {
-                    handle_exception((0, execute_safe_command_1.initialize_safe_command)(), exception).__start(() => on_exception(map_exception(exception)));
+                    handle_exception((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), exception).__start(() => on_exception(map_exception(exception)));
                 });
             }
         });

package/package.json

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

package/dist/Safe_Command_Result.d.ts

@@ -1,4 +0,0 @@
-export interface Safe_Command_Result {
-    execute(handle: ($i: Safe_Command_Result) => Safe_Command_Result): Safe_Command_Result;
-    __start(on_finished: () => void): void;
-}

package/dist/Unsafe_Command_Result.d.ts

@@ -1,24 +0,0 @@
-import * as _et from 'exupery-core-types';
-import { Safe_Command_Result } from "./Safe_Command_Result";
-export interface Unsafe_Command_Result<E> {
-    /**
-     *
-     * executes a command when an exception has occurred,
-     * but stays in the unsafe context
-     *
-     * this is useful when you want to do some cleanup
-     * or logging in case of an exception,
-     * but still want to propagate the exception further
-     *
-     * note that this is different from `catch`,
-     * which would switch to the safe context
-     */
-    process_exception<NE>(handle: ($i: Safe_Command_Result, $: E) => Safe_Command_Result, map: ($: E) => NE): Unsafe_Command_Result<NE>;
-    throw_exception<E>($: E): Unsafe_Command_Result<E>;
-    catch(handle_exception: ($i: Safe_Command_Result, $: E) => Safe_Command_Result): Safe_Command_Result;
-    execute_unsafe(handle: ($i: Unsafe_Command_Result<E>) => Unsafe_Command_Result<E>): Unsafe_Command_Result<E>;
-    execute(handle: ($i: Safe_Command_Result) => Safe_Command_Result): Unsafe_Command_Result<E>;
-    execute_dictionary_unsafe<E2>($: _et.Dictionary<Unsafe_Command_Result<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Unsafe_Command_Result<E>;
-    execute_multiple_unsafe<E2>($: _et.Array<Unsafe_Command_Result<E2>>, aggregate_exceptions: ($: _et.Array<E2>) => E): Unsafe_Command_Result<E>;
-    __start(on_success: () => void, on_exception: ($: E) => void): void;
-}

package/dist/execute_safe_command.d.ts

@@ -1,12 +0,0 @@
-import { Safe_Command_Result } from "./Safe_Command_Result";
-type Executer = {
-    'execute': (on_finished: () => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function __execute_safe_command(executer: Executer): Safe_Command_Result;
-export declare const initialize_safe_command: () => Safe_Command_Result;
-export {};