exupery-core-async 0.3.4 → 0.3.6

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

@@ -1,4 +1,4 @@
-import { Guaranteed_Procedure_Promise } from "../../types/Guaranteed_Procedure";
+import * as _et from "exupery-core-types";
 type Executer = {
     'execute': (on_finished: () => void) => void;
 };
@@ -7,5 +7,5 @@ type Executer = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_guaranted_procedure(executer: Executer): Guaranteed_Procedure_Promise;
+export declare function __create_guaranted_procedure(executer: Executer): _et.Guaranteed_Procedure_Promise;
 export {};

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

@@ -1,4 +1,4 @@
-import { Unguaranteed_Procedure_Promise } from "../../types/Unguaranteed_Procedure";
+import * as _et from "exupery-core-types";
 /**
  * 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,5 +13,5 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): Unguaranteed_Procedure_Promise<E>;
+export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): _et.Unguaranteed_Procedure_Promise<E>;
 export {};

package/dist/algorithms/procedure/initialize_unguaranteed_procedure.js

@@ -8,7 +8,7 @@ class Unguaranteed_Procedure_Promise_Class {
     __start(on_success, on_exception) {
         this.executer.execute(on_success, on_exception);
     }
-    transform_error(handle_error) {
+    map_error(handle_error) {
         return new Unguaranteed_Procedure_Promise_Class({
             'execute': (on_success, on_exception) => {
                 this.executer.execute(on_success, (error) => {

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

@@ -1,4 +1,4 @@
-import { Guaranteed_Query_Promise } from "../../types/Guaranteed_Query";
+import * as _et from "exupery-core-types";
 type Executer<T> = {
     'execute': (on_value: ($: T) => void) => void;
 };
@@ -7,5 +7,5 @@ type Executer<T> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_guaranteed_query<T>(executer: Executer<T>): Guaranteed_Query_Promise<T>;
+export declare function __create_guaranteed_query<T>(executer: Executer<T>): _et.Guaranteed_Query_Promise<T>;
 export {};

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

@@ -1,4 +1,4 @@
-import { Unguaranteed_Query_Promise } from "../../types/Unguaranteed_Query";
+import * as _et from "exupery-core-types";
 /**
  * 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,5 +13,5 @@ type Executer<T, E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_unguaranteed_query<T, E>(executer: Executer<T, E>): Unguaranteed_Query_Promise<T, E>;
+export declare function __create_unguaranteed_query<T, E>(executer: Executer<T, E>): _et.Unguaranteed_Query_Promise<T, E>;
 export {};

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

@@ -1,6 +1,6 @@
-import { Guaranteed_Query_Promise } from "../../types/Guaranteed_Query";
+import * as _et from 'exupery-core-types';
 export type Sync_Tuple_2<T1, T2> = {
     readonly 'first': T1;
     readonly 'second': T2;
 };
-export declare function merge_2_unguaranteed_queries<T1, T2>(first: Guaranteed_Query_Promise<T1>, second: Guaranteed_Query_Promise<T2>): Guaranteed_Query_Promise<Sync_Tuple_2<T1, T2>>;
+export declare function merge_2_unguaranteed_queries<T1, T2>(first: _et.Guaranteed_Query_Promise<T1>, second: _et.Guaranteed_Query_Promise<T2>): _et.Guaranteed_Query_Promise<Sync_Tuple_2<T1, T2>>;

package/dist/index.d.ts

@@ -1,21 +1,18 @@
-export * from "./types/Guaranteed_Procedure";
-export * from "./types/Unguaranteed_Procedure";
-export * from "./types/Unguaranteed_Query";
-export * from "./types/Guaranteed_Query";
+import * as _et from "exupery-core-types";
+export * from "./types/Basic_Unguaranteed_Query";
+export * from "./types/Basic_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_Query_Promise } from "./types/Guaranteed_Query";
-import { Unguaranteed_Query_Promise } from "./types/Unguaranteed_Query";
 export declare const query: {
     guaranteed: {
-        'create result': <T>($: T) => Guaranteed_Query_Promise<T>;
+        'create result': <T>($: T) => _et.Guaranteed_Query_Promise<T>;
     };
     unguaranteed: {
-        'create result': <T, E>($: T) => Unguaranteed_Query_Promise<T, E>;
-        'raise exception': <T, E>($: E) => Unguaranteed_Query_Promise<T, E>;
+        'create result': <T, E>($: T) => _et.Unguaranteed_Query_Promise<T, E>;
+        'raise exception': <T, E>($: E) => _et.Unguaranteed_Query_Promise<T, E>;
     };
 };

package/dist/index.js

@@ -16,10 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 //types
-__exportStar(require("./types/Guaranteed_Procedure"), exports);
-__exportStar(require("./types/Unguaranteed_Procedure"), exports);
-__exportStar(require("./types/Unguaranteed_Query"), exports);
-__exportStar(require("./types/Guaranteed_Query"), exports);
+__exportStar(require("./types/Basic_Unguaranteed_Query"), exports);
+__exportStar(require("./types/Basic_Guaranteed_Query"), exports);
 //functions
 __exportStar(require("./algorithms/query/merge_2_guaranteed_queries"), exports);
 __exportStar(require("./algorithms/query/create_guaranteed_query"), exports);

package/dist/shorthands.d.ts

@@ -1,18 +1,13 @@
-import * as _ei from 'exupery-core-internals';
 import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from "./types/Unguaranteed_Query";
-import { Basic_Guaranteed_Query_Promise } from "./types/Guaranteed_Query";
-import { Guaranteed_Procedure_Promise, Guaranteed_Procedure } from "./types/Guaranteed_Procedure";
-import { Unguaranteed_Procedure, Unguaranteed_Procedure_Promise } from "./types/Unguaranteed_Procedure";
-import { Unguaranteed_Query } from "./types/Unguaranteed_Query";
-import { Guaranteed_Query } from "./types/Guaranteed_Query";
+import { Basic_Unguaranteed_Query_Promise } from "./types/Basic_Unguaranteed_Query";
+import { Basic_Guaranteed_Query_Promise } from "./types/Basic_Guaranteed_Query";
 import { Error_Handler } from "./types/Error_Handler";
 /**
  *
  * @param action gpi
  * @param error_transform gt
  */
