exupery-core-internals 0.1.5 → 0.1.7

package/dist/imp/public/array_literal.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.array_literal = array_literal;
-const create_asynchronous_processes_monitor_1 = require("../private/create_asynchronous_processes_monitor");
-const create_Async_Value_1 = require("./create_Async_Value");
-const create_Unsafe_Async_Value_1 = require("./create_Unsafe_Async_Value");
 const not_set_1 = require("./not_set");
 const set_1 = require("./set");
 /**
@@ -20,53 +17,6 @@ class Array_Class {
             return $v(entry);
         }));
     }
-    map_async(on_element_value) {
-        const data = this.data;
-        return (0, create_Async_Value_1.create_Async_Value)({
-            'execute': (on_array_value) => {
-                const temp = [];
-                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((registry) => {
-                    data.map(on_element_value).forEach((v) => {
-                        registry['report process started']();
-                        v.__start((v) => {
-                            temp.push(v);
-                            registry['report process finished']();
-                        });
-                    });
-                }, () => {
-                    on_array_value(array_literal(temp));
-                });
-            }
-        });
-    }
-    map_async_unsafe(on_element_value) {
-        const data = this.data;
-        return (0, create_Unsafe_Async_Value_1.create_Unsafe_Async_Value)({
-            'execute': (on_array_value, on_array_exception) => {
-                const temp_values = [];
-                const temp_exceptions = [];
-                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((registry) => {
-                    data.map(on_element_value).forEach((v) => {
-                        registry['report process started']();
-                        v.__start(($) => {
-                            temp_values.push($);
-                            registry['report process finished']();
-                        }, ($) => {
-                            temp_exceptions.push($);
-                            registry['report process finished']();
-                        });
-                    });
-                }, () => {
-                    if (temp_exceptions.length > 0) {
-                        on_array_exception(array_literal(temp_exceptions));
-                    }
-                    else {
-                        on_array_value(array_literal(temp_values));
-                    }
-                });
-            }
-        });
-    }
     //internal methods
     __for_each($i) {
         this.data.forEach(($) => {

package/dist/imp/public/dictionary_literal.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dictionary_literal = dictionary_literal;
-const create_asynchronous_processes_monitor_1 = require("../private/create_asynchronous_processes_monitor");
-const create_Async_Value_1 = require("./create_Async_Value");
-const create_Unsafe_Async_Value_1 = require("./create_Unsafe_Async_Value");
 const set_1 = require("./set");
 const not_set_1 = require("./not_set");
 const array_literal_1 = require("./array_literal");
@@ -22,53 +19,6 @@ class Dictionary {
             };
         }));
     }
-    map_async(on_entry_value) {
-        const source = this.source;
-        const temp = {};
-        return (0, create_Async_Value_1.create_Async_Value)({
-            'execute': (on_dictionary_value) => {
-                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((counter) => {
-                    source.map(($) => {
-                        counter['report process started']();
-                        on_entry_value($.value).__start((nv) => {
-                            temp[$.key] = nv;
-                            counter['report process finished']();
-                        });
-                    });
-                }, () => {
-                    on_dictionary_value(dictionary_literal(temp));
-                });
-            }
-        });
-    }
-    map_async_unsafe(on_entry_value) {
-        const source = this.source;
-        const temp_values = {};
-        const temp_exceptions = {};
-        return (0, create_Unsafe_Async_Value_1.create_Unsafe_Async_Value)({
-            'execute': (on_dictionary_value, on_dictionary_exception) => {
-                (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((counter) => {
-                    source.map(($) => {
-                        counter['report process started']();
-                        on_entry_value($.value).__start((value) => {
-                            temp_values[$.key] = value;
-                            counter['report process finished']();
-                        }, (exception) => {
-                            temp_exceptions[$.key] = exception;
-                            counter['report process finished']();
-                        });
-                    });
-                }, () => {
-                    if (Object.keys(temp_exceptions).length > 0) {
-                        on_dictionary_exception(dictionary_literal(temp_exceptions));
-                    }
-                    else {
-                        on_dictionary_value(dictionary_literal(temp_values));
-                    }
-                });
-            }
-        });
-    }
     __map_with_key($v) {
         return new Dictionary(this.source.map(($) => {
             return {

package/dist/index.d.ts

@@ -6,9 +6,6 @@ export * from "./imp/public/change_context";
 export * from "./imp/public/block";
 export * from "./imp/public/switch_state";
 export * from "./imp/public/get_location_info";
-export * from "./imp/public/resolve_async_tuple_2";
-export * from "./imp/public/make_async";
-export * from "./imp/public/create_Async_Value";
 export * from "./imp/public/set";
 export * from "./imp/public/not_set";
 export * from "./imp/public/Error";

package/dist/index.js

@@ -22,9 +22,6 @@ __exportStar(require("./imp/public/change_context"), exports);
 __exportStar(require("./imp/public/block"), exports);
 __exportStar(require("./imp/public/switch_state"), exports);
 __exportStar(require("./imp/public/get_location_info"), exports);
-__exportStar(require("./imp/public/resolve_async_tuple_2"), exports);
-__exportStar(require("./imp/public/make_async"), exports);
-__exportStar(require("./imp/public/create_Async_Value"), exports);
 __exportStar(require("./imp/public/set"), exports);
 __exportStar(require("./imp/public/not_set"), exports);
 __exportStar(require("./imp/public/Error"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-internals",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "license": "ISC",
   "description": "",
   "author": "Corno",
@@ -15,7 +15,7 @@
     "url": "https://github.com/corno/exupery-core/issues"
   },
   "dependencies": {
-    "exupery-core-types": "^0.1.4"
+    "exupery-core-types": "^0.1.5"
   },
   "devDependencies": {
     "@types/node": "^18.15.3"

package/dist/imp/private/create_asynchronous_processes_monitor.d.ts

@@ -1,15 +0,0 @@
-export type I_Async_Monitor = {
-    readonly 'report process started': () => void;
-    readonly 'report process finished': () => void;
-};
-/**
- * this function helps in keeping track of ongoing async operations
- * async operations are registered and when finished reported as such.
- * when all ongoing operations are finished the onEnd callback is called
- *
- * this function is specifically useful for async map functions
- *
- * @param callback this callback creates a scope within which the counter is provided
- * @param onEnd this callback will be called when all ongoing operations are finished
- */
-export declare function create_asynchronous_processes_monitor(monitoring_phase: ($: I_Async_Monitor) => void, on_all_finished: () => void): void;

