exupery-core-internals 0.3.5 → 0.3.7

package/dist/create_data_preparation_result.d.ts

@@ -0,0 +1,10 @@
+import * as _et from "exupery-core-types";
+/**
+ * this function contains the body in which the async value or error is executed
+ * after the execution, either the on_result or on_error callback will be called
+ * @param on_result the callback to call when a value is produced
+ * @param on_error the callback to call when an error is produced
+ */
+type Executer<Output, Error> = (on_result: ($: Output) => void, on_error: ($: Error) => void) => void;
+export declare function __create_data_preparation_result<T, E>(executer: Executer<T, E>): _et.Data_Preparation_Result<T, E>;
+export {};

package/dist/create_data_preparation_result.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__create_data_preparation_result = __create_data_preparation_result;
+class Data_Preparation_Result_Class {
+    constructor(executer) {
+        this.executer = executer;
+    }
+    transform(transformer) {
+        return new Data_Preparation_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                on_result(transformer($));
+            }, on_error);
+        });
+    }
+    transform_error_temp(transform_error) {
+        return new Data_Preparation_Result_Class((on_result, on_error) => {
+            this.executer(on_result, ($) => {
+                on_error(transform_error($));
+            });
+        });
+    }
+    process_without_error_transformation(processor) {
+        return new Data_Preparation_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                processor($).__extract_data(on_result, on_error);
+            }, on_error);
+        });
+    }
+    process(processor, transform_error) {
+        return new Data_Preparation_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                processor($).__extract_data(on_result, (processor_error) => {
+                    on_error(transform_error(processor_error));
+                });
+            }, on_error);
+        });
+    }
+    rework_error_temp(rework_error, transform_rework_error) {
+        return new Data_Preparation_Result_Class((on_result, on_error) => {
+            this.executer(on_result, ($) => {
+                rework_error($).__extract_data((new_target_error) => {
+                    on_error(new_target_error);
+                }, (rework_error) => {
+                    on_error(transform_rework_error(rework_error));
+                });
+            });
+        });
+    }
+    __extract_data(on_result, on_error) {
+        this.executer(on_result, on_error);
+    }
+}
+function __create_data_preparation_result(executer) {
+    return new Data_Preparation_Result_Class(executer);
+}

package/dist/data_processing.d.ts

@@ -0,0 +1,5 @@
+import * as _et from 'exupery-core-types';
+export declare namespace data_processing {
+    const failed: <T, E>(error: E) => _et.Data_Preparation_Result<T, E>;
+    const successful: <T, E>(value: T) => _et.Data_Preparation_Result<T, E>;
+}

package/dist/data_processing.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.data_processing = void 0;
+const create_data_preparation_result_1 = require("./create_data_preparation_result");
+var data_processing;
+(function (data_processing) {
+    data_processing.failed = (error) => {
+        return (0, create_data_preparation_result_1.__create_data_preparation_result)((on_result, on_error) => {
+            on_error(error);
+        });
+    };
+    data_processing.successful = (value) => {
+        return (0, create_data_preparation_result_1.__create_data_preparation_result)((on_result, on_error) => {
+            on_result(value);
+        });
+    };
+})(data_processing || (exports.data_processing = data_processing = {}));

package/dist/index.d.ts

@@ -8,4 +8,4 @@ export * from "./imp/public/panic";
 export * from "./imp/public/procedural_builder";
 export * from "./imp/public/set";
 export * from "./imp/public/switch_state";
-export * from "./refinement";
+export * from "./create_data_preparation_result";

package/dist/index.js

@@ -24,4 +24,4 @@ __exportStar(require("./imp/public/panic"), exports);
 __exportStar(require("./imp/public/procedural_builder"), exports);
 __exportStar(require("./imp/public/set"), exports);
 __exportStar(require("./imp/public/switch_state"), exports);
-__exportStar(require("./refinement"), exports);
+__exportStar(require("./create_data_preparation_result"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-internals",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "license": "ISC",
   "description": "",
   "author": "Corno",
@@ -15,7 +15,7 @@
     "url": "https://github.com/corno/exupery-core/issues"
   },
   "dependencies": {
-    "exupery-core-types": "^0.3.31"
+    "exupery-core-types": "^0.3.33"
   },
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",

package/dist/refinement.d.ts

@@ -1,5 +0,0 @@
-import * as _et from 'exupery-core-types';
-export declare namespace refinement {
-    const failed: <T, E>(error: E) => _et.Refinement_Result<T, E>;
-    const successful: <T, E>(value: T) => _et.Refinement_Result<T, E>;
-}

package/dist/refinement.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.refinement = void 0;
-var refinement;
-(function (refinement) {
-    refinement.failed = (error) => {
-        return {
-            'process': (success, error_handler) => {
-                error_handler(error);
-            },
-            'transform': (success, error_handler) => {
-                return error_handler(error);
-            },
-            'with_result': (success) => {
-                return refinement.failed(error);
-            },
-            'map': (handle_value, handle_error) => {
-                return refinement.failed(handle_error(error));
-            },
-            'map_result': (handle_value) => {
-                return refinement.failed(error);
-            },
-            'transform_error': (handle_error) => {
-                return refinement.failed(handle_error(error));
-            },
-        };
-    };
-    refinement.successful = (value) => {
-        return {
-            'process': (success, error_handler) => {
-                success(value);
-            },
-            'transform': (success, error_handler) => {
-                return success(value);
-            },
-            'with_result': (success) => {
-                return success(value);
-            },
-            'map': (handle_value, handle_error) => {
-                return refinement.successful(handle_value(value));
-            },
-            'map_result': (handle_value) => {
-                return refinement.successful(handle_value(value));
-            },
-            'transform_error': (handle_error) => {
-                return refinement.successful(value);
-            },
-        };
-    };
-})(refinement || (exports.refinement = refinement = {}));