-export declare const eh: <Parameters, Error, Resources>(action: Guaranteed_Procedure<Parameters, Resources>, error_transform: _ei.Transformation_Without_Parameters<Error, Parameters>, resources: Resources) => Error_Handler<Error>;
+export declare const eh: <Parameters, Error, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, error_transform: _et.Transformer_Without_Parameters<Error, Parameters>, resources: Resources) => Error_Handler<Error>;
 export declare namespace gp {
     /**
      *
@@ -20,7 +15,7 @@ export declare namespace gp {
      * @param query g.q
      * @returns
      */
-    const action: <Parameters, Resources>(action: Guaranteed_Procedure<Parameters, Resources>, query: Basic_Guaranteed_Query_Promise<Parameters>, $r: Resources) => Guaranteed_Procedure_Promise;
+    const action: <Parameters, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, query: Basic_Guaranteed_Query_Promise<Parameters>, $r: Resources) => _et.Guaranteed_Procedure_Promise;
 }
 export declare namespace gq {
     /**
@@ -36,7 +31,7 @@ export declare namespace gq {
      * @param result_transformation gt
      * @returns
      */
-    const g: <Result_After_Transformation, Parameters, Query_Result, Resources>(the_query: Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Guaranteed_Query_Promise<Parameters>, result_transformation: _ei.Transformation_Without_Parameters<Query_Result, Result_After_Transformation>, resources: Resources) => Basic_Guaranteed_Query_Promise<Result_After_Transformation>;
+    const g: <Result_After_Transformation, Parameters, Query_Result, Resources>(the_query: _et.Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Guaranteed_Query_Promise<Parameters>, result_transformation: _et.Transformer_Without_Parameters<Query_Result, Result_After_Transformation>, resources: Resources) => Basic_Guaranteed_Query_Promise<Result_After_Transformation>;
 }
 export declare namespace gt {
     /**
@@ -44,7 +39,7 @@ export declare namespace gt {
      * @param the_transformation gt
      * @returns
      */
-    const g: <In, Out>(the_transformation: _ei.Transformation_Without_Parameters<In, Out>) => _ei.Transformation_Without_Parameters<In, Out>;
+    const g: <In, Out>(the_transformation: _et.Transformer_Without_Parameters<In, Out>) => _et.Transformer_Without_Parameters<In, Out>;
 }
 export declare namespace up {
     /**
@@ -52,39 +47,39 @@ export declare namespace up {
      * @param action upi
      * @param query u.q
      */
-    const action: <Error, Parameters, Resources>(action: Unguaranteed_Procedure<Parameters, Error, Resources>, query: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources) => Unguaranteed_Procedure_Promise<Error>;
+    const action: <Error, Parameters, Resources>(action: _et.Unguaranteed_Procedure<Parameters, Error, Resources>, query: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources) => _et.Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param steps up[]
      * @returns
      */
-    const sequence: <Error>(steps: Unguaranteed_Procedure_Promise<Error>[]) => Unguaranteed_Procedure_Promise<Error>;
+    const sequence: <Error>(steps: _et.Unguaranteed_Procedure_Promise<Error>[]) => _et.Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param the_array up[]
      * @param aggregate_exceptions gt
      * @returns
      */
-    const array: <Error, Element_Error>(the_array: _et.Array<Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Array<Element_Error>, Error>) => Unguaranteed_Procedure_Promise<Error>;
+    const array: <Error, Element_Error>(the_array: _et.Array<_et.Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Array<Element_Error>, Error>) => _et.Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param the_dictionary dict<up>
      * @param aggregate_exceptions gt
      * @returns
      */
-    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => Unguaranteed_Procedure_Promise<Error>;
+    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => _et.Unguaranteed_Procedure_Promise<Error>;
 }
 export declare namespace upi {
     /**
      *
      * @param action gpi
      */
-    const g: <Parameters, Error, Resources>(action: Guaranteed_Procedure<Parameters, Resources>, $r: Resources) => Unguaranteed_Procedure<Parameters, Error, Resources>;
+    const g: <Parameters, Error, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, $r: Resources) => _et.Unguaranteed_Procedure<Parameters, Error, Resources>;
     /**
      *
      * @param action upi
      */
