exupery-core-internals 0.3.8 → 0.3.10

package/dist/{create_data_preparation_result.d.ts → create_staging_result.d.ts}

@@ -6,5 +6,5 @@ import * as _et from "exupery-core-types";
  * @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 declare function __create_staging_result<T, E>(executer: Executer<T, E>): _et.Staging_Result<T, E>;
 export {};

package/dist/create_staging_result.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__create_staging_result = __create_staging_result;
+class Staging_Result_Class {
+    constructor(executer) {
+        this.executer = executer;
+    }
+    transform(transformer) {
+        return new Staging_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                on_result(transformer($));
+            }, on_error);
+        });
+    }
+    transform_error_temp(error_transformer) {
+        return new Staging_Result_Class((on_result, on_error) => {
+            this.executer(on_result, ($) => {
+                on_error(error_transformer($));
+            });
+        });
+    }
+    stage_without_error_transformation(stager) {
+        return new Staging_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                stager($).__extract_data(on_result, on_error);
+            }, on_error);
+        });
+    }
+    stage(stager, transform_error) {
+        return new Staging_Result_Class((on_result, on_error) => {
+            this.executer(($) => {
+                stager($).__extract_data(on_result, (stager_error) => {
+                    on_error(transform_error(stager_error));
+                });
+            }, on_error);
+        });
+    }
+    rework_error_temp(error_reworker, rework_error_transformer) {
+        return new Staging_Result_Class((on_result, on_error) => {
+            this.executer(on_result, ($) => {
+                error_reworker($).__extract_data((new_target_error) => {
+                    on_error(new_target_error);
+                }, (rework_error) => {
+                    on_error(rework_error_transformer(rework_error));
+                });
+            });
+        });
+    }
+    __extract_data(on_result, on_error) {
+        this.executer(on_result, on_error);
+    }
+}
+function __create_staging_result(executer) {
+    return new Staging_Result_Class(executer);
+}

package/dist/data_processing.d.ts

@@ -1,5 +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>;
+    const failed: <T, E>(error: E) => _et.Staging_Result<T, E>;
+    const successful: <T, E>(value: T) => _et.Staging_Result<T, E>;
 }

package/dist/data_processing.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.data_processing = void 0;
-const create_data_preparation_result_1 = require("./create_data_preparation_result");
+const create_staging_result_1 = require("./create_staging_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) => {
+        return (0, create_staging_result_1.__create_staging_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) => {
+        return (0, create_staging_result_1.__create_staging_result)((on_result, on_error) => {
             on_result(value);
         });
     };

package/dist/imp/public/dictionary_literal.d.ts

@@ -1,4 +1,4 @@
-import * as pt from "exupery-core-types";
+import * as _et from "exupery-core-types";
 /**
  * returns a Exupery dictionary
  *
@@ -8,4 +8,4 @@ import * as pt from "exupery-core-types";
  */
 export declare function dictionary_literal<T>(source: {
     readonly [key: string]: T;
-}): pt.Dictionary<T>;
+}): _et.Dictionary<T>;

package/dist/imp/public/dictionary_literal.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dictionary_literal = dictionary_literal;
 const set_1 = require("./set");
 const not_set_1 = require("./not_set");
-const array_literal_1 = require("./array_literal");
+const list_literal_1 = require("./list_literal");
 /**
  * this is an implementation, not public by design
  */
