res-pareto-build 0.9.0 → 0.10.0

package/dist/api.generated.d.ts

@@ -1,26 +1,20 @@
 import * as g_common from "glo-pareto-common";
 import * as g_this from "./glossary";
 export declare namespace A {
-    type buildArray = g_this.SYNC.A.F.BuildArray;
-    type createAsyncArrayBuilder = g_this.ASYNC.A.C.CreateArrayBuilder;
-    type createAsyncIgnoringDictionaryBuilder = g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
-    type createAsyncOverwritingDictionaryBuilder = g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
-    type createSyncIgnoringDictionaryBuilder = ($d: {}, $se: {
+    type buildArray = () => g_this.SYNC.A.F.BuildArray;
+    type buildSafeDictionary = ($: g_this.T.DictionaryBuildStrategy, $se: {
         readonly 'onDuplicate': g_common.SYNC.I.String;
-    }) => g_this.SYNC.A.F.BuildDictionary;
-    type createSyncOverwritingDictionaryBuilder = ($d: {}, $se: {
-        readonly 'onDuplicate': g_common.SYNC.I.String;
-    }) => g_this.SYNC.A.F.BuildDictionary;
-    type createUnsafeAsyncDictionaryBuilder = g_this.ASYNC.A.C.CreateUnsafeDictionaryBuilder;
-    type unsafeSyncBuildDictionary = g_this.SYNC.A.F.BuildDictionary;
+    }) => g_this.SYNC.A.F.BuildSafeDictionary;
+    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 createUnsafeDictionaryBuilder = () => g_this.ASYNC.A.C.CreateUnsafeDictionaryBuilder;
 }
 export type API = {
-    buildArray: A.buildArray;
-    createAsyncArrayBuilder: A.createAsyncArrayBuilder;
-    createAsyncIgnoringDictionaryBuilder: A.createAsyncIgnoringDictionaryBuilder;
-    createAsyncOverwritingDictionaryBuilder: A.createAsyncOverwritingDictionaryBuilder;
-    createSyncIgnoringDictionaryBuilder: A.createSyncIgnoringDictionaryBuilder;
-    createSyncOverwritingDictionaryBuilder: A.createSyncOverwritingDictionaryBuilder;
-    createUnsafeAsyncDictionaryBuilder: A.createUnsafeAsyncDictionaryBuilder;
-    unsafeSyncBuildDictionary: A.unsafeSyncBuildDictionary;
+    readonly 'buildArray': A.buildArray;
+    readonly 'buildSafeDictionary': A.buildSafeDictionary;
+    readonly 'buildUnsafeDictionary': A.buildUnsafeDictionary;
+    readonly 'createArrayBuilder': A.createArrayBuilder;
+    readonly 'createSafeDictionaryBuilder': A.createSafeDictionaryBuilder;
+    readonly 'createUnsafeDictionaryBuilder': A.createUnsafeDictionaryBuilder;
 };

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

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

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

