exupery-core-types 0.3.58 → 0.3.59

package/dist/algorithm/Command.d.ts

@@ -1,7 +1,7 @@
-import { Transformer_New } from "./Transformer";
+import { Transformer } from "./Transformer";
 export type Command_Procedure<Error, Parameters, Command_Resources, Query_Resources> = ($c: Command_Resources, $q: Query_Resources) => Command<Error, Parameters>;
 export type Command<Error, Parameters> = {
-    'execute': <Target_Error>(parameters: Parameters, error_transformer: Transformer_New<Error, Target_Error>) => Command_Promise<Target_Error>;
+    'execute': <Target_Error>(parameters: Parameters, error_transformer: Transformer<Error, Target_Error>) => Command_Promise<Target_Error>;
 };
 export type Command_Promise<Error> = {
     __start: (on_success: () => void, on_error: (error: Error) => void) => void;

package/dist/algorithm/Deserializer.d.ts

@@ -0,0 +1,2 @@
+export type Refiner_With_Parameters<Result, Error, Input, Parameters> = ($: Input, $p: Parameters, abort: ($: Error) => never) => Result;
+export type Refiner<Result, Error, Input> = ($: Input, abort: ($: Error) => never) => Result;

package/dist/algorithm/Deserializer.js

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

package/dist/algorithm/Query.d.ts

@@ -1,3 +1,3 @@
 import { Query_Result } from "./Query_Result";
-import { Transformer_New } from "./Transformer";
-export type Query<Output, Error, Input> = <Target_Error>($: Input, error_transformer: Transformer_New<Error, Target_Error>) => Query_Result<Output, Target_Error>;
+import { Transformer } from "./Transformer";
+export type Query<Output, Error, Input> = <Target_Error>($: Input, error_transformer: Transformer<Error, Target_Error>) => Query_Result<Output, Target_Error>;

package/dist/algorithm/Query_Result.d.ts

@@ -1,26 +1,26 @@
 import { Queryer } from "./Queryer";
-import { Refiner_Old } from "./Refiner";
-import { Transformer_New } from "./Transformer";
+import { Deprecated_Refiner_Catcher } from "./Refinement_Result";
+import { Transformer } from "./Transformer";
 export interface Query_Result<Output, Error> {
     query_result: null;
-    transform_result<New_Output>(transformer: Transformer_New<Output, New_Output>): Query_Result<New_Output, Error>;
-    deprecated_transform_error<New_Error>(error_transformer: Transformer_New<Error, New_Error>): Query_Result<Output, New_Error>;
+    transform_result<New_Output>(transformer: Transformer<Output, New_Output>): Query_Result<New_Output, Error>;
+    deprecated_transform_error<New_Error>(error_transformer: Transformer<Error, New_Error>): Query_Result<Output, New_Error>;
     query_without_error_transformation<New_Output>(query: Queryer<New_Output, Error, Output>): Query_Result<New_Output, Error>;
     query<New_Output, Query_Error>(query: Queryer<New_Output, Query_Error, Output>, 
     /**
      * if the query fails, rework its error into the desired error type
      */
-    error_transformer: Transformer_New<Query_Error, Error>): Query_Result<New_Output, Error>;
-    refine_without_error_transformation<New_Output>(refiner: Refiner_Old<New_Output, Error, Output>): Query_Result<New_Output, Error>;
-    refine<New_Output, Refiner_Error>(refiner: Refiner_Old<New_Output, Refiner_Error, Output>, 
+    error_transformer: Transformer<Query_Error, Error>): Query_Result<New_Output, Error>;
+    deprecated_refine_old_without_error_transformation<New_Output>(refiner: Deprecated_Refiner_Catcher<New_Output, Error, Output>): Query_Result<New_Output, Error>;
+    deprecated_refine_old<New_Output, Refiner_Error>(refiner: Deprecated_Refiner_Catcher<New_Output, Refiner_Error, Output>, 
     /**
      * if the refiner fails, rework its error into the desired error type
      */
-    error_transformer: Transformer_New<Refiner_Error, Error>): Query_Result<New_Output, Error>;
+    error_transformer: Transformer<Refiner_Error, Error>): Query_Result<New_Output, Error>;
     rework_error_temp<New_Error, Rework_Error>(error_reworker: Queryer<New_Error, Rework_Error, Error>, 
     /**
      * if the reworker fails, we need to transform *that* error into the New_Error
      */
-    rework_error_transformer: Transformer_New<Rework_Error, New_Error>): Query_Result<Output, New_Error>;
+    rework_error_transformer: Transformer<Rework_Error, New_Error>): Query_Result<Output, New_Error>;
     __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
 }

