pareto 0.60.0 → 0.62.0

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/testresult.data.ts

@@ -9,125 +9,127 @@ 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({
-            // "intermediate": {
-            //     'namespaces': d({
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({
+                // "intermediate": {
+                //     'namespaces': d({
 
-            //     }),
-            //     'data types': d({}),
-            // },
-            // "summary": {
-            //     'namespaces': d({
+                //     }),
+                //     'data types': d({}),
+                // },
+                // "summary": {
+                //     'namespaces': d({
 
-            //     }),
-            //     'data types': d({}),
-            // },
-        }),
-        'data types': d({
-            "Library": type(group({
-                "public": member(ref(typeReference("Module Set"))),
-                "private": member(ref(typeReference("Module Set"))),
-            })),
-            "Module Set": type(dictionary(ref(typeReference("Module")))),
-            "Module": type(dictionary(ref(typeReference("Algorithm")))),
-            "Algorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "tests": member(optional(dictionary(ref(typeReference("Test"))))),
-            })),
-            "Source Location": type(group({
-                "file": member(string()),
-                "line": member(number()),
-                "column": member(number()),
-            })),
-            "Test": type(array(ref(typeReference("Error")))),
-            "Error": type(taggedUnion({
-                "content": ref(typeReference("Compare Error"))
-            })),
-            "Compare Error": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "path": member(string()),
-                "type": member(taggedUnion({
-                    "wrong number": group({
-                        "found": member(number()),
-                    }),
-                    "wrong text": group({
-                        "found": member(string()),
-                    }),
-                    "wrong boolean": group({
-                        "found": member(boolean())
-                    }),
-                    "optional value expected not to be set": null_(),
-                    "optional value expected to be set": null_(),
-                    "not the right state": group({
-                        "found": member(string())
-                    }),
-                    "not enough elements": null_(),
-                    "too many elements": null_(),
-                    "superfluous entries": group({
-                        "keys": member(dictionary(null_()))
-                    }),
-                    "missing dictionary entry": group({
-                        "key": member(string()),
-                    }),
+                //     }),
+                //     'data types': d({}),
+                // },
+            }),
+            'data types': d({
+                "Library": type(group({
+                    "public": member(ref(typeReference("Module Set"))),
+                    "private": member(ref(typeReference("Module Set"))),
+                })),
+                "Module Set": type(dictionary(ref(typeReference("Module")))),
+                "Module": type(dictionary(ref(typeReference("Algorithm")))),
+                "Algorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+                })),
+                "Source Location": type(group({
+                    "file": member(string()),
+                    "line": member(number()),
+                    "column": member(number()),
                 })),
+                "Test": type(array(ref(typeReference("Error")))),
+                "Error": type(taggedUnion({
+                    "content": ref(typeReference("Compare Error"))
+                })),
+                "Compare Error": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "path": member(string()),
+                    "type": member(taggedUnion({
+                        "wrong number": group({
+                            "found": member(number()),
+                        }),
+                        "wrong text": group({
+                            "found": member(string()),
+                        }),
+                        "wrong boolean": group({
+                            "found": member(boolean())
+                        }),
+                        "optional value expected not to be set": null_(),
+                        "optional value expected to be set": null_(),
+                        "not the right state": group({
+                            "found": member(string())
+                        }),
+                        "not enough elements": null_(),
+                        "too many elements": null_(),
+                        "superfluous entries": group({
+                            "keys": member(dictionary(null_()))
+                        }),
+                        "missing dictionary entry": group({
+                            "key": member(string()),
+                        }),
+                    })),
 
-            })),
-            "Summary": type(group({
-                "number of tests": member(number()),
-                "number of missing tests": member(number()),
-                "number of errors": member(number()),
-            })),
+                })),
+                "Summary": type(group({
+                    "number of tests": member(number()),
+                    "number of missing tests": member(number()),
+                    "number of errors": member(number()),
+                })),
 
-            "intLibrary": type(group({
-                "public": member(ref(typeReference("intModule Set"))),
-                "private": member(ref(typeReference("intModule Set"))),
-            })),
-            "intModule Set": type(dictionary(ref(typeReference("intModule")))),
-            "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
-            "intAlgorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "status": member(taggedUnion({
-                    "no tests": null_(),
-                    "skipped": null_(),
-                    "has tests": dictionary(ref(typeReference("intTest"))),
+                "intLibrary": type(group({
+                    "public": member(ref(typeReference("intModule Set"))),
+                    "private": member(ref(typeReference("intModule Set"))),
                 })),