@@ -1,27 +1,26 @@
 import * as pt from 'pareto-core-types';
 export declare namespace T {
     namespace Array {
-        type A<GType> = GType;
+        type A<TType> = TType;
     }
-    type Array<GType> = pt.Array<GType>;
+    type Array<TType> = pt.Array<TType>;
     namespace Dictionary {
-        type D<GType> = GType;
+        type D<TType> = TType;
     }
-    type Dictionary<GType> = pt.Dictionary<GType>;
+    type Dictionary<TType> = pt.Dictionary<TType>;
     namespace DictionaryBuildStrategy {
         namespace ignore { }
-        type ignore<GType> = null;
+        type ignore = null;
         namespace overwrite { }
-        type overwrite<GType> = null;
+        type overwrite = null;
     }
-    type DictionaryBuildStrategy<GType> = ['ignore', null] | ['overwrite', null];
+    type DictionaryBuildStrategy = ['ignore', null] | ['overwrite', null];
     namespace KeyValuePair {
-        type key<GType> = string;
-        type value<GType> = GType;
+        type key<TType> = string;
+        type value<TType> = TType;
     }
-    type KeyValuePair<GType> = {
+    type KeyValuePair<TType> = {
         readonly 'key': string;
-        readonly 'value': GType;
+        readonly 'value': TType;
     };
-    type Type<GType> = GType;
 }

package/dist/implementation.generated.js

@@ -2,20 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$r = void 0;
 const buildArray_native_1 = require("./implementations/buildArray.native");
-const createAsyncArrayBuilder_native_1 = require("./implementations/createAsyncArrayBuilder.native");
-const createAsyncIgnoringDictionaryBuilder_native_1 = require("./implementations/createAsyncIgnoringDictionaryBuilder.native");
-const createAsyncOverwritingDictionaryBuilder_native_1 = require("./implementations/createAsyncOverwritingDictionaryBuilder.native");
-const createSyncIgnoringDictionaryBuilder_native_1 = require("./implementations/createSyncIgnoringDictionaryBuilder.native");
-const createSyncOverwritingDictionaryBuilder_native_1 = require("./implementations/createSyncOverwritingDictionaryBuilder.native");
-const createUnsafeAsyncDictionaryBuilder_native_1 = require("./implementations/createUnsafeAsyncDictionaryBuilder.native");
-const unsafeSyncBuildDictionary_native_1 = require("./implementations/unsafeSyncBuildDictionary.native");
+const buildSafeDictionary_native_1 = require("./implementations/buildSafeDictionary.native");
+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 createUnsafeDictionaryBuilder_native_1 = require("./implementations/createUnsafeDictionaryBuilder.native");
 exports.$r = {
     'buildArray': buildArray_native_1.$$,
-    'createAsyncArrayBuilder': createAsyncArrayBuilder_native_1.$$,
-    'createAsyncIgnoringDictionaryBuilder': createAsyncIgnoringDictionaryBuilder_native_1.$$,
-    'createAsyncOverwritingDictionaryBuilder': createAsyncOverwritingDictionaryBuilder_native_1.$$,
-    'createSyncIgnoringDictionaryBuilder': createSyncIgnoringDictionaryBuilder_native_1.$$,
-    'createSyncOverwritingDictionaryBuilder': createSyncOverwritingDictionaryBuilder_native_1.$$,
-    'createUnsafeAsyncDictionaryBuilder': createUnsafeAsyncDictionaryBuilder_native_1.$$,
-    'unsafeSyncBuildDictionary': unsafeSyncBuildDictionary_native_1.$$,
+    'buildSafeDictionary': buildSafeDictionary_native_1.$$,
+    'buildUnsafeDictionary': buildUnsafeDictionary_native_1.$$,
+    'createArrayBuilder': createArrayBuilder_native_1.$$,
+    'createSafeDictionaryBuilder': createSafeDictionaryBuilder_native_1.$$,
+    'createUnsafeDictionaryBuilder': createUnsafeDictionaryBuilder_native_1.$$,
 };

package/dist/implementations/buildArray.native.js

@@ -25,11 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($c) => {
-    const out = [];
-    $c(($) => {
-        out.push($);
-    });
-    return pi.wrapRawArray(out);
+const $$ = () => {
+    return ($c) => {
+        const out = [];
+        $c(($) => {
+            out.push($);
+        });
+        return pi.wrapRawArray(out);
+    };
 };
 exports.$$ = $$;

package/dist/implementations/buildSafeDictionary.native.d.ts

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

package/dist/implementations/{createSyncOverwritingDictionaryBuilder.native.js → buildSafeDictionary.native.js}

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($d, $se) => {
+const $$ = ($x, $se) => {
     return ($c) => {
         const out = {};
         $c(($) => {
@@ -33,7 +33,19 @@ const $$ = ($d, $se) => {
                 out[$.key] = $.value;
             }
             else {
-                out[$.key] = $.value;
+                const x = $;
+                switch ($x[0]) {
+                    case 'ignore':
+                        pi.cc($x[1], ($) => {
+                        });
+                        break;
+                    case 'overwrite':
+                        pi.cc($x[1], ($) => {
+                            out[x.key] = x.value;
+                        });
+                        break;
+                    default: pi.au($x[0]);
+                }
                 $se.onDuplicate($.key);
             }
         });

package/dist/implementations/buildUnsafeDictionary.native.d.ts

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

package/dist/implementations/{createSyncIgnoringDictionaryBuilder.native.js → buildUnsafeDictionary.native.js}

@@ -25,16 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($d, $se) => {
+const $$ = () => {
     return ($c) => {
         const out = {};
         $c(($) => {
-            if (out[$.key] === undefined) {
-                out[$.key] = $.value;
-            }
-            else {
-                $se.onDuplicate($.key);
+            if (out[$.key] !== undefined) {
+                pi.panic(`entry '${$.key}' already exists`);
             }
+            out[$.key] = $.value;
         });
         return pi.wrapRawDictionary(out);
     };

package/dist/implementations/createArrayBuilder.native.d.ts

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

package/dist/implementations/{createAsyncArrayBuilder.native.js → createArrayBuilder.native.js}

@@ -25,15 +25,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const arr = [];
-    return {
-        'data': ($) => {
-            arr.push($);
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawArray(arr));
-        }
+const $$ = () => {
+    return ($is) => {
+        const arr = [];
+        return {
+            'data': ($) => {
+                arr.push($);
+            },
+            'end': () => {
+                $is.handler(pi.wrapRawArray(arr));
+            }
+        };
     };
 };
 exports.$$ = $$;

package/dist/implementations/createSafeDictionaryBuilder.native.d.ts

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

package/dist/implementations/{createAsyncOverwritingDictionaryBuilder.native.js → createSafeDictionaryBuilder.native.js}

@@ -25,19 +25,36 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
-    return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                $is.duplicatesHandler.data($.key);
+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]);
+                    }
+                    $is.duplicatesHandler.data($.key);
+                }
+                else {
+                    dict[$.key] = $.value;
+                }
+            },
+            'end': () => {
+                $is.handler(pi.wrapRawDictionary(dict));
+                $is.duplicatesHandler.end();
             }
-            dict[$.key] = $.value;
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-            $is.duplicatesHandler.end();
-        }
+        };
     };
 };
 exports.$$ = $$;

