pareto 0.60.0 → 0.62.0

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/array/glossary.data.ts

@@ -12,76 +12,78 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            //out
-            "Array": parametrizedType(
-                { "Type": null },
-                array(ref(typeParameter("Type")))
-            ),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                //out
+                "Array": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeParameter("Type")))
+                ),
 
-            "ZippedArray": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                array(group({
-                    "benchmark": member(ref(typeParameter("Benchmark"))),
-                    "focus": member(ref(typeParameter("Focus"))),
-                }))
-            ),
+                "ZippedArray": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    array(group({
+                        "benchmark": member(ref(typeParameter("Benchmark"))),
+                        "focus": member(ref(typeParameter("Focus"))),
+                    }))
+                ),
 
-            //in
-            "ArrayOfArrays": parametrizedType(
-                { "Type": null },
-                array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+                //in
+                "ArrayOfArrays": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
 
-            "AppendParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "PrependParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "ArrayTuple": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                group({
-                    "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                    "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
-                })
-            ),
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                "none": null_(),
-            })),
-            // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            // "KeyValuePair": parametrizedType({ "Type": null }, group({
-            //     "key": member(string()),
-            //     "value": member(ref(typeParameter("Type"))),
-            // })),
+                "AppendParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "PrependParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "ArrayTuple": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    group({
+                        "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                    })
+                ),
+                "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                    "single": ref(typeParameter("Type")),
+                    "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                    "none": null_(),
+                })),
+                // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                // "KeyValuePair": parametrizedType({ "Type": null }, group({
+                //     "key": member(string()),
+                //     "value": member(ref(typeParameter("Type"))),
+                // })),
 
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
+                "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                    "value": member(ref(typeParameter("Type"))),
+                    "dependencies": member(dictionary(null_())),
+                }))),
 
 
-            "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
+                "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
 
-        }),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/boolean/glossary.data.ts

@@ -17,19 +17,21 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "Pair Of Booleans": type(group({
-                "yin": member(boolean()),
-                "yang": member(boolean()),
-            })),
-            "Array Of Booleans": type(array(boolean())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Pair Of Booleans": type(group({
+                    "yin": member(boolean()),
+                    "yang": member(boolean()),
+                })),
+                "Array Of Booleans": type(array(boolean())),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/buildInterfaceInitializers/glossary.data.ts

@@ -13,40 +13,43 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
 
-            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "Simple String": type(string()),
+                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "Simple String": type(string()),
 
-            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                "array": member(array(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "String": parametrizedType({ "EndType": null }, group({
-                "string": member(string()),
-                "end": member(ref(typeParameter("EndType"))),
-            })),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
+                "Array": parametrizedType({ "Type": null, "EndType": null }, group({
+                    "array": member(array(ref(typeParameter("Type")))),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
+                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "String": parametrizedType({ "EndType": null }, group({
+                    "string": member(string()),
+                    "end": member(ref(typeParameter("EndType"))),
+                })),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
+
+                "DictionaryBuildStrategy": type(taggedUnion({
+                    "ignore": group({}),
+                    "overwrite": group({}),
+                })),
+                "Startstring": type(string()),
+            }),
+        },
 
-            "DictionaryBuildStrategy": type(taggedUnion({
-                "ignore": group({}),
-                "overwrite": group({}),
-            })),
-            "Startstring": type(string()),
-        }),
     },
     'interface types': d({
         "Array": aInterface(

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/dictionary/api.data.ts

@@ -10,7 +10,21 @@ import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterfa
 export const $: g_project.D.API = api(
     glos,
     {
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+
         "filter": algorithm("Filter", null, {}),
+        /**
+         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
+         */
+        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
+         */
+        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
+         */
+        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
         /**
          * a dictionary with containing entries with values and a key candidate is transformed
          * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
@@ -26,24 +40,15 @@ export const $: g_project.D.API = api(
          * if the key is not unique the function panics
          */
         "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
+        /**
+         * prepends and appends strings to all keys in the dictionary
+         */
+        "wrapKeys": algorithm("WrapKeys", null, {}),
         /**
          * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
          * this last dictionary contains all entries found in the benchmark dictionary.
          * each entry value is optionally supplemented with the value of the focus entry, if found.
          */
         "zip": algorithm("Zip", null, {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
-         */
-        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
-        /**
-         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
-         */
-        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
-        /**
-         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
-         */
-        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
-        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/dictionary/glossary.data.ts

@@ -26,47 +26,53 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "String": type(string()),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
-            "MergeParameters": parametrizedType({ "Type": null }, group({
-                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-            })),
-            "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(optional(ref(typeParameter("Focus")))),
-            }))),
-
-            "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
-            })),
-            "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                "separator": member(string()),
-                "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
-            })),
-            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
-            })),
-            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "String": type(string()),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
+                "MergeParameters": parametrizedType({ "Type": null }, group({
+                    "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                })),
+                "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
+                    "benchmark": member(ref(typeParameter("Benchmark"))),
+                    "focus": member(optional(ref(typeParameter("Focus")))),
+                }))),
 