package/dist/imp/private/create_asynchronous_processes_monitor.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_asynchronous_processes_monitor = create_asynchronous_processes_monitor;
-/**
- * this function helps in keeping track of ongoing async operations
- * async operations are registered and when finished reported as such.
- * when all ongoing operations are finished the onEnd callback is called
- *
- * this function is specifically useful for async map functions
- *
- * @param callback this callback creates a scope within which the counter is provided
- * @param onEnd this callback will be called when all ongoing operations are finished
- */
-function create_asynchronous_processes_monitor(monitoring_phase, on_all_finished) {
-    let counter = 0;
-    /*
-     * we need to keep track of if the registration phase is ended or not.
-     * it can happen that the counter reaches 0 during the registration phase, specifically if there is no real async calls being made
-     * in that case the reportFinished counter is als called during the registration phase.
-     * If that happens there should not yet be a call to onEnd().
-     */
-    let registration_phase_ended = false;
-    let on_all_finished_has_been_called = false;
-    function checkStatus() {
-        if (registration_phase_ended) {
-            if (counter === 0) {
-                if (on_all_finished_has_been_called === true) {
-                    throw new Error("CORE: already ended");
-                }
-                on_all_finished_has_been_called = true;
-                on_all_finished();
-            }
-        }
-    }
-    monitoring_phase({
-        'report process started': () => {
-            if (on_all_finished_has_been_called) {
-                throw new Error("CORE: async call done after context is ready");
-            }
-            counter += 1;
-        },
-        'report process finished': () => {
-            if (counter === 0) {
-                throw new Error("CORE: decrement while counter is 0");
-            }
-            counter -= 1;
-            checkStatus();
-        },
-    });
-    registration_phase_ended = true;
-    checkStatus();
-}

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

