pareto-core 0.1.153 → 0.1.154

package/dist/assign.d.ts

@@ -1,10 +1,4 @@
 export * as decide from "./implementation/__internal/sync/decide";
 export * from "./implementation/__internal/sync/data_switch";
-export * as boolean from "./implementation/__internal/sync/transform/boolean";
-export * as dictionary from "./implementation/__internal/sync/transform/dictionary";
-export * as group from "./implementation/__internal/sync/transform/group";
-export * as list from "./implementation/__internal/sync/transform/list";
-export * as number from "./implementation/__internal/sync/transform/number";
-export * as optional from "./implementation/__internal/sync/transform/optional";
-export * as state from "./implementation/__internal/sync/transform/state";
+export * from "./implementation/__internal/sync/transform/transform";
 export * as literal from "./implementation/__internal/sync/literal";

package/dist/assign.js

@@ -36,15 +36,9 @@ 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 });
-exports.literal = exports.state = exports.optional = exports.number = exports.list = exports.group = exports.dictionary = exports.boolean = exports.decide = void 0;
+exports.literal = exports.decide = void 0;
 exports.decide = __importStar(require("./implementation/__internal/sync/decide"));
 __exportStar(require("./implementation/__internal/sync/data_switch"), exports);
-exports.boolean = __importStar(require("./implementation/__internal/sync/transform/boolean"));
-exports.dictionary = __importStar(require("./implementation/__internal/sync/transform/dictionary"));
-exports.group = __importStar(require("./implementation/__internal/sync/transform/group"));
-exports.list = __importStar(require("./implementation/__internal/sync/transform/list"));
-exports.number = __importStar(require("./implementation/__internal/sync/transform/number"));
-exports.optional = __importStar(require("./implementation/__internal/sync/transform/optional"));
-exports.state = __importStar(require("./implementation/__internal/sync/transform/state"));
+__exportStar(require("./implementation/__internal/sync/transform/transform"), exports);
 exports.literal = __importStar(require("./implementation/__internal/sync/literal"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzaWduLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Fzc2lnbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFDQSxrRkFBaUU7QUFDakUsK0VBQTREO0FBRTVELDhGQUE2RTtBQUM3RSxvR0FBbUY7QUFDbkYsMEZBQXlFO0FBQ3pFLHdGQUF1RTtBQUN2RSw0RkFBMkU7QUFDM0UsZ0dBQStFO0FBQy9FLDBGQUF5RTtBQUV6RSxvRkFBbUUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzaWduLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Fzc2lnbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFDQSxrRkFBaUU7QUFDakUsK0VBQTREO0FBRTVELHVGQUFvRTtBQUdwRSxvRkFBbUUifQ==

package/dist/implementation/__internal/sync/transform/transform.d.ts

@@ -0,0 +1,74 @@
+import * as p_di from "../../../../interface/data";
+import * as p_ri from "../../../../interface/refiner";
+import * as p_ti from "../../../../interface/transformer";
+import { Abort } from "../../../../interface/__internal/Abort";
+export declare namespace from {
+    const boolean: (boolean_value: boolean) => {
+        convert: <T extends p_di.Value>(assign_set: () => T) => p_di.Optional_Value<T>;
+    };
+    const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {
+        amount_of_entries: () => number;
+        convert: <New_Type extends p_di.Value>(assign_item: (value: T, id: string) => New_Type) => p_di.List<New_Type>;
+        filter: (callback: (value: T, id: string) => boolean) => p_di.Dictionary<T>;
+        flatten: <New_Type extends p_di.Value>(get_child_dictionary: (value: T) => p_di.Dictionary<New_Type>, get_id: (parent_id: string, child_id: string) => string, abort: {
+            duplicate_id: Abort<string>;
+        }) => p_di.Dictionary<New_Type>;
+        flatten_to_list: <NT extends p_di.Value>(assign_item: (value: T, id: string) => p_di.List<NT>) => p_di.List<NT>;
+        group: (get_id: (value: T, id: string) => string) => p_di.Dictionary<p_di.Dictionary<T>>;
+        is_empty: () => boolean;
+        join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_dictionary: p_di.Dictionary<Other_Type>, assign_entry: (value: T, other_value: p_di.Optional_Value<Other_Type>, id: string) => Result) => p_di.Dictionary<Result>;
+        map: <New_Type extends p_di.Value>(assign_entry: (value: T, id: string) => New_Type) => p_di.Dictionary<New_Type>;
+        map_optionally: <New_Type extends p_di.Value>(assign_optional_entry: (value: T, id: string) => p_di.Optional_Value<New_Type>) => p_di.Dictionary<New_Type>;
+        re_id: (get_id: ($: T, key: string) => string, abort: {
+            duplicate_id: (value: T, id: string) => never;
+        }) => p_di.Dictionary<T>;
+        resolve_refiner: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ri.lookup.Acyclic<Resolved>, cyclic_lookup: p_ri.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
+        resolve_transform: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ti.lookup.Acyclic<Resolved>, cyclic_lookup: p_ti.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
+        sum: (assign_value: (item: T) => number) => number;
+    };
+    const list: <T extends p_di.Value>(list: p_di.List<T>) => {
+        amount_of_items: () => number;
+        convert: <NT extends p_di.Value>(get_id: (item: T) => string, get_value: (item: T) => NT, abort: {
+            duplicate_id: Abort<string>;
+        }) => p_di.Dictionary<NT>;
+        filter: (callback: (item: T) => boolean) => p_di.List<T>;
+        flatten: <NT extends p_di.Value>(assign_list: ($: T) => p_di.List<NT>) => p_di.List<NT>;
+        full_join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: p_di.Optional_Value<T>, other_value: p_di.Optional_Value<Other_Type>) => Result) => p_di.List<Result>;
+        group: (get_id: (item: T) => string) => p_di.Dictionary<p_di.List<T>>;
+        is_empty: () => boolean;
+        join: <Other_Type extends p_di.Value, Result_1 extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: T, other_value: p_di.Optional_Value<Other_Type>) => Result_1) => p_di.List<Result_1>;
+        map: <New_Type extends p_di.Value>(assign_item: (item: T) => New_Type) => p_di.List<New_Type>;
+        map_optionally: <New_Type extends p_di.Value>(assign_optional_item: (item: T) => p_di.Optional_Value<New_Type>) => p_di.List<New_Type>;
+        map_with_state: <Target_Item extends p_di.Value, State, Result_Type extends {
+            [id: string]: p_di.Value;
+        }>(initial_state: State, assign_item: (item: T, state: State) => Target_Item, update_state: (item: Target_Item, state: State) => State, wrapup: (final_list: p_di.List<Target_Item>, final_state: State) => Result_Type) => Result_Type;
+        sum: (assign_value: (item: T) => number) => number;
+        reduce_to_boolean: (initial_state: boolean, update_state: (value: T, current: boolean) => boolean) => boolean;
+        reduce_to_number: (initial_state: number, update_state: (value: T, current: number) => number) => number;
+        reverse: () => p_di.List<T>;
+    };
+    namespace number {
+        /**
+         * Performs integer division of two numbers with configurable rounding behavior.
+         *
+         * dividend / divisor
+         *
+         * Rounding modes:
+         * - 'towards negative infinity': floor (7.8 → 7, -7.8 → -8)
+         * - 'towards positive infinity': ceiling (7.2 → 8, -7.8 → -7)
+         * - 'towards zero': truncate (7.8 → 7, -7.8 → -7)
+         * - 'towards nearest': round to nearest integer (7.5 → 8, 7.4 → 7)
+         * - 'away from zero': round away from zero (7.2 → 8, -7.2 → -8)
+         */
+        const divide: ($: number, divisor: number, round: ["towards negative infinity", null] | ["towards positive infinity", null] | ["towards nearest", null] | ["towards zero", null] | ["away from zero", null], abort: {
+            divided_by_zero: Abort<null>;
+        }) => number;
+    }
+    const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {
+        is_set: () => boolean;
+        map: <New_Type extends p_di.Value>(assign_set_value: (value: T) => New_Type) => p_di.Optional_Value<New_Type>;
+    };
+    const text: (string: string) => {
+        state: <State extends p_di.State>(assign_state: ($: string) => State) => p_di.State;
+    };
+}

