res-pareto-build 0.10.0 → 0.12.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: {
@@ -8,6 +10,7 @@ export declare namespace A {
     type buildUnsafeDictionary = () => g_this.SYNC.A.F.BuildUnsafeDictionary;
     type createArrayBuilder = () => g_this.ASYNC.A.C.CreateArrayBuilder;
     type createSafeDictionaryBuilder = ($: g_this.T.DictionaryBuildStrategy) => g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
+    type createStringBuilder = ($: g_common.T.String) => g_this.ASYNC.A.C.CreateStringBuilder;
     type createUnsafeDictionaryBuilder = () => g_this.ASYNC.A.C.CreateUnsafeDictionaryBuilder;
 }
 export type API = {
@@ -16,5 +19,6 @@ export type API = {
     readonly 'buildUnsafeDictionary': A.buildUnsafeDictionary;
     readonly 'createArrayBuilder': A.createArrayBuilder;
     readonly 'createSafeDictionaryBuilder': A.createSafeDictionaryBuilder;
+    readonly 'createStringBuilder': A.createStringBuilder;
     readonly 'createUnsafeDictionaryBuilder': A.createUnsafeDictionaryBuilder;
 };

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

@@ -2,37 +2,55 @@ 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;
+        };
+        type StringConsumer<TEndType> = ($: T.String<TEndType>) => void;
+        type StringStreamConsumer<TEndType> = {
+            'data': ($: g_common.T.String) => 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 = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'duplicatesHandler': ASYNC.I.DuplicatesHandler;
+                    readonly 'handler': ASYNC.I.Dictionary<TEndType, TType>;
+                }) => ASYNC.I.Entries<TEndType, TType>;
+            };
         }
         namespace C {
-            type CreateSafeDictionaryBuilder = <TType>($is: {
-                readonly 'duplicatesHandler': ASYNC.I.DuplicatesHandler;
-                readonly 'handler': ASYNC.I.Dictionary<TType>;
-            }) => ASYNC.I.Entries<TType>;
+            type CreateStringBuilder = {
+                'construct': <TEndType>($is: {
+                    readonly 'handler': ASYNC.I.StringConsumer<TEndType>;
+                }) => ASYNC.I.StringStreamConsumer<TEndType>;
+            };
         }
         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 +61,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;
@@ -23,4 +32,12 @@ export declare namespace T {
         readonly 'key': string;
         readonly 'value': TType;
     };
+    namespace String {
+        type end<TEndType> = TEndType;
+        type _lstring<TEndType> = string;
+    }
+    type String<TEndType> = {
+        readonly 'end': TEndType;
+        readonly 'string': string;
+    };
 }

package/dist/implementation.generated.js

@@ -6,6 +6,7 @@ const buildSafeDictionary_native_1 = require("./implementations/buildSafeDiction
 const buildUnsafeDictionary_native_1 = require("./implementations/buildUnsafeDictionary.native");
 const createArrayBuilder_native_1 = require("./implementations/createArrayBuilder.native");
 const createSafeDictionaryBuilder_native_1 = require("./implementations/createSafeDictionaryBuilder.native");
+const createStringBuilder_native_1 = require("./implementations/createStringBuilder.native");
 const createUnsafeDictionaryBuilder_native_1 = require("./implementations/createUnsafeDictionaryBuilder.native");
 exports.$r = {
     'buildArray': buildArray_native_1.$$,
@@ -13,5 +14,6 @@ exports.$r = {
     'buildUnsafeDictionary': buildUnsafeDictionary_native_1.$$,
     'createArrayBuilder': createArrayBuilder_native_1.$$,
     'createSafeDictionaryBuilder': createSafeDictionaryBuilder_native_1.$$,
+    'createStringBuilder': createStringBuilder_native_1.$$,
     'createUnsafeDictionaryBuilder': createUnsafeDictionaryBuilder_native_1.$$,
 };

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/createStringBuilder.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.createStringBuilder;

package/dist/implementations/createStringBuilder.native.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = void 0;
+const $$ = ($c) => {
+    return {
+        'construct': ($is) => {
+            let temp = $c;
+            return {
+                'data': ($) => {
+                    temp += $;
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'string': temp,
+                        '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.12.0",
+  "content-fingerprint": "421d7d800b6fd7f16004729e735e19fe7c2b389b"
 }