pareto 0.55.0 → 0.57.0

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

@@ -0,0 +1,39 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "JoinData": type(group({
+                "first": member(string()),
+                "second": member(string()),
+            })),
+            "RepeatData": type(group({
+                "contextString": member(string()),
+                "times": member(number()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+
+        "Join": sfunction(typeReference("String"), data(typeReference("JoinData"))),
+        "Repeat": sfunction(typeReference("String"), data(typeReference("RepeatData"))),
+        "Foo": sfunction(typeReference("String"), data(typeReference("String"))),
+    }),
+}

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

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, member, type, group, string, optional, number } from 'pareto/auto.dist/public/shorthands/cosmos'
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
+        "getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
+
+        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
+
+    }
+)

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

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, typeReference, group, member, null_, number, optional, sfunction, string, type,
+    parametrizedType,
+    ref,
+    typeParameter
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
+            "StringArray": type(array(string())),
+            "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+
+
+            "Configuration": type(group({
+                "separator": member(string()),
+                "maximum": member(optional(group({
+                    "maximum": member(number()),
+                    "suffix": member(string()),
+                }))),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null}),
+        "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
+        "GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+        "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/res-typescript/$.data.ts

@@ -0,0 +1,35 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_library from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_serialize } from "./modules/serialize/api.data"
+import { $ as d_naming } from "./modules/naming/api.data"
+
+
+export const $: g_library.D.Library = {
+    'author': "Corno",
+    'description': "provides functionality to support javascript code generation. helps create valid identifiers, quoted strings etcetera",
+    'license': "TBD",
+
+    'type': ['impure', null],
+    'module sets': {
+        'public': {
+            'glossaries': d({}),
+            'modules': d({
+
+                "serialize": d_serialize,
+                "naming": d_naming,
+            }),
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({}),
+        },
+    }
+    // 'modules': d({
+    // }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/res-typescript/modules/naming/api.data.ts

@@ -0,0 +1,15 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "createIdentifier": algorithm("CreateIdentifier", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/res-typescript/modules/naming/glossary.data.ts

@@ -0,0 +1,34 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    data,
+    sfunction,
+    type,
+    group,
+    typeReference,
+    member,
+    string,
+    dictionary,
+    null_,
+    array,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "CreateIdentifier": sfunction(typeReference("String"), data(typeReference("String"))),
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/res-typescript/modules/serialize/api.data.ts

@@ -0,0 +1,18 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "escape": algorithm("Escape", null, {}),
+        "createQuotedString": algorithm("CreateQuotedString", null, {}),
+        "createApostrophedString": algorithm("CreateBacktickedString", null, {}),
+        "createBacktickedString": algorithm("CreateApostrophedString", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/res-typescript/modules/serialize/glossary.data.ts

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    data,
+    sfunction,
+    type,
+    group,
+    typeReference,
+    member,
+    string,
+    dictionary,
+    null_,
+    array,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "EscapeParameters": type(group({
+                "string": member(string()),
+                "escape": member(string()),
+                "patterns to escape": member(array(string())),
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
+        "CreateQuotedString": sfunction(typeReference("String"), data(typeReference("String"))),
+        "CreateApostrophedString": sfunction(typeReference("String"), data(typeReference("String"))),
+        "CreateBacktickedString": sfunction(typeReference("String"), data(typeReference("String"))),
+    }),
+
+}

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

@@ -511,8 +511,7 @@ export const $: g_cosmos.D.Glossary = {
                     },
                     "type": {
                         'type': <g_cosmos.D.Data__Type>['taggedUnion', d({
-                            "impure": <g_cosmos.D.Data__Type>['group', d({})],
-                            "pure": <g_cosmos.D.Data__Type>['group', d({
+                            "composite": <g_cosmos.D.Data__Type>['group', d({
                                 "dependencies": {
                                     'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
                                         "library": {
@@ -528,7 +527,11 @@ export const $: g_cosmos.D.Glossary = {
                                         },
                                     })]],
                                 },
+                                "pure": {
+                                    'type': <g_cosmos.D.Data__Type>['boolean', null],
+                                },
                             })],
+                            "primitive": <g_cosmos.D.Data__Type>['group', d({})],
                         })],
                     },
                 })]
@@ -1416,16 +1419,7 @@ export const $: g_cosmos.D.Glossary = {
                                     "TU": {
                                         'data types': d({}),
                                         'namespaces': d({
-                                            "impure": {
-                                                'data types': d({}),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({}),
-                                                        'namespaces': d({}),
-                                                    },
-                                                }),
-                                            },
-                                            "pure": {
+                                            "composite": {
                                                 'data types': d({}),
                                                 'namespaces': d({
                                                     "G": {
@@ -1454,10 +1448,23 @@ export const $: g_cosmos.D.Glossary = {
                                                                     },
                                                                 }),
                                                             },
+                                                            "pure": {
+                                                                'data types': d({}),
+                                                                'namespaces': d({}),
+                                                            },
                                                         }),
                                                     },
                                                 }),
                                             },
+                                            "primitive": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
                                         }),
                                     },
                                 }),

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

@@ -0,0 +1,122 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_cosmos from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+const a = pd.a
+
+export const $: g_cosmos.D.Glossary = {
+    'imports': d({}),
+    'glossary parameters': d({}),
+    'root': {
+        'data types': d({
+            "Typescript Package": {
+                'parameters': d({}),
+                'type': <g_cosmos.D.Data__Type>['group', d({
+                    "executables": {
+                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
+                            "initializer": {
+                                'type': <g_cosmos.D.Data__Type>['string', null],
+                            },
+                            "module": {
+                                'type': <g_cosmos.D.Data__Type>['string', null],
+                            },
+                        })]],
+                    },
+                    "type": {
+                        'type': <g_cosmos.D.Data__Type>['taggedUnion', d({
+                            "impure": <g_cosmos.D.Data__Type>['group', d({
+                                "dependencies": {
+                                    'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['null', null]],
+                                },
+                                "devDependencies": {
+                                    'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['null', null]],
+                                },
+                            })],
+                            "pure": <g_cosmos.D.Data__Type>['null', null],
+                        })],
+                    },
+                })]
+            },
+        }),
+        'namespaces': d({
+            "Typescript Package": {
+                'data types': d({}),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({}),
+                        'namespaces': d({
+                            "executables": {
+                                'data types': d({}),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({}),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "initializer": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                    "module": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "type": {
+                                'data types': d({}),
+                                'namespaces': d({
+                                    "TU": {
+                                        'data types': d({}),
+                                        'namespaces': d({
+                                            "impure": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({
+                                                            "dependencies": {
+                                                                'data types': d({}),
+                                                                'namespaces': d({
+                                                                    "DX": {
+                                                                        'data types': d({}),
+                                                                        'namespaces': d({}),
+                                                                    },
+                                                                }),
+                                                            },
+                                                            "devDependencies": {
+                                                                'data types': d({}),
+                                                                'namespaces': d({
+                                                                    "DX": {
+                                                                        'data types': d({}),
+                                                                        'namespaces': d({}),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "pure": {
+                                                'data types': d({}),
+                                                'namespaces': d({}),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({}),
+}