pareto 0.68.0 → 0.69.0

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

@@ -28,31 +28,24 @@ import { $ as d_fountain_pen } from "./fountain_pen_indented_file.data"
 
 const d = pd.d
 
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({
-        }),
-        'imports': d({
-            "fp": imp(d_fountain_pen['data glossary'], {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Directory": type(group({
-                    "nodes": member(dictionary(stateGroup({
-                        "allowed manual": nothing(),
-                        "allowed automatic": nothing(),
-                        "file": component(externalTypeReference("fp", "Block")),
-                        "template": component(externalTypeReference("fp", "Block")),
-                        "directory": component(typeReference("Directory")),
-                    })))
-                }))
-            }),
-        },
-    },
-    'interface types': d({
-
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({
     }),
-    'algorithm types': d({
+    'imports': d({
+        "fp": imp(d_fountain_pen, {}),
     }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Directory": type(group({
+                "nodes": member(dictionary(stateGroup({
+                    "allowed manual": nothing(),
+                    "allowed automatic": nothing(),
+                    "file": component(externalTypeReference("fp", "Block")),
+                    "template": component(externalTypeReference("fp", "Block")),
+                    "directory": component(typeReference("Directory")),
+                })))
+            }))
+        }),
+    },
 }

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

@@ -24,41 +24,35 @@ import {
 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 = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(list(stateGroup({
+                "nested line": component(typeReference("Line")),
+                "line": text(),
+                /**
+                 * this one can be used to make code generation easier.
+                 * it will be inlined
+                 */
+                "sub block": component(typeReference("Block")),
+            }))),
+            "Line": type(list(stateGroup({
+                "snippet": text(),
+                "indent": component(typeReference("Block")),
+                /**
+                 * this one can be used to make code generation easier.
+                 * it will be inlined
+                 */
+                "sub line": component(typeReference("Line")),
+            }))),
+            "Lines": type(list(group({
+                "indentation": member(integer()),
+                "text": member(text()),
+            }))),
         }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Block": type(list(stateGroup({
-                    "nested line": component(typeReference("Line")),
-                    "line": text(),
-                    /**
-                     * this one can be used to make code generation easier.
-                     * it will be inlined
-                     */
-                    "sub block": component(typeReference("Block")),
-                }))),
-                "Line": type(list(stateGroup({
-                    "snippet": text(),
-                    "indent": component(typeReference("Block")),
-                    /**
-                     * this one can be used to make code generation easier.
-                     * it will be inlined
-                     */
-                    "sub line": component(typeReference("Line")),
-                }))),
-                "Lines": type(list(group({
-                    "indentation": member(integer()),
-                    "text": member(text()),
-                }))),
-            }),
-        },
     },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-    }),
 }

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

@@ -25,33 +25,28 @@ import {
 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 = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(list(stateGroup({
+                "nested line": component(typeReference("Line")),
+                "line": text(),
+            }))),
+            "Line": type(list(stateGroup({
+                "snippet": text(),
+                "apostrophed string": text(),
+                "quoted string": text(),
+                "backticked string": text(),
+                "indent": component(typeReference("Block"))
+            }))),
+            "Lines": type(list(group({
+                "indentation": member(integer()),
+                "text": member(text()),
+            }))),
         }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Block": type(list(stateGroup({
-                    "nested line": component(typeReference("Line")),
-                    "line": text(),
-                }))),
-                "Line": type(list(stateGroup({
-                    "snippet": text(),
-                    "apostrophed string": text(),
-                    "quoted string": text(),
-                    "backticked string": text(),
-                    "indent": component(typeReference("Block"))
-                }))),
-                "Lines": type(list(group({
-                    "indentation": member(integer()),
-                    "text": member(text()),
-                }))),
-            }),
-        },
     },
-    'interface types': d({}),
-    'algorithm types': d({
-    }),
 }

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

@@ -25,20 +25,14 @@ import {
 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 = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Lines": type(list(text())),
         }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Lines": type(list(text())),
-            }),
-        },
     },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-    }),
 }

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