-            })),
-            "intTest": type(taggedUnion({
-                "has errors": array(ref(typeReference("Error"))),
-                "has no errors": null_(),
-            })),
-            "annotatedStatus": type(taggedUnion({
-                "has errors": null_(),  // red
-                "missing tests": null_(), // yellow
-                "no tests": null_(), // grey
-                "success": null_(), // green
-            })),
-            "annotatedLibrary": type(group({
-                "public": member(ref(typeReference("annotatedModule Set"))),
-                "private": member(ref(typeReference("annotatedModule Set"))),
-            })),
-            "annotatedModule Set": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "modules": member(dictionary(ref(typeReference("annotatedModule")))),
-            })),
-            "annotatedModule": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
-            })),
-            "annotatedAlgorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "tests": member(dictionary(ref(typeReference("annotatedTest")))),
-            })),
-            "annotatedTest": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "errors": member(array(ref(typeReference("Error")))),
-            })),
-        }),
+                "intModule Set": type(dictionary(ref(typeReference("intModule")))),
+                "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+                "intAlgorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "status": member(taggedUnion({
+                        "no tests": null_(),
+                        "skipped": null_(),
+                        "has tests": dictionary(ref(typeReference("intTest"))),
+                    })),
+                })),
+                "intTest": type(taggedUnion({
+                    "has errors": array(ref(typeReference("Error"))),
+                    "has no errors": null_(),
+                })),
+                "annotatedStatus": type(taggedUnion({
+                    "has errors": null_(),  // red
+                    "missing tests": null_(), // yellow
+                    "no tests": null_(), // grey
+                    "success": null_(), // green
+                })),
+                "annotatedLibrary": type(group({
+                    "public": member(ref(typeReference("annotatedModule Set"))),
+                    "private": member(ref(typeReference("annotatedModule Set"))),
+                })),
+                "annotatedModule Set": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+                })),
+                "annotatedModule": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+                })),
+                "annotatedAlgorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+                })),
+                "annotatedTest": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "errors": member(array(ref(typeReference("Error")))),
+                })),
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data.ts

@@ -11,56 +11,58 @@ 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({
-            "Block": type(array(taggedUnion({
-                "nested line": ref(typeReference("Line")),
-                "line": string(),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Block": type(array(taggedUnion({
+                    "nested line": ref(typeReference("Line")),
+                    "line": string(),
 
-                //specials
+                    //specials
 
-                /**
-                 * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
-                 */
-                "block dictionary": dictionary(ref(typeReference("Block"))),
-            }))),
-            "Line": type(array(taggedUnion({
-                "snippet": string(),
-                "indent": ref(typeReference("Block")),
+                    /**
+                     * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
+                     */
+                    "block dictionary": dictionary(ref(typeReference("Block"))),
+                }))),
+                "Line": type(array(taggedUnion({
+                    "snippet": string(),
+                    "indent": ref(typeReference("Block")),
 
-                //specials
-                "apostrophed string": string(),
-                "quoted string": string(),
-                "backticked string": string(),
-                "identifier": string(),
-                // /**
-                //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
-                //  * for example in type arguments.
-                //  */
-                // "array without trailing commas": array(ref(typeReference("Line"))),
-                /**
-                 * this one can be used to transform a dictionary into an array of line parts. The order is not controllable.
-                 * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
-                 */
-                "line dictionary": group({
-                    "dictionary": member(dictionary(ref(typeReference("Line")))),
-                    "if empty": member(ref(typeReference("Line"))),
-                    "if not empty": member(group({
-                        "prefix": member(ref(typeReference("Line"))),
-                        "suffix": member(ref(typeReference("Line"))),
-                        "add commas in between": member(boolean()),
-                    })),
-                }),
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
-        }),
+                    //specials
+                    "apostrophed string": string(),
+                    "quoted string": string(),
+                    "backticked string": string(),
+                    "identifier": string(),
+                    // /**
+                    //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
+                    //  * for example in type arguments.
+                    //  */
+                    // "array without trailing commas": array(ref(typeReference("Line"))),
+                    /**
+                     * this one can be used to transform a dictionary into an array of line parts. The order is not controllable.
+                     * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
+                     */
+                    "line dictionary": group({
+                        "dictionary": member(dictionary(ref(typeReference("Line")))),
+                        "if empty": member(ref(typeReference("Line"))),
+                        "if not empty": member(group({
+                            "prefix": member(ref(typeReference("Line"))),
+                            "suffix": member(ref(typeReference("Line"))),
+                            "add commas in between": member(boolean()),
+                        })),
+                    }),
+                }))),
+                "Lines": type(array(group({
+                    "indentation": member(number()),
+                    "text": member(string()),
+                }))),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/modules/{graphviz_2_string_aware_fountain_pen → alan_light_2_fountain_pen_indented_file_with_escaped_strings}/api.data.ts

