pareto 0.75.2 → 0.76.2

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/dictionary/glossary.data.ts

@@ -1,84 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    dictionary,
-    typeReference,
-    data,
-    sfunction,
-    typeParameter,
-    externalTypeReference,
-    parametrizedType,
-    optional,
-    group,
-    component,
-    prop,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
-    type,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
-    integer,
-    text,
-} 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.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Boolean": type(boolean()),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
-                "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                    "dictionary": prop(dictionary(component(typeParameter("Type")))),
-                    "key": prop(text()),
-                })),
-
-                "Number": type(integer()),
-                "PossibleValue": parametrizedType({ "Type": null }, optional(component(typeParameter("Type")))),
-                "Value": parametrizedType({ "Type": null }, component(typeParameter("Type"))),
-
-            }),
-        },
-    },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-        "Contains": sfunction(
-            typeReference("Boolean"),
-            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-        "GetPossibleEntry": sfunction(
-            typeReference("PossibleValue", { "Type": typeParameter("Type") }),
-            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "IsEmpty": sfunction(
-            typeReference("Boolean"),
-            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-        "Size": sfunction(
-            typeReference("Number"),
-            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-        "UnsafeGetEntry": sfunction(
-            typeReference("Value", { "Type": typeParameter("Type") }),
-            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        )
-    }),
-
-}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/api.data.ts

@@ -1,17 +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"
-import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "createFileWriter": algorithm([
-            `create a file writer interface`
-        ], "CreateFileWriter", {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/glossary.data.ts

@@ -1,61 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    data,
-    sfunction,
-    type,
-    group,
-    typeReference,
-    prop,
-    text,
-    dictionary,
-    nothing,
-    list,
-    imp,
-    externalTypeReference,
-    infInit,
-    aInterfaceReference,
-    aInterface,
-    aInterfaceMethod,
-    component,
-    infref,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import { $ as d_lines } from "../../glossaries/lines.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({
-            "lines": imp(d_lines, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "File Path": type(list(text())),
-                "File Write Data": type(group({
-                    "directory path": prop(component(typeReference("File Path"))),
-                    "file name": prop(text()),
-                    "data": prop(component(externalTypeReference("lines", "Lines"))),
-                })),
-                "Root Data": type(group({
-                    "context directory": prop(text()),
-                })),
-            }),
-        },
-    },
-    'interface types': d({
-        "RootFileWriter": aInterface(aInterfaceMethod(typeReference("Root Data"), infref(aInterfaceReference("FileWriter")))),
-        "FileWriter": aInterface(aInterfaceMethod(typeReference("File Write Data"))),
-        "ErrorsHandler": aInterface(aInterfaceMethod(null)),
-    }),
-    'algorithm types': d({
-        "CreateFileWriter": infInit(aInterfaceReference("RootFileWriter"), {
-            "errorshandler": aInterfaceReference("ErrorsHandler"),
-        })
-    }),
-
-}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/api.data.ts

@@ -1,25 +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"
-import { glossary, group, prop, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "parse": algorithm([
-            `parse a json string into a possible data structure`
-        ], "Parse", {}),
-        "serialize": algorithm([
-            `serialize a data structure into a json string`
-        ], "Serialize", {}),
-
-        "unsafeParse": algorithm([
-            `parse a json string into a data structure`,
-            `if the json is invalid, panic`
-        ], "UnsafeParse", {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/glossary.data.ts

@@ -1,55 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    list, afunction, boolean, data, dictionary,
-    glossaryParameter, group, prop, integer, optional, component, sfunction, text, type, typeReference,
-    stateGroup,
-    nothing,
-    sInterface,
-    sInterfaceMethod
-} 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.Glossary = {
-
-    'data glossary': {
-        'glossary parameters': d({
-        }),
-        'imports': d({}),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "String": type(text()),
-                "Result": type(stateGroup({
-                    "success": component(typeReference("Value")),
-                    "error": text(),
-                })),
-                //"Result": type(component(glossaryParameter("Type"))),
-                "Value": type(stateGroup({
-                    "object": dictionary(component(typeReference("Value"))),
-                    "array": list(component(typeReference("Value"))),
-                    "string": text(),
-                    "number": integer(),
-                    "boolean": boolean(),
-                    "null": nothing(),
-                })),
-
-            }),
-        },
-    },
-    'interface types': d({
-
-    }),
-    'algorithm types': d({
-        "Parse": sfunction(typeReference("Result"), data(typeReference("String"))),
-
-        "Serialize": sfunction(typeReference("String"), data(typeReference("Value"))),
-
-        /*use this one if the application may crash if the JSON is invalid*/
-        "UnsafeParse": sfunction(typeReference("Value"), data(typeReference("String"))),
-        //"Convert": sfunction(typeReference("Result"), data(typeReference("Value"))),
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/api.data.ts

@@ -1,26 +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"
-import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "smallerThan": algorithm([
-            `is the focus number smaller than the benchmark number`
-        ], "SmallerThan", {}),
-        "greaterThan": algorithm([
-            `is the focus number greater than the benchmark number`
-        ], "GreaterThan", {}),
-        "isZero": algorithm([
-            `is the number zero`
-        ], "IsZero", {}),
-        "equal": algorithm([
-            `are the two numbers equal`
-        ], "Equal", {}),
-    }
-)

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/glossary.data.ts