@@ -25,132 +25,125 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 
 const d = pd.d
 
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({
-                // "intermediate": {
-                //     'namespaces': d({
+export const $: g_glossary.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(component(typeReference("Module Set"))),
-                    "private": member(component(typeReference("Module Set"))),
-                })),
-                "Module Set": type(dictionary(component(typeReference("Module")))),
-                "Module": type(dictionary(component(typeReference("Algorithm")))),
-                "Algorithm": type(group({
-                    "location": member(component(typeReference("Source Location"))),
-                    "tests": member(optional(dictionary(component(typeReference("Test"))))),
-                })),
-                "Source Location": type(group({
-                    "file": member(text()),
-                    "line": member(integer()),
-                    "column": member(integer()),
-                })),
-                "Test": type(list(component(typeReference("Error")))),
-                "Error": type(stateGroup({
-                    "content": component(typeReference("Compare Error"))
+            //     }),
+            //     'data types': d({}),
+            // },
+        }),
+        'data types': d({
+            "Library": type(group({
+                "public": member(component(typeReference("Module Set"))),
+                "private": member(component(typeReference("Module Set"))),
+            })),
+            "Module Set": type(dictionary(component(typeReference("Module")))),
+            "Module": type(dictionary(component(typeReference("Algorithm")))),
+            "Algorithm": type(group({
+                "location": member(component(typeReference("Source Location"))),
+                "tests": member(optional(dictionary(component(typeReference("Test"))))),
+            })),
+            "Source Location": type(group({
+                "file": member(text()),
+                "line": member(integer()),
+                "column": member(integer()),
+            })),
+            "Test": type(list(component(typeReference("Error")))),
+            "Error": type(stateGroup({
+                "content": component(typeReference("Compare Error"))
+            })),
+            "Compare Error": type(group({
+                "location": member(component(typeReference("Source Location"))),
+                "path": member(text()),
+                "type": member(stateGroup({
+                    "wrong number": group({
+                        "found": member(integer()),
+                    }),
+                    "wrong text": group({
+                        "found": member(text()),
+                    }),
+                    "wrong boolean": group({
+                        "found": member(boolean())
+                    }),
+                    "optional value expected not to be set": nothing(),
+                    "optional value expected to be set": nothing(),
+                    "not the right state": group({
+                        "found": member(text())
+                    }),
+                    "not enough elements": nothing(),
+                    "too many elements": nothing(),
+                    "superfluous entries": group({
+                        "keys": member(dictionary(nothing()))
+                    }),
+                    "missing dictionary entry": group({
+                        "key": member(text()),
+                    }),
                 })),
-                "Compare Error": type(group({
-                    "location": member(component(typeReference("Source Location"))),
-                    "path": member(text()),
-                    "type": member(stateGroup({
-                        "wrong number": group({
-                            "found": member(integer()),
-                        }),
-                        "wrong text": group({
-                            "found": member(text()),
-                        }),
-                        "wrong boolean": group({
-                            "found": member(boolean())
-                        }),
-                        "optional value expected not to be set": nothing(),
-                        "optional value expected to be set": nothing(),
-                        "not the right state": group({
-                            "found": member(text())
-                        }),
-                        "not enough elements": nothing(),
-                        "too many elements": nothing(),
-                        "superfluous entries": group({
-                            "keys": member(dictionary(nothing()))
-                        }),
-                        "missing dictionary entry": group({
-                            "key": member(text()),
-                        }),
-                    })),
 
-                })),
-                "Summary": type(group({
-                    "number of tests": member(integer()),
-                    "number of missing tests": member(integer()),
-                    "number of errors": member(integer()),
-                })),
+            })),
+            "Summary": type(group({
+                "number of tests": member(integer()),
+                "number of missing tests": member(integer()),
+                "number of errors": member(integer()),
+            })),
 
-                "intLibrary": type(group({
-                    "public": member(component(typeReference("intModule Set"))),
-                    "private": member(component(typeReference("intModule Set"))),
-                })),
-                "intModule Set": type(dictionary(component(typeReference("intModule")))),
-                "intModule": type(dictionary(component(typeReference("intAlgorithm")))),
-                "intAlgorithm": type(group({
-                    "location": member(component(typeReference("Source Location"))),
-                    "status": member(stateGroup({
-                        "no tests": nothing(),
-                        "skipped": nothing(),
-                        "has tests": dictionary(component(typeReference("intTest"))),
-                    })),
-                })),
-                "intTest": type(stateGroup({
-                    "has errors": list(component(typeReference("Error"))),
-                    "has no errors": nothing(),
+            "intLibrary": type(group({
+                "public": member(component(typeReference("intModule Set"))),
+                "private": member(component(typeReference("intModule Set"))),
+            })),
+            "intModule Set": type(dictionary(component(typeReference("intModule")))),
+            "intModule": type(dictionary(component(typeReference("intAlgorithm")))),
+            "intAlgorithm": type(group({
+                "location": member(component(typeReference("Source Location"))),
+                "status": member(stateGroup({
+                    "no tests": nothing(),
+                    "skipped": nothing(),
+                    "has tests": dictionary(component(typeReference("intTest"))),
                 })),
-                "annotatedStatus": type(stateGroup({
-                    "has errors": nothing(),  // red
-                    "missing tests": nothing(), // yellow
-                    "no tests": nothing(), // grey
-                    "success": nothing(), // green
-                })),
-                "annotatedLibrary": type(group({
-                    "public": member(component(typeReference("annotatedModule Set"))),
-                    "private": member(component(typeReference("annotatedModule Set"))),
-                })),
-                "annotatedModule Set": type(group({
-                    "status": member(component(typeReference("annotatedStatus"))),
-                    "modules": member(dictionary(component(typeReference("annotatedModule")))),
-                })),
-                "annotatedModule": type(group({
-                    "status": member(component(typeReference("annotatedStatus"))),
-                    "algorithms": member(dictionary(component(typeReference("annotatedAlgorithm")))),
-                })),
-                "annotatedAlgorithm": type(group({
-                    "location": member(component(typeReference("Source Location"))),
-                    "status": member(component(typeReference("annotatedStatus"))),
-                    "tests": member(dictionary(component(typeReference("annotatedTest")))),
-                })),
-                "annotatedTest": type(group({
-                    "status": member(component(typeReference("annotatedStatus"))),
-                    "errors": member(list(component(typeReference("Error")))),
-                })),
-            }),
-        },
+            })),
+            "intTest": type(stateGroup({
+                "has errors": list(component(typeReference("Error"))),
+                "has no errors": nothing(),
+            })),
+            "annotatedStatus": type(stateGroup({
+                "has errors": nothing(),  // red
+                "missing tests": nothing(), // yellow
+                "no tests": nothing(), // grey
+                "success": nothing(), // green
+            })),
+            "annotatedLibrary": type(group({
+                "public": member(component(typeReference("annotatedModule Set"))),
+                "private": member(component(typeReference("annotatedModule Set"))),
+            })),
+            "annotatedModule Set": type(group({
+                "status": member(component(typeReference("annotatedStatus"))),
+                "modules": member(dictionary(component(typeReference("annotatedModule")))),
+            })),
+            "annotatedModule": type(group({
+                "status": member(component(typeReference("annotatedStatus"))),
+                "algorithms": member(dictionary(component(typeReference("annotatedAlgorithm")))),
+            })),
+            "annotatedAlgorithm": type(group({
+                "location": member(component(typeReference("Source Location"))),
+                "status": member(component(typeReference("annotatedStatus"))),
+                "tests": member(dictionary(component(typeReference("annotatedTest")))),
+            })),
+            "annotatedTest": type(group({
+                "status": member(component(typeReference("annotatedStatus"))),
+                "errors": member(list(component(typeReference("Error")))),
+            })),
+        }),
     },
