pareto 0.75.2 → 0.76.1

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

@@ -1,64 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as d_liana_schema } from "./auto.liana_schema.temp_in_between.data"
-import { $ as d_liana_resolver } from "./auto.liana_resolver.temp_in_between.data"
-
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-        "schema": imp(d_liana_schema, {}),
-        "resolver": imp(d_liana_resolver, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Project": type(group({
-                "definitions": prop(dictionary(group({
-                    "type library": prop(group({
-                        "schema": prop(component(externalTypeReference("schema", "Type Library"))),
-                        "resolver": prop(component(externalTypeReference("resolver", "Type Library"))),
-                    })),
-                    "terminal mapping": prop(component(typeReference("Terminal Mapping"))),
-                    "usages": prop(group({
-                        "manual": prop(boolean()),
-                        "temp in between": prop(boolean()),
-                        "transformation target": prop(boolean()),
-                    }))
-                })))
-            })),
-
-            "Terminal Mapping": type(dictionary(stateGroup({
-                "boolean": nothing(),
-                "integer": nothing(),
-                "text": nothing(),
-            }))),
-        }),
-    },
-}

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

@@ -1,38 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Lines": type(list(text())),
-        }),
-    },
-}

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

@@ -1,149 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.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({}),
-            // },
-        }),
-        'data types': d({
-            "Library": type(group({
-                "public": prop(component(typeReference("Module Set"))),
-                "private": prop(component(typeReference("Module Set"))),
-            })),
-            "Module Set": type(dictionary(component(typeReference("Module")))),
-            "Module": type(dictionary(component(typeReference("Algorithm")))),
-            "Algorithm": type(group({
-                "location": prop(component(typeReference("Source Location"))),
-                "tests": prop(optional(dictionary(component(typeReference("Test"))))),
-            })),
-            "Source Location": type(group({
-                "file": prop(text()),
-                "line": prop(integer()),
-                "column": prop(integer()),
-            })),
-            "Test": type(list(component(typeReference("Error")))),
-            "Error": type(stateGroup({
-                "content": component(typeReference("Compare Error"))
-            })),
-            "Compare Error": type(group({
-                "location": prop(component(typeReference("Source Location"))),
-                "path": prop(text()),
-                "type": prop(stateGroup({
-                    "wrong number": group({
-                        "found": prop(integer()),
-                    }),
-                    "wrong text": group({
-                        "found": prop(text()),
-                    }),
-                    "wrong boolean": group({
-                        "found": prop(boolean())
-                    }),
-                    "optional value expected not to be set": nothing(),
-                    "optional value expected to be set": nothing(),
-                    "not the right state": group({
-                        "found": prop(text())
-                    }),
-                    "not enough elements": nothing(),
-                    "too many elements": nothing(),
-                    "superfluous entries": group({
-                        "keys": prop(dictionary(nothing()))
-                    }),
-                    "missing dictionary entry": group({
-                        "key": prop(text()),
-                    }),
-                })),
-
-            })),
-            "Summary": type(group({
-                "number of tests": prop(integer()),
-                "number of missing tests": prop(integer()),
-                "number of errors": prop(integer()),
-            })),
-
-            "intLibrary": type(group({
-                "public": prop(component(typeReference("intModule Set"))),
-                "private": prop(component(typeReference("intModule Set"))),
-            })),
-            "intModule Set": type(dictionary(component(typeReference("intModule")))),
-            "intModule": type(dictionary(component(typeReference("intAlgorithm")))),
-            "intAlgorithm": type(group({
-                "location": prop(component(typeReference("Source Location"))),
-                "status": prop(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(),
-            })),
-            "annotatedStatus": type(stateGroup({
-                "has errors": nothing(),  // red
-                "missing tests": nothing(), // yellow
-                "no tests": nothing(), // grey
-                "success": nothing(), // green
-            })),
-            "annotatedLibrary": type(group({
-                "public": prop(component(typeReference("annotatedModule Set"))),
-                "private": prop(component(typeReference("annotatedModule Set"))),
-            })),
-            "annotatedModule Set": type(group({
-                "status": prop(component(typeReference("annotatedStatus"))),
-                "modules": prop(dictionary(component(typeReference("annotatedModule")))),
-            })),
-            "annotatedModule": type(group({
-                "status": prop(component(typeReference("annotatedStatus"))),
-                "algorithms": prop(dictionary(component(typeReference("annotatedAlgorithm")))),
-            })),
-            "annotatedAlgorithm": type(group({
-                "location": prop(component(typeReference("Source Location"))),
-                "status": prop(component(typeReference("annotatedStatus"))),
-                "tests": prop(dictionary(component(typeReference("annotatedTest")))),
-            })),
-            "annotatedTest": type(group({
-                "status": prop(component(typeReference("annotatedStatus"))),
-                "errors": prop(list(component(typeReference("Error")))),
-            })),
-        }),
-    },
-}

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