@@ -1,10 +0,0 @@
-import * as pt from "exupery-core-types";
-export type Executer<T> = {
-    'execute': (on_value: ($: T) => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function create_Async_Value<T>(executer: Executer<T>): pt.Async_Value<T>;

package/dist/imp/public/create_Async_Value.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_Async_Value = create_Async_Value;
-class Async_Value_Class {
-    constructor(executer) {
-        this.executer = executer;
-    }
-    map(handle_value) {
-        return create_Async_Value({
-            'execute': (on_value) => {
-                this.executer.execute((value) => {
-                    on_value(handle_value(value));
-                });
-            }
-        });
-    }
-    then(handle_value) {
-        return create_Async_Value({
-            'execute': (on_value) => {
-                this.executer.execute((value) => {
-                    handle_value(value).__start(on_value);
-                });
-            }
-        });
-    }
-    __start(on_value) {
-        this.executer.execute(on_value);
-    }
-}
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-function create_Async_Value(executer) {
-    return new Async_Value_Class(executer);
-}

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

@@ -1,17 +0,0 @@
-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
- * @param on_value the callback to call when a value is produced
- * @param on_exception the callback to call when an error is produced
- */
-type Executer<T, E> = {
-    'execute': (on_value: ($: T) => void, on_exception: ($: E) => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function create_Unsafe_Async_Value<T, E>(executer: Executer<T, E>): _et.Unsafe_Async_Value<T, E>;
-export {};

package/dist/imp/public/create_Unsafe_Async_Value.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_Unsafe_Async_Value = create_Unsafe_Async_Value;
-const create_Async_Value_1 = require("./create_Async_Value");
-class Unsafe_Async_Value_Class {
-    constructor(executer) {
-        this.executer = executer;
-    }
-    map(handle_value) {
-        return new Unsafe_Async_Value_Class({
-            'execute': (on_value, on_exception) => {
-                this.executer.execute(($) => {
-                    on_value(handle_value($));
-                }, on_exception);
-            }
-        });
-    }
-    then(handle_value) {
-        return new Unsafe_Async_Value_Class({
-            'execute': (new_on_value, new_on_exception) => {
-                this.executer.execute(($) => {
-                    handle_value($).__start(new_on_value, new_on_exception);
-                }, new_on_exception);
-            }
-        });
-    }
-    if_exception_then(handle_exception) {
-        return new Unsafe_Async_Value_Class({
-            'execute': (new_on_value, new_on_exception) => {
-                this.executer.execute(new_on_value, ($) => {
-                    handle_exception($).__start(new_on_value, new_on_exception);
-                });
-            }
-        });
-    }
-    map_exception(handle_exception) {
-        return new Unsafe_Async_Value_Class({
-            'execute': (on_value, on_exception) => {
-                this.executer.execute(on_value, ($) => {
-                    on_exception(handle_exception($));
-                });
-            }
-        });
-    }
-    catch(handle_exception) {
-        return (0, create_Async_Value_1.create_Async_Value)({
-            'execute': (on_value) => {
-                this.executer.execute(on_value, ($) => {
-                    on_value(handle_exception($));
-                });
-            }
-        });
-    }
-    catch_and_map(handle_value, handle_exception) {
-        return (0, create_Async_Value_1.create_Async_Value)({
-            'execute': (on_value) => {
-                this.executer.execute(($) => {
-                    on_value(handle_value($));
-                }, ($) => {
-                    on_value(handle_exception($));
-                });
-            }
-        });
-    }
-    __start(on_value, on_exception) {
-        this.executer.execute(on_value, on_exception);
-    }
-}
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-function create_Unsafe_Async_Value(executer) {
-    return new Unsafe_Async_Value_Class(executer);
-}

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

@@ -1,7 +0,0 @@
-import * as pt from "exupery-core-types";
-/**
- * converts a regular value to a {@link Async_Value}
- * @param $ the value
- * @returns
- */
-export declare function make_async<T>($: T): pt.Async_Value<T>;

package/dist/imp/public/make_async.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.make_async = make_async;
-const create_Async_Value_1 = require("./create_Async_Value");
-/**
- * converts a regular value to a {@link Async_Value}
- * @param $ the value
- * @returns
- */
-function make_async($) {
-    return (0, create_Async_Value_1.create_Async_Value)({
-        'execute': (on_value) => {
-            on_value($);
-        }
-    });
-}

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

@@ -1,6 +0,0 @@
-import * as pt from 'exupery-core-types';
-export type Sync_Tuple_2<T1, T2> = {
-    readonly 'first': T1;
-    readonly 'second': T2;
-};
-export declare function resolve_async_tuple_2<T1, T2>(first: pt.Async_Value<T1>, second: pt.Async_Value<T2>): pt.Async_Value<Sync_Tuple_2<T1, T2>>;

package/dist/imp/public/resolve_async_tuple_2.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolve_async_tuple_2 = resolve_async_tuple_2;
-const create_Async_Value_1 = require("./create_Async_Value");
-function resolve_async_tuple_2(first, second) {
-    return (0, create_Async_Value_1.create_Async_Value)({
-        'execute': (on_value) => {
-            let element_1_is_set = false;
-            let element_2_is_set = false;
-            let elem1;
-            let elem2;
-            function wrap_up() {
-                if (element_1_is_set && element_2_is_set) {
-                    on_value({ first: elem1, second: elem2 });
-                }
-            }
-            first.__start((val) => {
-                elem1 = val;
-                element_1_is_set = true;
-                wrap_up();
-            });
-            second.__start((val) => {
-                elem2 = val;
-                element_2_is_set = true;
-                wrap_up();
-            });
-        }
-    });
-}