@@ -15,6 +15,6 @@ export const $: g_project.D.API = api(
          * Serialization to this format can be done in a pure way.
          * serialization from this format to an array of strings is not pure, specifically for 1 reason so far: apostrophed strings.
          */
-        "map": algorithm("Map", null, {}),
+        "map Root 2 Block": algorithm("Map Root 2 Block", null, {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/{alan_light_2_string_aware_fountain_pen → alan_light_2_fountain_pen_indented_file_with_escaped_strings}/glossary.data.ts

@@ -16,25 +16,27 @@ import {
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import { $ as d_in } from "../../glossaries/auto.alan_light.data"
-import { $ as d_out } from "../../glossaries/string_aware_fountain_pen.data"
+import { $ as d_out } from "../../glossaries/fountain_pen_indented_file_with_escaped_strings.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Root"))),
+        "Map Root 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Root"))),
     }),
 
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/{astn_2_fountain_pen → astn_2_fountain_pen_indented_file_with_escaped_strings}/api.data.ts

@@ -10,6 +10,6 @@ import { glossary, group, member, number, sInterface, sInterfaceMethod, string,
 export const $: g_project.D.API = api(
     glos,
     {
-        "map": algorithm("Map", null, {}),
+        "map Value 2 Block": algorithm("Map Value 2 Block", null, {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/{astn_2_fountain_pen → astn_2_fountain_pen_indented_file_with_escaped_strings}/glossary.data.ts

@@ -14,26 +14,28 @@ import {
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as d_in } from "../../glossaries/astn.data"
-import { $ as d_out } from "../../glossaries/fountain_pen.data"
+import { $ as d_out } from "../../glossaries/fountain_pen_indented_file_with_escaped_strings.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'glossary parameters': d({
+        }),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({
 
     }),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Value"))),
+        "Map Value 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Value"))),
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_graphviz/api.data.ts

@@ -11,7 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "map": algorithm("Map", null, {}),
+        "map Glossary 2 Graph": algorithm("Map Glossary 2 Graph", null, {}),
 
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_graphviz/glossary.data.ts

@@ -12,19 +12,21 @@ import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("out", "Graph"), data(externalTypeReference("in", "Glossary"))),
+        "Map Glossary 2 Graph": sfunction(externalTypeReference("out", "Graph"), data(externalTypeReference("in", "Glossary"))),
 
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_pareto/api.data.ts

@@ -11,7 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "library2ParetoComparators": algorithm("Library2ParetoComparators", null, {}),
+        "map Library 2 Compilation Unit": algorithm("Map Library 2 Compilation Unit", null, {}),
 
     }
 )

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_pareto/glossary.data.ts

@@ -12,22 +12,24 @@ import { $ as d_in } from "../../glossaries/auto.cosmos_type_system.data"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Library2ParetoComparatorsData": type(group({
-                "library": member(ref(externalTypeReference("in", "Library"))),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Library2ParetoComparatorsData": type(group({
+                    "library": member(ref(externalTypeReference("in", "Library"))),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Library2ParetoComparators": sfunction(externalTypeReference("out", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
+        "Map Library 2 Compilation Unit": sfunction(externalTypeReference("out", "Compilation Unit"), data(typeReference("Library2ParetoComparatorsData"))),
 
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_typescript_2_fountain_pen_directory/api.data.ts

@@ -0,0 +1,17 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "map Library 2 Directory": algorithm("Map Library 2 Directory", null, {}),
+
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_typescript_2_fountain_pen_directory/glossary.data.ts

@@ -0,0 +1,38 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as d_out } from "../../glossaries/fountain_pen_directory.data"
+import { $ as d_in } from "../../glossaries/auto.cosmos_typescript.data"
+import { $ as d_cts } from "../../glossaries/auto.cosmos_type_system.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
+            "cts": imp(d_cts, {}),
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "In": type(group({
+                    "$": member(ref(externalTypeReference("in", "Typescript Package"))),
+                    "library": member(ref(externalTypeReference("cts", "Library"))),
+                }))
+            }),
+        },
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map Library 2 Directory": sfunction(externalTypeReference("out", "Directory"), data(typeReference("In"))),
+
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/{fountain_pen_2_fountain_pen → fountain_pen_indented_file_2_fountain_pen_indented_file}/api.data.ts

@@ -12,6 +12,6 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "map": algorithm("Map", null, {}),
+        "map Block 2 Lines": algorithm("Map Block 2 Lines", null, {}),
     }
 )