-    const u: <Parameters, Error, Action_Error, Resources>(action: Unguaranteed_Procedure<Parameters, Action_Error, Resources>, error_transform: _ei.Transformation_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => Unguaranteed_Procedure<Parameters, Error, Resources>;
+    const u: <Parameters, Error, Action_Error, Resources>(action: _et.Unguaranteed_Procedure<Parameters, Action_Error, Resources>, error_transform: _et.Transformer_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => _et.Unguaranteed_Procedure<Parameters, Error, Resources>;
 }
 export declare namespace uq {
     /**
@@ -102,14 +97,14 @@ export declare namespace uq {
      * @param error_handler eh
      * @returns
      */
-    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error, Resources>(the_query: Unguaranteed_Query<Parameters, Query_Result, Query_Error, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _ei.Transformation_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
+    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error, Resources>(the_query: _et.Unguaranteed_Query<Parameters, Query_Result, Query_Error, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources, result_refinement: _et.Refiner_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _et.Transformer_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
     /**
      * guaranteed query
      * @param the_query gqi
      * @param parameters u.q
      * @param result_refinement ut
      */
-    const g: <Result_After_Transformation, Error, Parameters, Query_Result, Resources>(the_query: Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>, resources: Resources) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
+    const g: <Result_After_Transformation, Error, Parameters, Query_Result, Resources>(the_query: _et.Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, result_refinement: _et.Refiner_Without_Parameters<Query_Result, Result_After_Transformation, Error>, resources: Resources) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
 }
 export declare namespace ut {
     /**
@@ -119,10 +114,10 @@ export declare namespace ut {
      * @param error_handler  eh
      * @returns
      */
-    const u: <In, Out, Error, Transformation_Error>(the_refinement: _ei.Refinement_Without_Parameters<In, Out, Transformation_Error>, error_transform: _ei.Transformation_Without_Parameters<Transformation_Error, Error>, error_handler?: Error_Handler<Transformation_Error>) => _ei.Refinement_Without_Parameters<In, Out, Error>;
+    const u: <In, Out, Error, Transformation_Error>(the_refinement: _et.Refiner_Without_Parameters<In, Out, Transformation_Error>, error_transform: _et.Transformer_Without_Parameters<Transformation_Error, Error>, error_handler?: Error_Handler<Transformation_Error>) => _et.Refiner_Without_Parameters<In, Out, Error>;
     /**
      *
      * @param the_transformation gt
      */
-    const g: <In, Out, Error>(the_transformation: _ei.Transformation_Without_Parameters<In, Out>) => _ei.Refinement_Without_Parameters<In, Out, Error>;
+    const g: <In, Out, Error>(the_transformation: _et.Transformer_Without_Parameters<In, Out>) => _et.Refiner_Without_Parameters<In, Out, Error>;
 }

package/dist/types/Basic_Guaranteed_Query.d.ts

@@ -0,0 +1,3 @@
+export type Basic_Guaranteed_Query_Promise<Result> = {
+    __start: (on_finished: (result: Result) => void) => void;
+};

package/dist/types/Basic_Unguaranteed_Query.d.ts

@@ -0,0 +1,3 @@
+export type Basic_Unguaranteed_Query_Promise<Result, Error> = {
+    __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-async",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "async types for Exupery",
@@ -22,6 +22,6 @@
     "url": "git+https://github.com/corno/exupery-core.git"
   },
   "dependencies": {
-    "exupery-core-internals": "^0.3.0"
+    "exupery-core-internals": "^0.3.1"
   }
 }

package/dist/types/Guaranteed_Procedure.d.ts

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

package/dist/types/Guaranteed_Query.d.ts

@@ -1,20 +0,0 @@
-export type Guaranteed_Query<Parameters, Result, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Query_Promise<Result>;
-/**
- * A value that will asynchronously become available.
- * Similar to the concept of a promise, but with a smaller API.
- */
-export type Guaranteed_Query_Promise<Result> = {
-    map<NT>(handle_value: ($: Result) => NT): Guaranteed_Query_Promise<NT>;
-    /**
-     * maps the current async value into a new async value
-     * @param handle_value callback that transforms the actual value into a new Async_Value
-     */
-    then<NT>(handle_value: ($: Result) => Guaranteed_Query_Promise<NT>): Guaranteed_Query_Promise<NT>;
-    /**
-     * This method is only to be used by resources
-     */
-    __start(on_finished: ($: Result) => void): void;
-};
-export type Basic_Guaranteed_Query_Promise<Result> = {
-    __start: (on_finished: (result: Result) => void) => void;
-};

package/dist/types/Unguaranteed_Procedure.d.ts

@@ -1,5 +0,0 @@
-export type Unguaranteed_Procedure<Parameters, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Procedure_Promise<Error>;
-export type Unguaranteed_Procedure_Promise<Error> = {
-    __start: (on_success: () => void, on_error: (error: Error) => void) => void;
-    transform_error<NE>(handle_error: (error: Error) => NE): Unguaranteed_Procedure_Promise<NE>;
-};

package/dist/types/Unguaranteed_Procedure.js

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

package/dist/types/Unguaranteed_Query.d.ts

@@ -1,13 +0,0 @@
-import { Guaranteed_Query_Promise } from "./Guaranteed_Query";
-export type Unguaranteed_Query<Parameters, Result, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Query_Promise<Result, Error>;
-export type Unguaranteed_Query_Promise<Result, Error> = {
-    map_<NT>(handle_value: ($: Result) => NT): Unguaranteed_Query_Promise<NT, Error>;
-    map_exception_<NE>(handle_exception: ($: Error) => NE): Unguaranteed_Query_Promise<Result, NE>;
-    then<NT>(handle_value: ($: Result) => Guaranteed_Query_Promise<NT>): Unguaranteed_Query_Promise<NT, Error>;
-    then_unguaranteed<NT>(handle_value: ($: Result) => Unguaranteed_Query_Promise<NT, Error>): Unguaranteed_Query_Promise<NT, Error>;
-    catch_(handle_exception: ($: Error) => Guaranteed_Query_Promise<Result>): Guaranteed_Query_Promise<Result>;
-    __start(on_success: ($: Result) => void, on_error: ($: Error) => void): void;
-};
-export type Basic_Unguaranteed_Query_Promise<Result, Error> = {
-    __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
-};

package/dist/types/Unguaranteed_Query.js

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