-            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                    "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+                })),
+                "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
+                    "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                    "separator": member(string()),
+                    "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
+                })),
+                "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+                })),
+                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-        }),
+                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "WrapKeysData": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "prefix": member(string()),
+                    "suffix": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({
     }),
@@ -113,7 +119,13 @@ export const $: g_glossary.D.Glossary = {
         ),
         "DecorateDictionaryEntriesWithKey": sfunction(
             typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "WrapKeys": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("WrapKeysData", { "Type": typeParameter("Type") })),
+            { "Type": null }
         ),
 
     }),

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/nested/glossary.data.ts

@@ -8,14 +8,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/number/glossary.data.ts

@@ -10,30 +10,32 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Number": type(number()),
-            "OptionalNumber": type(optional(number())),
-            "NumberRange": type(array(number())),
-            "NumberTuple": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "SubtractData": type(group({
-                "minuend": member(number()),
-                "subtrahend": member(number()),
-            })),
-            "NumberDictionary": type(dictionary(number())),
-            "NumberArray": type(array(number())),
-
-            "IncrementConfig": type(group({
-                "stepsize": member(number())
-            }))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Number": type(number()),
+                "OptionalNumber": type(optional(number())),
+                "NumberRange": type(array(number())),
+                "NumberTuple": type(group({
+                    "yin": member(number()),
+                    "yang": member(number()),
+                })),
+                "SubtractData": type(group({
+                    "minuend": member(number()),
+                    "subtrahend": member(number()),
+                })),
+                "NumberDictionary": type(dictionary(number())),
+                "NumberArray": type(array(number())),
+
+                "IncrementConfig": type(group({
+                    "stepsize": member(number())
+                }))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -46,7 +48,7 @@ export const $: g_glossary.D.Glossary = {
         * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-     
+
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/optional/glossary.data.ts

@@ -10,18 +10,20 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "OptionalNumber": type(optional(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "OptionalNumber": type(optional(number())),
+                "DivisionData": type(group({
+                    "numerator": member(number()),
+                    "denominator": member(number()),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -32,5 +34,5 @@ export const $: g_glossary.D.Glossary = {
         "Divide": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
         "DivisionRemainder": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
     }),
-     
+
 }

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/resolve/glossary.data.ts

@@ -23,14 +23,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/string/api.data.ts

@@ -10,11 +10,15 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "join": algorithm("Join", null, {}),
+        "join 2 strings": algorithm("Join 2 Strings", null, {}),
+        "join array of strings": algorithm("Join Array Of Strings", null, {}),
         "repeat": algorithm("Repeat", null, {}),
 
-
+        /**
+         * this functon joins an array of strings into a single string, using a separator, and optionally a maximum number of elements to join
+         */
         "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+
         "getLengthAsString": algorithm("GetLengthAsString", null, {}),
         
         //this one implicitely sorts the keys