package/dist/algorithm/Refinement_Result.d.ts

@@ -1,13 +1,13 @@
-import { Refiner_Old } from "./Refiner";
-import { Transformer_New } from "./Transformer";
+import { Transformer } from "./Transformer";
 export interface Refinement_Result<Output, Error> {
-    transform<Target>(output_transformer: Transformer_New<Output, Target>, error_transformer: Transformer_New<Error, Target>): Target;
-    transform_result<New_Output>(transformer: Transformer_New<Output, New_Output>): Refinement_Result<New_Output, Error>;
-    deprecated_transform_error<New_Error>(error_transformer: Transformer_New<Error, New_Error>): Refinement_Result<Output, New_Error>;
-    refine<New_Output, Refiner_Error>(refiner: Refiner_Old<New_Output, Refiner_Error, Output>, 
+    transform<Target>(output_transformer: Transformer<Output, Target>, error_transformer: Transformer<Error, Target>): Target;
+    transform_result<New_Output>(transformer: Transformer<Output, New_Output>): Refinement_Result<New_Output, Error>;
+    deprecated_transform_error<New_Error>(error_transformer: Transformer<Error, New_Error>): Refinement_Result<Output, New_Error>;
+    deprecated_refine_old<New_Output, Refiner_Error>(refiner: Deprecated_Refiner_Catcher<New_Output, Refiner_Error, Output>, 
     /**
      * if the refiner fails, rework its error into the desired error type
      */
-    error_transformer: Transformer_New<Refiner_Error, Error>): Refinement_Result<New_Output, Error>;
+    error_transformer: Transformer<Refiner_Error, Error>): Refinement_Result<New_Output, Error>;
     __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
 }
+export type Deprecated_Refiner_Catcher<Result, Error, Input> = ($: Input) => Refinement_Result<Result, Error>;

package/dist/algorithm/Refiner.d.ts

@@ -1,4 +1,2 @@
-import { Refinement_Result } from "./Refinement_Result";
-export type Refiner_Old<Result, Error, Input> = ($: Input) => Refinement_Result<Result, Error>;
 export type Refiner_With_Parameters<Result, Error, Input, Parameters> = ($: Input, $p: Parameters, abort: ($: Error) => never) => Result;
-export type Refiner_New<Result, Error, Input> = ($: Input, abort: ($: Error) => never) => Result;
+export type Refiner<Result, Error, Input> = ($: Input, abort: ($: Error) => never) => Result;

package/dist/algorithm/Serializer.d.ts

@@ -0,0 +1,3 @@
+import { Transformer, Transformer_With_Parameters } from "./Transformer";
+export type Serializer_With_Parameters<Input, Parameters> = Transformer_With_Parameters<Input, string, Parameters>;
+export type Serializer<Input> = Transformer<Input, string>;

package/dist/algorithm/Serializer.js

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

package/dist/algorithm/Transformer.d.ts

@@ -1,2 +1,2 @@
-export type Transformer_New_With_Parameters<Input, Result, Parameters> = ($: Input, $p: Parameters) => Result;
-export type Transformer_New<Input, Result> = ($: Input) => Result;
+export type Transformer_With_Parameters<Input, Result, Parameters> = ($: Input, $p: Parameters) => Result;
+export type Transformer<Input, Result> = ($: Input) => Result;

package/package.json

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