-    'interface types': d({
-
-    }),
-    'algorithm types': d({
-    }),
 }

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

@@ -25,20 +25,14 @@ import {
 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 = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Text": type(text()),
         }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Text": type(text()),
-            }),
-        },
     },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-    }),
 }

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

@@ -25,61 +25,56 @@ import {
 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 = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Block": type(list(stateGroup({
-                    "nested line": component(typeReference("Line")),
-                    "line": text(),
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(list(stateGroup({
+                "nested line": component(typeReference("Line")),
+                "line": text(),
 
-                    //specials
+                //specials
 
-                    /**
-                     * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
-                     */
-                    "block dictionary": dictionary(component(typeReference("Block"))),
-                }))),
-                "Line": type(list(stateGroup({
-                    "snippet": text(),
-                    "indent": component(typeReference("Block")),
+                /**
+                 * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
+                 */
+                "block dictionary": dictionary(component(typeReference("Block"))),
+            }))),
+            "Line": type(list(stateGroup({
+                "snippet": text(),
+                "indent": component(typeReference("Block")),
 
-                    //specials
-                    "apostrophed string": text(),
-                    "quoted string": text(),
-                    "backticked string": text(),
-                    "identifier": text(),
-                    // /**
-                    //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
-                    //  * for example in type arguments.
-                    //  */
-                    // "array without trailing commas": list(component(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(component(typeReference("Line")))),
-                        "if empty": member(component(typeReference("Line"))),
-                        "if not empty": member(group({
-                            "prefix": member(component(typeReference("Line"))),
-                            "suffix": member(component(typeReference("Line"))),
-                            "add commas in between": member(boolean()),
-                        })),
-                    }),
-                }))),
-                "Lines": type(list(group({
-                    "indentation": member(integer()),
-                    "text": member(text()),
-                }))),
-            }),
-        },
+                //specials
+                "apostrophed string": text(),
+                "quoted string": text(),
+                "backticked string": text(),
+                "identifier": text(),
+                // /**
+                //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
+                //  * for example in type arguments.
+                //  */
+                // "array without trailing commas": list(component(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(component(typeReference("Line")))),
+                    "if empty": member(component(typeReference("Line"))),
+                    "if not empty": member(group({
+                        "prefix": member(component(typeReference("Line"))),
+                        "suffix": member(component(typeReference("Line"))),
+                        "add commas in between": member(boolean()),
+                    })),
+                }),
+            }))),
+            "Lines": type(list(group({
+                "indentation": member(integer()),
+                "text": member(text()),
+            }))),
+        }),
     },
-    'interface types': d({}),
-    'algorithm types': d({
-    }),
 }

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

@@ -0,0 +1,57 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    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"
+const d = pd.d
+
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+
+            "Document": type(group({
+                "root": member(component(typeReference("Element"))),
+            })),
+            "Element": type(group({
+                "id": member(text()),
+                "attributes": member(dictionary(text())),
+                "type": member(stateGroup({
+                    "mixed": group({
+                        "children": member(list(stateGroup({
+                            "text": text(),
+                            "element": component(typeReference("Element"))
+                        })))
+                    }),
+                    "elements": group({
+                        "children": member(list(component(typeReference("Element"))))
+                    })
+                }))
+            })),
+        }),
+    },
+}