package/dist/implementations/createUnsafeDictionaryBuilder.native.d.ts

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

package/dist/implementations/{createAsyncIgnoringDictionaryBuilder.native.js → createUnsafeDictionaryBuilder.native.js}

@@ -25,21 +25,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
-    return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                $is.duplicatesHandler.data($.key);
-            }
-            else {
+const $$ = () => {
+    return ($is) => {
+        const dict = {};
+        return {
+            'data': ($) => {
+                if (dict[$.key] !== undefined) {
+                    pi.panic(`duplicate key: ${$.key}`);
+                }
                 dict[$.key] = $.value;
+            },
+            'end': () => {
+                $is.handler(pi.wrapRawDictionary(dict));
             }
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-            $is.duplicatesHandler.end();
-        }
+        };
     };
 };
 exports.$$ = $$;

package/package.json

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

package/dist/implementations/createAsyncArrayBuilder.native.d.ts

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

package/dist/implementations/createAsyncIgnoringDictionaryBuilder.native.d.ts

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

package/dist/implementations/createAsyncOverwritingDictionaryBuilder.native.d.ts

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

package/dist/implementations/createSyncIgnoringDictionaryBuilder.native.d.ts

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

package/dist/implementations/createSyncOverwritingDictionaryBuilder.native.d.ts

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

package/dist/implementations/createUnsafeAsyncDictionaryBuilder.native.d.ts

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

package/dist/implementations/createUnsafeAsyncDictionaryBuilder.native.js

@@ -1,42 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$$ = void 0;
-const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
-    return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                pi.panic(`duplicate key: ${$.key}`);
-            }
-            dict[$.key] = $.value;
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-        }
-    };
-};
-exports.$$ = $$;

package/dist/implementations/unsafeSyncBuildDictionary.native.d.ts

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

package/dist/implementations/unsafeSyncBuildDictionary.native.js

@@ -1,38 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$$ = void 0;
-const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($c) => {
-    const out = {};
-    $c(($) => {
-        if (out[$.key] !== undefined) {
-            pi.panic(`entry '${$.key}' already exists`);
-        }
-        out[$.key] = $.value;
-    });
-    return pi.wrapRawDictionary(out);
-};
-exports.$$ = $$;