@@ -1,42 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    list, boolean, data, dictionary, externalTypeReference, group, prop, integer, optional, sfunction,
-    type, 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.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Boolean": type(boolean()),
-                "Number": type(integer()),
-                "NumberPair": type(group({
-                    "yin": prop(integer()),
-                    "yang": prop(integer()),
-                })),
-                "CompareData": type(group({
-                    "benchmark": prop(integer()),
-                    "focus": prop(integer()),
-                })),
-
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "IsZero": sfunction(typeReference("Boolean"), data(typeReference("Number"))),
-
-        "GreaterThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
-        "SmallerThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
-        "Equal": sfunction(typeReference("Boolean"), data(typeReference("NumberPair"))),
-    }),
-}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/string/api.data.ts

@@ -1,75 +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"
-import { glossary, group, prop, integer, type } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "charCodeAt": algorithm([
-            `returns the unicode value of the character at the specified index`
-        ], "CharCodeAt", {}),
-        "endsWith": algorithm([
-            `does the string end with the specified value`
-        ], "EndsWith", {}),
-        "escape": algorithm([
-            `prepend the string with the escape string if it starts with the specified value`
-        ], "Escape", {}),
-        "fromCharacterArray": algorithm([
-            `create a string from a character array`
-        ], "FromCharacterArray", {}),
-        "fromCharacter": algorithm([
-            `create a string from a single character`
-        ], "FromCharacter", {}),
-        "includes": algorithm([
-            `does the string include the specified value`
-        ], "Includes", {}),
-        "indexOf": algorithm([
-            `returns the index of the optional specified value if it is found`
-        ], "IndexOf", {}),
-        "length": algorithm([
-            `returns the length of the string`
-        ], "Length", {}),
-        "padEnd": algorithm([
-            `pad the string at the end with the specified value until it reaches the specified length`
-        ], "PadEnd", {}),
-        "padStart": algorithm([
-            `pad the string at the start with the specified value until it reaches the specified length`
-        ], "PadStart", {}),
-        "replaceAll": algorithm([
-            `replace all occurrences of the specified value with the replacement value`
-        ], "ReplaceAll", {}),
-        "replaceFirst": algorithm([
-            `replace only the first occurrence of the specified value with the replacement value`
-        ], "ReplaceFirst", {}),
-        "split": algorithm([
-            `split the string into an array of substrings using the specified value as the separator`
-        ], "Split", {}),
-        "splitIn2": algorithm([
-            `split the string into 2 substrings using the specified value as the separator`,
-        ], "SplitIn2", {}),
-        "startsWith": algorithm([
-            `does the string start with the specified value`
-        ], "StartsWith", {}),
-        "substring": algorithm([
-            `get a substring of the string using the specified begin and length`,
-            `it will be empty if the begin is out of bounds`,
-            `it will be truncated if begin + length is out of bounds`,
-        ], "Substring", {}),
-        "toCharacterArray": algorithm([
-            `convert the string to a character array`
-        ], "ToCharacterArray", {}),
-        //"unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", {}),
-
-        //candidates:
-
-        //"trimEnd": algorithm("TrimEnd", {}),
-        // lastIndexOf(searchValue[, fromIndex])
-        // Returns the last index of the specified value.
-
-    }
-)

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

