res-pareto-build 0.10.0 → 0.11.0

package/dist/api.generated.d.ts

@@ -1,5 +1,7 @@
 import * as g_common from "glo-pareto-common";
 import * as g_this from "./glossary";
+export declare namespace D {
+}
 export declare namespace A {
     type buildArray = () => g_this.SYNC.A.F.BuildArray;
     type buildSafeDictionary = ($: g_this.T.DictionaryBuildStrategy, $se: {

package/dist/glossary/algorithmtypes.generated.d.ts

@@ -2,37 +2,43 @@ import { T } from "./datatypes.generated";
 import * as g_common from "glo-pareto-common";
 export declare namespace ASYNC {
     namespace I {
-        type Array<TType> = ($: T.Array<TType>) => void;
-        type Dictionary<TType> = ($: T.Dictionary<TType>) => void;
+        type Array<TEndType, TType> = ($: T.Array<TEndType, TType>) => void;
+        type Dictionary<TEndType, TType> = ($: T.Dictionary<TEndType, TType>) => void;
         type DuplicatesHandler = {
             'data': ($: g_common.T.String) => void;
             'end': () => void;
         };
-        type Elements<TType> = {
+        type Elements<TEndType, TType> = {
             'data': ($: TType) => void;
-            'end': () => void;
+            'end': ($: TEndType) => void;
         };
-        type Entries<TType> = {
+        type Entries<TEndType, TType> = {
             'data': ($: T.KeyValuePair<TType>) => void;
-            'end': () => void;
+            'end': ($: TEndType) => void;
         };
     }
     namespace A {
         namespace C {
-            type CreateArrayBuilder = <TType>($is: {
-                readonly 'handler': ASYNC.I.Array<TType>;
-            }) => ASYNC.I.Elements<TType>;
+            type CreateArrayBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'handler': ASYNC.I.Array<TEndType, TType>;
+                }) => ASYNC.I.Elements<TEndType, TType>;
+            };
         }
         namespace C {
-            type CreateSafeDictionaryBuilder = <TType>($is: {
-                readonly 'duplicatesHandler': ASYNC.I.DuplicatesHandler;
-                readonly 'handler': ASYNC.I.Dictionary<TType>;
-            }) => ASYNC.I.Entries<TType>;
+            type CreateSafeDictionaryBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'duplicatesHandler': ASYNC.I.DuplicatesHandler;
+                    readonly 'handler': ASYNC.I.Dictionary<TEndType, TType>;
+                }) => ASYNC.I.Entries<TEndType, TType>;
+            };
         }
         namespace C {
-            type CreateUnsafeDictionaryBuilder = <TType>($is: {
-                readonly 'handler': ASYNC.I.Dictionary<TType>;
-            }) => ASYNC.I.Entries<TType>;
+            type CreateUnsafeDictionaryBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'handler': ASYNC.I.Dictionary<TEndType, TType>;
+                }) => ASYNC.I.Entries<TEndType, TType>;
+            };
         }
     }
 }
@@ -43,13 +49,13 @@ export declare namespace SYNC {
     }
     namespace A {
         namespace F {
-            type BuildArray = <TType>($c: ($i: SYNC.I.Push<TType>) => void) => T.Array<TType>;
+            type BuildArray = <TType>($c: ($i: SYNC.I.Push<TType>) => void) => g_common.T.Array<TType>;
         }
         namespace F {
-            type BuildSafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => T.Dictionary<TType>;
+            type BuildSafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => g_common.T.Dictionary<TType>;
         }
         namespace F {
-            type BuildUnsafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => T.Dictionary<TType>;
+            type BuildUnsafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => g_common.T.Dictionary<TType>;
         }
     }
 }

package/dist/glossary/datatypes.generated.d.ts