@@ -1,38 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Data__Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Text": type(text()),
-        }),
-    },
-}

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

@@ -1,80 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.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(),
-
-                //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")),
-
-                //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": prop(dictionary(component(typeReference("Line")))),
-                    "if empty": prop(component(typeReference("Line"))),
-                    "if not empty": prop(group({
-                        "prefix": prop(component(typeReference("Line"))),
-                        "suffix": prop(component(typeReference("Line"))),
-                        "add commas in between": prop(boolean()),
-                    })),
-                }),
-            }))),
-            "Lines": type(list(group({
-                "indentation": prop(integer()),
-                "text": prop(text()),
-            }))),
-        }),
-    },
-}

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

@@ -1,57 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_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": prop(component(typeReference("Element"))),
-            })),
-            "Element": type(group({
-                "id": prop(text()),
-                "attributes": prop(dictionary(text())),
-                "type": prop(stateGroup({
-                    "mixed": group({
-                        "children": prop(list(stateGroup({
-                            "text": text(),
-                            "element": component(typeReference("Element"))
-                        })))
-                    }),
-                    "elements": group({
-                        "children": prop(list(component(typeReference("Element"))))
-                    })
-                }))
-            })),
-        }),
-    },
-}

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

@@ -1,21 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        /**
-         * use this function to serialize to an intermediate format.
-         * 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.
-         */
-        "transform Root 2 Block": algorithm([
-            `transforms an Alan light model into a fountain pen block`,
-        ], "Transform Root 2 Block", {}),
-    }
-)

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

@@ -1,49 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import { $ as d_in } from "../../glossaries/auto.alan_light.temp_in_between.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.pareto_4gl_type_system"
-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, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Root 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Root"))),
-    }),
-
-}

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

@@ -1,14 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "transform Value 2 Block": algorithm([], "Transform Value 2 Block", {}),
-    }
-)

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

@@ -1,52 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as d_in } from "../../glossaries/astn.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 = {
-    '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({
-        "Transform Value 2 Block": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Value"))),
-    }),
-}

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

@@ -1,16 +0,0 @@
-
-
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "transform Block 2 Lines": algorithm([], "Transform Block 2 Lines", {}),
-    }
-)

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

@@ -1,53 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    imp,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-import { $ as d_in } from "../../glossaries/fountain_pen_indented_file.data"
-import { $ as d_out } from "../../glossaries/fountain_pen_indented_file.data"
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                // "SerializeData": type(group({
-                //     "block": prop(component(externalTypeReference("in", "Block"))),
-                // })),
-                // "String": type(text()),
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Block 2 Lines": sfunction(externalTypeReference("out", "Lines"), data(externalTypeReference("in", "Block"))),
-    }),
-}

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

@@ -1,17 +0,0 @@
-
-
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "transform Lines 2 Lines": algorithm([], "Transform Lines 2 Lines", {}),
-        "stream": algorithm([], "Stream", {}),
-    }
-)