@@ -1,124 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-     list, boolean, data, group, prop, integer, optional, sfunction, streamconsumer, text, type, 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.Glossary = {
-
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "String": type(text()),
-                "Length": type(integer()),
-                "Boolean": type(boolean()),
-                "Character Code": type(integer()),
-                "Possible Character Code": type(optional(integer())),
-                "Possible Position": type(optional(integer())),
-
-                "CharacterCode At Data": type(group({
-                    "contextString": prop(text()),
-                    "index": prop(integer()),
-                })),
-                "CharacterArray": type(list(integer())),
-                "SplitData": type(group({
-                    "contextString": prop(text()),
-                    "splitter": prop(text()),
-                })),
-                "IncludesData": type(group({
-                    "contextString": prop(text()),
-                    "searchString": prop(text()),
-                })),
-                "SplitIn2Result": type(group({
-                    "head": prop(text()),
-                    "tail": prop(optional(text())),
-                })),
-                "SplitResult": type(list(text())),
-                "StartsWithData": type(group({
-                    "contextString": prop(text()),
-                    "searchString": prop(text()),
-                })),
-                "EndsWithData": type(group({
-                    "contextString": prop(text()),
-                    "searchString": prop(text()),
-                })),
-                "SubstringData": type(group({
-                    "contextString": prop(text()),
-                    "begin": prop(integer()),
-                    /**
-                     * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
-                     * and then this function is guaranteed to not have a negative length.
-                     * going with 'end' would require a check for negative values.
-                     */
-                    "length": prop(integer()),
-                })),
-                "ReplaceData": type(group({
-                    "contextString": prop(text()),
-                    "pattern": prop(text()),
-                    "replacement": prop(text()),
-                })),
-                "EscapeParameters": type(group({
-                    "contextString": prop(text()),
-                    "escape": prop(text()),
-                    "patterns to escape": prop(list(text())),
-                })),
-                "PadData": type(group({
-                    "contextString": prop(text()),
-                    "targetLength": prop(integer()),
-                    "padString": prop(text()),
-                })),
-                "IndexOfData": type(group({
-                    "contextString": prop(text()),
-                    "searchString": prop(text()),
-                })),
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        //array
-        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
-        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
-
-        //boolean
-        "EndsWith": sfunction(typeReference("Boolean"), data(typeReference("EndsWithData"))),
-        "Includes": sfunction(typeReference("Boolean"), data(typeReference("IncludesData"))),
-        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
-
-        //number
-        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
-
-        //optional
-        "CharCodeAt": sfunction(typeReference("Possible Character Code"), data(typeReference("CharacterCode At Data"))),
-        "IndexOf": sfunction(typeReference("Possible Position"), data(typeReference("IndexOfData"))),
-
-        //string
-        "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
-        "FromCharacter": sfunction(typeReference("String"), data(typeReference("Character Code"))),
-        "FromCharacterArray": sfunction(typeReference("String"), data(typeReference("CharacterArray"))),
-        "PadEnd": sfunction(typeReference("String"), data(typeReference("PadData"))),
-        "PadStart": sfunction(typeReference("String"), data(typeReference("PadData"))),
-        "ReplaceAll": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
-        "ReplaceFirst": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
-        "Substring": sfunction(typeReference("String"), data(typeReference("SubstringData"))),
-
-        //composite
-        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
-
-
-        //"UnsafeCharCodeAt": sfunction(typeReference("Character Code"), data(typeReference("CharacterCode At Data"))),
-        //"TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
-
-    }),
-}

package/auto.pareto/modules/filesystem_naming/api.data.ts

@@ -1,20 +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,
-    {
-
-        "create Valid File Name": algorithm([
-            `turns a string into a valid file name, escaping all the characters that are not allowed in a file name`,
-            `like slashes, colons, etc.`,
-            `see https://en.wikipedia.org/wiki/Filename#Reserved_characters_and_words`,
-            `and https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file`,
-        ], "Create Valid File Name", {}),
-    }
-)

package/auto.pareto/modules/filesystem_naming/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 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({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Create Valid File Name": type(group({
-                    "raw filename": prop(text()),
-                    "escape spaces": prop(boolean()),
-                })),
-                "Sanitized File Name": type(text()),
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Create Valid File Name": sfunction(typeReference("Sanitized File Name"), data(typeReference("Create Valid File Name"))),
-    }),
-
-}

package/auto.pareto/modules/fountain_pen_indented_file_2_fountain_pen_indented_file_with_escaped_texts/api.data.ts

@@ -1,14 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as sh 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 = sh.api(
-    glos,
-    {
-        "transform Block 2 Block": sh.algorithm([], "Transform Block 2 Block", {}),
-    }
-)

package/auto.pareto/modules/fountain_pen_indented_file_2_fountain_pen_indented_file_with_escaped_texts/glossary.data.ts

@@ -1,29 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as sh from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import { $ as d_in } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file_with_escaped_strings.data"
-import { $ as d_out } from "../../auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.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": sh.imp(d_in, {}),
-            "out": sh.imp(d_out, {}),
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Transform Block 2 Block": sh.sfunction(sh.externalTypeReference("out", "Block"), sh.data(sh.externalTypeReference("in", "Block"))),
-    }),
-
-}

package/auto.pareto/modules/main/api.data.ts

@@ -1,16 +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,
-    {
-        "temp_compile_boekhouding": algorithm([
-                `this function compiles the boekhouding to an Alan file`,
-        ], "Main", {}),
-    }
-)