@@ -1,13 +1,22 @@
-import * as pt from 'pareto-core-types';
+import * as g_common from "glo-pareto-common";
+export declare namespace N { }
 export declare namespace T {
     namespace Array {
-        type A<TType> = TType;
+        type array<TEndType, TType> = g_common.T.Array<TType>;
+        type end<TEndType, TType> = TEndType;
     }
-    type Array<TType> = pt.Array<TType>;
+    type Array<TEndType, TType> = {
+        readonly 'array': g_common.T.Array<TType>;
+        readonly 'end': TEndType;
+    };
     namespace Dictionary {
-        type D<TType> = TType;
+        type dictionary<TEndType, TType> = g_common.T.Dictionary<TType>;
+        type end<TEndType, TType> = TEndType;
     }
-    type Dictionary<TType> = pt.Dictionary<TType>;
+    type Dictionary<TEndType, TType> = {
+        readonly 'dictionary': g_common.T.Dictionary<TType>;
+        readonly 'end': TEndType;
+    };
     namespace DictionaryBuildStrategy {
         namespace ignore { }
         type ignore = null;

package/dist/implementations/createArrayBuilder.native.js

@@ -26,16 +26,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
 const $$ = () => {
-    return ($is) => {
-        const arr = [];
-        return {
-            'data': ($) => {
-                arr.push($);
-            },
-            'end': () => {
-                $is.handler(pi.wrapRawArray(arr));
-            }
-        };
+    return {
+        'construct': ($is) => {
+            const arr = [];
+            return {
+                'data': ($) => {
+                    arr.push($);
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'end': $,
+                        'array': pi.wrapRawArray(arr)
+                    });
+                }
+            };
+        }
     };
 };
 exports.$$ = $$;

package/dist/implementations/createSafeDictionaryBuilder.native.js

@@ -26,35 +26,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
 const $$ = ($c) => {
-    return ($is) => {
-        const dict = {};
-        return {
-            'data': ($) => {
-                if (dict[$.key] !== undefined) {
-                    const x = $;
-                    switch ($c[0]) {
-                        case 'ignore':
-                            pi.cc($c[1], ($) => {
-                            });
-                            break;
-                        case 'overwrite':
-                            pi.cc($c[1], ($) => {
-                                dict[x.key] = x.value;
-                            });
-                            break;
-                        default: pi.au($c[0]);
+    return {
+        'construct': ($is) => {
+            const dict = {};
+            return {
+                'data': ($) => {
+                    if (dict[$.key] !== undefined) {
+                        const x = $;
+                        switch ($c[0]) {
+                            case 'ignore':
+                                pi.cc($c[1], ($) => {
+                                });
+                                break;
+                            case 'overwrite':
+                                pi.cc($c[1], ($) => {
+                                    dict[x.key] = x.value;
+                                });
+                                break;
+                            default: pi.au($c[0]);
+                        }
+                        $is.duplicatesHandler.data($.key);
                     }
-                    $is.duplicatesHandler.data($.key);
-                }
-                else {
-                    dict[$.key] = $.value;
+                    else {
+                        dict[$.key] = $.value;
+                    }
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'dictionary': pi.wrapRawDictionary(dict),
+                        'end': $,
+                    });
+                    $is.duplicatesHandler.end();
                 }
-            },
-            'end': () => {
-                $is.handler(pi.wrapRawDictionary(dict));
-                $is.duplicatesHandler.end();
-            }
-        };
+            };
+        }
     };
 };
 exports.$$ = $$;

package/dist/implementations/createUnsafeDictionaryBuilder.native.js

@@ -26,19 +26,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
 const $$ = () => {
-    return ($is) => {
-        const dict = {};
-        return {
-            'data': ($) => {
-                if (dict[$.key] !== undefined) {
-                    pi.panic(`duplicate key: ${$.key}`);
+    return {
+        'construct': ($is) => {
+            const dict = {};
+            return {
+                'data': ($) => {
+                    if (dict[$.key] !== undefined) {
+                        pi.panic(`duplicate key: ${$.key}`);
+                    }
+                    dict[$.key] = $.value;
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'dictionary': pi.wrapRawDictionary(dict),
+                        'end': $
+                    });
                 }
-                dict[$.key] = $.value;
-            },
-            'end': () => {
-                $is.handler(pi.wrapRawDictionary(dict));
-            }
-        };
+            };
+        }
     };
 };
 exports.$$ = $$;

package/package.json

@@ -3,8 +3,8 @@
   "license": "TBD",
   "description": "this library provides functions to build arrays and dictionaries by adding entries/elements one by one",
   "dependencies": {
-    "glo-pareto-common": "^0.26.0",
-    "pareto-core-internals": "^0.13.2"
+    "glo-pareto-common": "^0.28.0",
+    "pareto-core-internals": "^0.13.4"
   },
   "files": [
     "dist"
@@ -16,6 +16,6 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "name": "res-pareto-build",
-  "version": "0.10.0",
-  "content-fingerprint": "ce2f706ad4e8e2d0c02b7aefd7404d8093e9edbc"
+  "version": "0.11.0",
+  "content-fingerprint": "12ff37e1a36c0f336eedf4891c3d4e189f76cca7"
 }