@@ -21,7 +21,7 @@ class Dictionary {
     }
     deprecated_to_array(compare) {
         const sorted_keys = this.source.slice().sort(compare);
-        return (0, array_literal_1.array_literal)(sorted_keys);
+        return (0, list_literal_1.list_literal)(sorted_keys);
     }
     __get_entry(key) {
         for (let i = 0; i !== this.source.length; i += 1) {

package/dist/imp/public/{array_literal.d.ts → list_literal.d.ts}

@@ -5,4 +5,4 @@ import * as _et from "exupery-core-types";
  * @param source An array literal
  * @returns
  */
-export declare function array_literal<T>(source: readonly T[]): _et.Array<T>;
+export declare function list_literal<T>(source: readonly T[]): _et.List<T>;

package/dist/imp/public/{array_literal.js → list_literal.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.array_literal = array_literal;
+exports.list_literal = list_literal;
 const not_set_1 = require("./not_set");
 const set_1 = require("./set");
 /**
@@ -8,12 +8,12 @@ const set_1 = require("./set");
  * If you feel the need to rename this class, don't rename it to 'Array',
  * it will break the 'instanceOf Array' test
  */
-class Array_Class {
+class List_Class {
     constructor(data) {
         this.data = data;
     }
     map($v) {
-        return array_literal(this.data.map((entry) => {
+        return list_literal(this.data.map((entry) => {
             return $v(entry);
         }));
     }
@@ -42,10 +42,10 @@ class Array_Class {
  * @param source An array literal
  * @returns
  */
-function array_literal(source) {
+function list_literal(source) {
     if (!(source instanceof Array)) {
-        throw new Error("invalid input in 'array_literal'");
+        throw new Error("invalid input in 'list_literal'");
     }
     const data = source.slice(); //create a copy
-    return new Array_Class(data);
+    return new List_Class(data);
 }

package/dist/imp/public/{procedural_builder.d.ts → procedural_collection_builder.d.ts}

@@ -6,7 +6,7 @@ export type Procedural_Dictionary_Builder<Entry> = {
 export declare const create_procedural_dictionary_builder: <Entry>() => Procedural_Dictionary_Builder<Entry>;
 export type Procedural_List_Builder<Item> = {
     'add item': (item: Item) => void;
-    'add list': (list: _et.Array<Item>) => void;
-    'get list': () => _et.Array<Item>;
+    'add list': (list: _et.List<Item>) => void;
+    'get list': () => _et.List<Item>;
 };
 export declare const create_procedural_list_builder: <Item>() => Procedural_List_Builder<Item>;

package/dist/imp/public/{procedural_builder.js → procedural_collection_builder.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create_procedural_list_builder = exports.create_procedural_dictionary_builder = void 0;
 const dictionary_literal_1 = require("./dictionary_literal");
-const array_literal_1 = require("./array_literal");
+const list_literal_1 = require("./list_literal");
 const create_procedural_dictionary_builder = () => {
     const entries = {};
     return {
@@ -27,7 +27,7 @@ const create_procedural_list_builder = () => {
             });
         },
         'get list': () => {
-            return (0, array_literal_1.array_literal)(items);
+            return (0, list_literal_1.list_literal)(items);
         },
     };
 };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-export * from "./imp/public/array_literal";
+export * from "./imp/public/list_literal";
 export * from "./imp/public/assert_unreachable";
 export * from "./imp/public/block";
 export * from "./imp/public/change_context";
 export * from "./imp/public/dictionary_literal";
 export * from "./imp/public/not_set";
 export * from "./imp/public/panic";
-export * from "./imp/public/procedural_builder";
+export * from "./imp/public/procedural_collection_builder";
 export * from "./imp/public/set";
 export * from "./imp/public/switch_state";
-export * from "./create_data_preparation_result";
+export * from "./create_staging_result";
 export * from "./data_processing";

package/dist/index.js

@@ -14,15 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./imp/public/array_literal"), exports);
+__exportStar(require("./imp/public/list_literal"), exports);
 __exportStar(require("./imp/public/assert_unreachable"), exports);
 __exportStar(require("./imp/public/block"), exports);
 __exportStar(require("./imp/public/change_context"), exports);
 __exportStar(require("./imp/public/dictionary_literal"), exports);
 __exportStar(require("./imp/public/not_set"), exports);
 __exportStar(require("./imp/public/panic"), exports);
-__exportStar(require("./imp/public/procedural_builder"), exports);
+__exportStar(require("./imp/public/procedural_collection_builder"), exports);
 __exportStar(require("./imp/public/set"), exports);
 __exportStar(require("./imp/public/switch_state"), exports);
-__exportStar(require("./create_data_preparation_result"), exports);
+__exportStar(require("./create_staging_result"), exports);
 __exportStar(require("./data_processing"), exports);

package/package.json

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

package/dist/create_data_preparation_result.js

@@ -1,55 +0,0 @@
-"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);
-}