exupery-core-types 0.3.47 → 0.3.49

package/dist/Query.d.ts

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

package/dist/Query_Procedure.d.ts

@@ -1,2 +1,2 @@
-import { Query } from "./Stager";
+import { Query } from "./Query";
 export type Query_Procedure<Result, Error, Parameters, Query_Resources> = ($q: Query_Resources) => Query<Result, Error, Parameters>;

package/dist/Query_Result.d.ts

@@ -0,0 +1,26 @@
+import { Transformer } from "./Transformer";
+type Stager<Output, Error, Input> = ($: Input) => Query_Result<Output, Error>;
+export interface Query_Result<Output, Error> {
+    query_result: null;
+    transform_result<New_Output>(transformer: Transformer<New_Output, Output>): Query_Result<New_Output, Error>;
+    transform_error_temp<New_Error>(error_transformer: Transformer<New_Error, Error>): Query_Result<Output, New_Error>;
+    query_without_error_transformation<New_Output>(query: Stager<New_Output, Error, Output>): Query_Result<New_Output, Error>;
+    query<New_Output, Stager_Error>(query: Stager<New_Output, Stager_Error, Output>, 
+    /**
+     * if the stager fails, rework its error into the desired error type
+     */
+    error_transformer: Transformer<Error, Stager_Error>): Query_Result<New_Output, Error>;
+    refine_without_error_transformation<New_Output>(refiner: Stager<New_Output, Error, Output>): Query_Result<New_Output, Error>;
+    refine<New_Output, Stager_Error>(refiner: Stager<New_Output, Stager_Error, Output>, 
+    /**
+     * if the stager fails, rework its error into the desired error type
+     */
+    error_transformer: Transformer<Error, Stager_Error>): Query_Result<New_Output, Error>;
+    rework_error_temp<New_Error, Rework_Error>(error_reworker: Stager<New_Error, Rework_Error, Error>, 
+    /**
+     * if the reworker fails, we need to transform *that* error into the New_Error
+     */
+    rework_error_transformer: Transformer<New_Error, Rework_Error>): Query_Result<Output, New_Error>;
+    __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
+}
+export {};

package/dist/Refinement_Result.d.ts

@@ -0,0 +1,27 @@
+import { Query_Result } from "./Query_Result";
+import { Transformer } from "./Transformer";
+type Stager<Output, Error, Input> = ($: Input) => Refinement_Result<Output, Error>;
+export interface Refinement_Result<Output, Error> {
+    transform<Target>(output_transformer: Transformer<Target, Output>, error_transformer: Transformer<Target, Error>): Refinement_Result<Target, Target>;
+    transform_result<New_Output>(transformer: Transformer<New_Output, Output>): Refinement_Result<New_Output, Error>;
+    transform_error_temp<New_Error>(error_transformer: Transformer<New_Error, Error>): Refinement_Result<Output, New_Error>;
+    refine_without_error_transformation<New_Output>(refiner: Stager<New_Output, Error, Output>): Refinement_Result<New_Output, Error>;
+    refine<New_Output, Stager_Error>(refiner: Stager<New_Output, Stager_Error, Output>, 
+    /**
+     * if the stager fails, rework its error into the desired error type
+     */
+    error_transformer: Transformer<Error, Stager_Error>): Refinement_Result<New_Output, Error>;
+    query_without_error_transformation<New_Output>(query: Stager<New_Output, Error, Output>): Query_Result<New_Output, Error>;
+    query<New_Output, Stager_Error>(query: Stager<New_Output, Stager_Error, Output>, 
+    /**
+     * if the stager fails, rework its error into the desired error type
+     */
+    error_transformer: Transformer<Error, Stager_Error>): Query_Result<New_Output, Error>;
+    rework_error_temp<New_Error, Rework_Error>(error_reworker: Stager<New_Error, Rework_Error, Error>, 
+    /**
+     * if the reworker fails, we need to transform *that* error into the New_Error
+     */
+    rework_error_transformer: Transformer<New_Error, Rework_Error>): Refinement_Result<Output, New_Error>;
+    __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
+}
+export {};

package/dist/Refinement_Result.js

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

package/dist/index.d.ts

@@ -4,7 +4,8 @@ export * from "./Dictionary";
 export * from "./Lookup";
 export * from "./Optional_Value";
 export * from "./Command";
-export * from "./Stager";
-export * from "./Staging_Result";
+export * from "./Query";
+export * from "./Query_Result";
+export * from "./Refinement_Result";
 export * from "./Query_Procedure";
 export * from "./Transformer";

package/dist/index.js

@@ -20,7 +20,8 @@ __exportStar(require("./Dictionary"), exports);
 __exportStar(require("./Lookup"), exports);
 __exportStar(require("./Optional_Value"), exports);
 __exportStar(require("./Command"), exports);
-__exportStar(require("./Stager"), exports);
-__exportStar(require("./Staging_Result"), exports);
+__exportStar(require("./Query"), exports);
+__exportStar(require("./Query_Result"), exports);
+__exportStar(require("./Refinement_Result"), exports);
 __exportStar(require("./Query_Procedure"), exports);
 __exportStar(require("./Transformer"), exports);

package/package.json

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

package/dist/Stager.d.ts

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

package/dist/Staging_Result.d.ts

@@ -1,18 +0,0 @@
-import { Stager } from "./Stager";
-import { Transformer } from "./Transformer";
-export interface Staging_Result<Output, Error> {
-    transform_result<New_Output>(transformer: Transformer<New_Output, Output>): Staging_Result<New_Output, Error>;
-    transform_error_temp<New_Error>(error_transformer: Transformer<New_Error, Error>): Staging_Result<Output, New_Error>;
-    stage_without_error_transformation<New_Output>(stager: Stager<New_Output, Error, Output>): Staging_Result<New_Output, Error>;
-    stage<New_Output, Stager_Error>(stager: Stager<New_Output, Stager_Error, Output>, 
-    /**
-     * if the stager fails, rework its error into the desired error type
-     */
-    error_transformer: Transformer<Error, Stager_Error>): Staging_Result<New_Output, Error>;
-    rework_error_temp<New_Error, Rework_Error>(error_reworker: Stager<New_Error, Rework_Error, Error>, 
-    /**
-     * if the reworker fails, we need to transform *that* error into the New_Error
-     */
-    rework_error_transformer: Transformer<New_Error, Rework_Error>): Staging_Result<Output, New_Error>;
-    __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
-}