package/dist/implementation/__internal/sync/transform/transform.js

@@ -0,0 +1,498 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.from = void 0;
+const Dictionary_1 = require("../assign/literals/Dictionary");
+const List_1 = require("../assign/literals/List");
+const lit = __importStar(require("../literal"));
+var from;
+(function (from) {
+    from.boolean = (boolean_value) => {
+        return {
+            convert: (assign_set) => {
+                if (boolean_value) {
+                    return lit.set(assign_set());
+                }
+                else {
+                    return lit.not_set();
+                }
+            },
+        };
+    };
+    from.dictionary = (dictionary) => {
+        return {
+            amount_of_entries: () => {
+                return dictionary.__get_raw_copy().length;
+            },
+            convert: (assign_item) => {
+                return lit.list(dictionary.__get_raw_copy().map(($) => assign_item($[1], $[0])));
+            },
+            filter: (callback) => new Dictionary_1.Dictionary_Class(dictionary.__get_raw_copy().filter(($) => callback($[1], $[0]))),
+            flatten: (get_child_dictionary, get_id, abort) => {
+                const out = {};
+                dictionary.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    const child_dictionary = get_child_dictionary(value);
+                    child_dictionary.__get_raw_copy().forEach(($) => {
+                        const child_id = $[0];
+                        const child_value = $[1];
+                        const combined_id = get_id(id, child_id);
+                        if (out[combined_id] !== undefined) {
+                            abort.duplicate_id(combined_id);
+                        }
+                        out[combined_id] = child_value;
+                    });
+                });
+                return lit.dictionary(out);
+            },
+            flatten_to_list: (assign_item) => {
+                const out = [];
+                dictionary.__get_raw_copy().forEach(($) => {
+                    const entry = $;
+                    const innerList = assign_item(entry[1], entry[0]);
+                    innerList.__get_raw_copy().forEach(($) => {
+                        out.push($);
+                    });
+                });
+                return new List_1.List_Class(out);
+            },
+            group: (get_id) => {
+                const temp = {};
+                dictionary.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    const group_id = get_id(value, id);
+                    if (temp[group_id] === undefined) {
+                        temp[group_id] = {};
+                    }
+                    temp[group_id][id] = value;
+                });
+                return lit.dictionary(temp).__d_map_deprecated(($) => lit.dictionary($));
+            },
+            is_empty: () => {
+                return dictionary.__get_raw_copy().length === 0;
+            },
+            join: (other_dictionary, assign_entry) => {
+                const out = {};
+                dictionary.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    out[id] = assign_entry(value, other_dictionary.__get_possible_entry_deprecated(id), id);
+                });
+                return lit.dictionary(out);
+            },
+            map: (assign_entry) => dictionary.__d_map_deprecated(assign_entry),
+            map_optionally: (assign_optional_entry) => {
+                return new Dictionary_1.Dictionary_Class(dictionary
+                    .__get_raw_copy()
+                    .map(($) => [$[0], assign_optional_entry($[1], $[0])])
+                    .filter(($) => $[1].__get_raw() !== null)
+                    .map(($) => [$[0], $[1].__get_raw()[0]]));
+            },
+            re_id: (get_id, abort) => {
+                const temp = {};
+                dictionary.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    const new_id = get_id(value, id);
+                    if (temp[new_id] !== undefined) {
+                        abort.duplicate_id(value, new_id);
+                    }
+                    temp[new_id] = value;
+                });
+                return lit.dictionary(temp);
+            },
+            resolve_refiner: (assign_entry) => {
+                const source = dictionary;
+                const out = {};
+                const entries_started = {};
+                const cyclic_references = [];
+                const inner_resolve = (value, id, stack) => {
+                    if (out[id] !== undefined) {
+                        // already resolved
+                        return;
+                    }
+                    entries_started[id] = null;
+                    out[id] = assign_entry(value, id, {
+                        get_entry: (id, abort) => {
+                            if (out[id] === undefined) {
+                                if (entries_started[id] !== undefined) {
+                                    return abort['cycle_detected'](lit.list(stack.concat([id])));
+                                }
+                                else {
+                                    inner_resolve(source.__get_entry_deprecated(id, {
+                                        no_such_entry: () => abort.no_such_entry(null)
+                                    }), id, stack.concat([id]));
+                                }
+                            }
+                            // now it must be resolved, otherwise we would have aborted
+                            return out[id];
+                        },
+                        __get_entry_raw: (id, abort) => {
+                            const x = source.__get_entry_raw(id);
+                            if (x === null) {
+                                return null;
+                            }
+                            else {
+                                if (out[id] === undefined) {
+                                    if (entries_started[id] !== undefined) {
+                                        return abort.cycle_detected(lit.list(stack.concat([id])));
+                                    }
+                                    else {
+                                        inner_resolve(x[0], id, stack.concat([id]));
+                                    }
+                                }
+                                // now it must be resolved, otherwise we would have aborted
+                                return [out[id]];
+                            }
+                        }
+                    }, {
+                        get_entry: (id, abort) => {
+                            const temp_reference = {
+                                'id': id,
+                                'value': undefined,
+                                'abort': abort,
+                            };
+                            cyclic_references.push(temp_reference);
+                            return {
+                                get_circular_dependent: () => {
+                                    if (temp_reference.value === undefined) {
+                                        return abort.accessing_cyclic_sibling_before_it_is_resolved(null);
+                                    }
+                                    else {
+                                        return temp_reference.value;
+                                    }
+                                }
+                            };
+                        }
+                    });
+                };
+                source.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    inner_resolve(value, id, [id]);
+                });
+                cyclic_references.forEach(($) => {
+                    const value = out[$.id];
+                    if (value === undefined) {
+                        $.abort.no_such_entry($.id);
+                    }
+                    else {
+                        $.value = value;
+                    }
+                });
+                return lit.dictionary(out);
+            },
+            resolve_transform: (assign_entry) => {
+                const source = dictionary;
+                const out = {};
+                const entries_started = {};
+                const cyclic_references = [];
+                const inner_resolve = (value, id, stack) => {
+                    if (out[id] !== undefined) {
+                        // already resolved
+                        return;
+                    }
+                    entries_started[id] = null;
+                    out[id] = assign_entry(value, id, {
+                        get_entry: (id, exception) => {
+                            let no_such_entry = false;
+                            if (out[id] === undefined) {
+                                if (entries_started[id] !== undefined) {
+                                    return exception['cycle_detected'](lit.list(stack.concat([id])));
+                                }
+                                else {
+                                    source.__get_possible_entry_deprecated(id).__extract_data(($) => {
+                                        inner_resolve($, id, stack.concat([id]));
+                                        no_such_entry = false;
+                                    }, () => {
+                                        no_such_entry = true;
+                                    });
+                                }
+                            }
+                            // now it must be resolved, otherwise we would have aborted
+                            if (no_such_entry) {
+                                return lit.not_set();
+                            }
+                            else {
+                                return lit.set(out[id]);
+                            }
+                        },
+                        // __get_entry_raw: (
+                        //     id,
+                        //     abort,
+                        // ) => {
+                        //     const x = source.__get_entry_raw(id)
+                        //     if (x === null) {
+                        //         return null
+                        //     } else {
+                        //         if (out[id] === undefined) {
+                        //             if (entries_started[id] !== undefined) {
+                        //                 return abort.cycle_detected(lit.list(stack.concat([id])))
+                        //             } else {
+                        //                 inner_resolve(
+                        //                     x[0],
+                        //                     id,
+                        //                     stack.concat([id])
+                        //                 )
+                        //             }
+                        //         }
+                        //         // now it must be resolved, otherwise we would have aborted
+                        //         return [out[id]]
+                        //     }
+                        // }
+                    }, {
+                        get_entry: (id, exception) => {
+                            const temp_reference = {
+                                'id': id,
+                                'value': undefined,
+                                'exception': exception,
+                            };
+                            cyclic_references.push(temp_reference);
+                            return {
+                                get_circular_dependent: () => {
+                                    if (temp_reference.value === undefined) {
+                                        return exception.accessing_cyclic_sibling_before_it_is_resolved(null);
+                                    }
+                                    else {
+                                        return temp_reference.value;
+                                    }
+                                }
+                            };
+                        }
+                    });
+                };
+                source.__get_raw_copy().forEach(($) => {
+                    const id = $[0];
+                    const value = $[1];
+                    inner_resolve(value, id, [id]);
+                });
+                cyclic_references.forEach(($) => {
+                    const value = out[$.id];
+                    if (value === undefined) {
+                        $.value = lit.not_set();
+                    }
+                    else {
+                        $.value = lit.set(value);
+                    }
+                });
+                return lit.dictionary(out);
+            },
+            sum: (assign_value) => {
+                let sum = 0;
+                dictionary.__get_raw_copy().forEach(($) => {
+                    sum += assign_value($[1]);
+                });
+                return sum;
+            },
+        };
+    };
+    from.list = (list) => {
+        return {
+            amount_of_items: () => {
+                return list.__get_raw_copy().length;
+            },
+            convert: (get_id, get_value, abort) => {
+                const temp = {};
+                list.__get_raw_copy().forEach(($) => {
+                    const id = get_id($);
+                    if (temp[id] !== undefined) {
+                        abort.duplicate_id(id);
+                    }
+                    temp[id] = get_value($);
+                });
+                return lit.dictionary(temp);
+            },
+            filter: (callback) => {
+                return new List_1.List_Class(list.__get_raw_copy().filter(callback));
+            },
+            flatten: (assign_list) => {
+                const out = [];
+                list.__get_raw_copy().forEach(($) => {
+                    const innerList = assign_list($);
+                    innerList.__get_raw_copy().forEach(($) => {
+                        out.push($);
+                    });
+                });
+                return new List_1.List_Class(out);
+            },
+            full_join: (other_list, assign_item) => {
+                const out = [];
+                const maxLength = Math.max(list.__get_raw_copy().length, other_list.__get_raw_copy().length);
+                for (let i = 0; i < maxLength; i++) {
+                    out.push(assign_item(list.__deprecated_get_possible_item_at(i), other_list.__deprecated_get_possible_item_at(i)));
+                }
+                return lit.list(out);
+            },
+            group: (get_id) => {
+                const temp = {};
+                list.__get_raw_copy().forEach(($) => {
+                    const id = get_id($);
+                    if (temp[id] === undefined) {
+                        temp[id] = [];
+                    }
+                    temp[id].push($);
+                });
+                const temp2 = {};
+                Object.keys(temp).forEach((id) => {
+                    temp2[id] = new List_1.List_Class(temp[id]);
+                });
+                return lit.dictionary(temp2);
+            },
+            is_empty: () => {
+                return list.__get_raw_copy().length === 0;
+            },
+            join: (other_list, assign_item) => {
+                const out = [];
+                let index = -1;
+                list.__get_raw_copy().forEach(($) => {
+                    index++;
+                    out.push(assign_item($, other_list.__deprecated_get_possible_item_at(index)));
+                });
+                return lit.list(out);
+            },
+            map: (assign_item) => {
+                return list.__l_map_deprecated(assign_item);
+            },
+            map_optionally: (assign_optional_item) => {
+                const out = [];
+                list.__get_raw_copy().forEach(($) => {
+                    const result = assign_optional_item($);
+                    result.__extract_data(($) => {
+                        out.push($);
+                    }, () => { });
+                });
+                return new List_1.List_Class(out);
+            },
+            map_with_state: (initial_state, assign_item, update_state, wrapup) => {
+                let current_state = initial_state;
+                return wrapup(list.__l_map_deprecated(($) => {
+                    const result = assign_item($, current_state);
+                    current_state = update_state(result, current_state);
+                    return result;
+                }), current_state);
+            },
+            sum: (assign_value) => {
+                let sum = 0;
+                list.__get_raw_copy().forEach(($) => {
+                    sum += assign_value($);
+                });
+                return sum;
+            },
+            reduce_to_boolean: (initial_state, update_state) => {
+                let current_state = initial_state;
+                list.__get_raw_copy().forEach(($) => {
+                    current_state = update_state($, current_state);
+                });
+                return current_state;
+            },
+            reduce_to_number: (initial_state, update_state) => {
+                let current_state = initial_state;
+                list.__get_raw_copy().forEach(($) => {
+                    current_state = update_state($, current_state);
+                });
+                return current_state;
+            },
+            reverse: () => {
+                return new List_1.List_Class(list.__get_raw_copy().slice().reverse());
+            },
+        };
+    };
+    let number;
+    (function (number) {
+        /**
+         * Performs integer division of two numbers with configurable rounding behavior.
+         *
+         * dividend / divisor
+         *
+         * Rounding modes:
+         * - 'towards negative infinity': floor (7.8 → 7, -7.8 → -8)
+         * - 'towards positive infinity': ceiling (7.2 → 8, -7.8 → -7)
+         * - 'towards zero': truncate (7.8 → 7, -7.8 → -7)
+         * - 'towards nearest': round to nearest integer (7.5 → 8, 7.4 → 7)
+         * - 'away from zero': round away from zero (7.2 → 8, -7.2 → -8)
+         */
+        number.divide = ($, divisor, round, abort) => {
+            if (divisor === 0) {
+                abort.divided_by_zero(null);
+            }
+            const quotient = $ / divisor;
+            switch (round[0]) {
+                case 'towards negative infinity':
+                    // Always round down (floor)
+                    return Math.floor(quotient);
+                case 'towards positive infinity':
+                    // Always round up (ceiling)
+                    return Math.ceil(quotient);
+                case 'towards zero':
+                    // Truncate decimal part (round towards zero)
+                    return Math.trunc(quotient);
+                case 'towards nearest':
+                    // Round to nearest integer (0.5 rounds away from zero)
+                    return Math.round(quotient);
+                case 'away from zero':
+                    // Round away from zero
+                    if (quotient >= 0) {
+                        return Math.ceil(quotient);
+                    }
+                    else {
+                        return Math.floor(quotient);
+                    }
+                default:
+                    const _exhaustiveCheck = round;
+                    throw new Error(`Unexpected rounding mode: ${round}`);
+            }
+        };
+    })(number = from.number || (from.number = {}));
+    from.optional = (optional_value) => {
+        return {
+            is_set: () => {
+                return optional_value.__decide(() => true, () => false);
+            },
+            map: (assign_set_value) => {
+                return optional_value.__decide((value) => lit.set(assign_set_value(value)), () => lit.not_set());
+            }
+        };
+    };
+    from.text = (string) => {
+        return {
+            state: (assign_state) => {
+                return assign_state(string);
+            }
+        };
+    };
+})(from || (exports.from = from = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../src/implementation/__internal/sync/transform/transform.ts"],"names":[],"mappings":"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"}

package/dist/implementation/transformer/index.d.ts

@@ -1,12 +1,6 @@
 export * from "../__internal/sync/data_switch";
 export * as decide from "../__internal/sync/decide";
-export * as boolean from "../__internal/sync/transform/boolean";
-export * as dictionary from "../__internal/sync/transform/dictionary";
-export * as group from "../__internal/sync/transform/group";
-export * as list from "../__internal/sync/transform/list";
-export * as number from "../__internal/sync/transform/number";
-export * as optional from "../__internal/sync/transform/optional";
-export * as state from "../__internal/sync/transform/state";
+export * from "../__internal/sync/transform/transform";
 export * as literal from "../__internal/sync/literal";
 import * as p_di from "../../interface/data";
 export declare namespace select {