pareto 0.60.0 → 0.62.0

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -172,6 +173,47 @@ export const $: g_cosmos.D.Glossary = {
                     })],
                 })]
             },
+            "Data Glossary": {
+                'parameters': d({}),
+                'type': <g_cosmos.D.Data__Type>['group', d({
+                    "glossary parameters": {
+                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                            'context': ['local', null],
+                            'typeXX': "Parameters",
+                            'tailXX': a([]),
+                            'type arguments': d({}),
+                        }]],
+                    },
+                    "imports": {
+                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
+                            "glossary": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Glossary",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                            "type arguments": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Arguments",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                        })]],
+                    },
+                    "root": {
+                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                            'context': ['local', null],
+                            'typeXX': "Namespace",
+                            'tailXX': a([]),
+                            'type arguments': d({}),
+                        }]],
+                    },
+                })]
+            },
             "Data Or Synchronous Interface": {
                 'parameters': d({}),
                 'type': <g_cosmos.D.Data__Type>['taggedUnion', d({
@@ -395,34 +437,14 @@ export const $: g_cosmos.D.Glossary = {
                             },
                         })]],
                     },
-                    "glossary parameters": {
+                    "data glossary": {
                         'type': <g_cosmos.D.Data__Type>['reference', ['type', {
                             'context': ['local', null],
-                            'typeXX': "Parameters",
+                            'typeXX': "Data Glossary",
                             'tailXX': a([]),
                             'type arguments': d({}),
                         }]],
                     },
-                    "imports": {
-                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
-                            "glossary": {
-                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                                    'context': ['local', null],
-                                    'typeXX': "Glossary",
-                                    'tailXX': a([]),
-                                    'type arguments': d({}),
-                                }]],
-                            },
-                            "type arguments": {
-                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                                    'context': ['local', null],
-                                    'typeXX': "Arguments",
-                                    'tailXX': a([]),
-                                    'type arguments': d({}),
-                                }]],
-                            },
-                        })]],
-                    },
                     "interface types": {
                         'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
                             "parameters": {
@@ -459,14 +481,6 @@ export const $: g_cosmos.D.Glossary = {
                             },
                         })]],
                     },
-                    "root": {
-                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                            'context': ['local', null],
-                            'typeXX': "Namespace",
-                            'tailXX': a([]),
-                            'type arguments': d({}),
-                        }]],
-                    },
                 })]
             },
             "Glossary Reference": {
@@ -540,12 +554,19 @@ export const $: g_cosmos.D.Glossary = {
                 'parameters': d({}),
                 'type': <g_cosmos.D.Data__Type>['group', d({
                     "glossaries": {
-                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['reference', ['type', {
-                            'context': ['local', null],
-                            'typeXX': "Glossary",
-                            'tailXX': a([]),
-                            'type arguments': d({}),
-                        }]]],
+                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
+                            "description": {
+                                'type': <g_cosmos.D.Data__Type>['string', null],
+                            },
+                            "glossary": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Glossary",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                        })]],
                     },
                     "modules": {
                         'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['reference', ['type', {
@@ -942,6 +963,47 @@ export const $: g_cosmos.D.Glossary = {
                     },
                 }),
             },
+            "Data Glossary": {
+                'data types': d({}),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({}),
+                        'namespaces': d({
+                            "glossary parameters": {
+                                'data types': d({}),
+                                'namespaces': d({}),
+                            },
+                            "imports": {
+                                'data types': d({}),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({}),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "glossary": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                    "type arguments": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "root": {
+                                'data types': d({}),
+                                'namespaces': d({}),
+                            },
+                        }),
+                    },
+                }),
+            },
             "Data Or Synchronous Interface": {
                 'data types': d({}),
                 'namespaces': d({
@@ -1271,33 +1333,10 @@ export const $: g_cosmos.D.Glossary = {
                                     },
                                 }),
                             },
-                            "glossary parameters": {
+                            "data glossary": {
                                 'data types': d({}),
                                 'namespaces': d({}),
                             },
-                            "imports": {
-                                'data types': d({}),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({}),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({}),
-                                                'namespaces': d({
-                                                    "glossary": {
-                                                        'data types': d({}),
-                                                        'namespaces': d({}),
-                                                    },
-                                                    "type arguments": {
-                                                        'data types': d({}),
-                                                        'namespaces': d({}),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
                             "interface types": {
                                 'data types': d({}),
                                 'namespaces': d({
@@ -1355,10 +1394,6 @@ export const $: g_cosmos.D.Glossary = {
                                     },
                                 }),
                             },
-                            "root": {
-                                'data types': d({}),
-                                'namespaces': d({}),
-                            },
                         }),
                     },
                 }),
@@ -1484,7 +1519,21 @@ export const $: g_cosmos.D.Glossary = {
                                 'namespaces': d({
                                     "DX": {
                                         'data types': d({}),
-                                        'namespaces': d({}),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "description": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                    "glossary": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
+                                        }),
                                     },
                                 }),
                             },
@@ -1676,6 +1725,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -117,6 +118,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({
         "Annotation": null,
@@ -257,6 +258,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -663,6 +664,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -1449,6 +1450,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({
         "Annotation": null,
@@ -971,6 +972,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -857,6 +858,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -0,0 +1,47 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, afunction, boolean, computed, data, dictionary,
+    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
+    taggedUnion,
+    null_,
+    sInterface,
+    sInterfaceMethod,
+    imp,
+    externalTypeReference
+} 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_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, {}),
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Directory": type(group({
+                    "nodes": member(dictionary(taggedUnion({
+                        "allowed manual": null_(),
+                        "allowed automatic": null_(),
+                        "file": ref(externalTypeReference("fp", "Block")),
+                        "template": ref(externalTypeReference("fp", "Block")),
+                        "directory": ref(typeReference("Directory")),
+                    })))
+                }))
+            }),
+        },
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+    }),
+}

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

@@ -0,0 +1,50 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, 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"
+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(array(taggedUnion({
+                    "nested line": ref(typeReference("Line")),
+                    "line": string(),
+                    /**
+                     * this one can be used to make code generation easier.
+                     * it will be inlined
+                     */
+                    "sub block": ref(typeReference("Block")),
+                }))),
+                "Line": type(array(taggedUnion({
+                    "snippet": string(),
+                    "indent": ref(typeReference("Block")),
+                    /**
+                     * this one can be used to make code generation easier.
+                     * it will be inlined
+                     */
+                    "sub line": ref(typeReference("Line")),
+                }))),
+                "Lines": type(array(group({
+                    "indentation": member(number()),
+                    "text": member(string()),
+                }))),
+            }),
+        },
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+    }),
+}

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

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, 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"
+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(array(taggedUnion({
+                    "nested line": ref(typeReference("Line")),
+                    "line": string(),
+                }))),
+                "Line": type(array(taggedUnion({
+                    "snippet": string(),
+                    "apostrophed string": string(),
+                    "quoted string": string(),
+                    "backticked string": string(),
+                    "indent": ref(typeReference("Block"))
+                }))),
+                "Lines": type(array(group({
+                    "indentation": member(number()),
+                    "text": member(string()),
+                }))),
+            }),
+        },
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+    }),
+}

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

@@ -11,14 +11,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({
-            "Lines": type(array(string())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Lines": type(array(string())),
+            }),
+        },
     },
     'interface types': d({
     }),