astn 0.105.0 → 0.110.0

package/dist/modules/grammar/interface/types/tokens.d.ts

@@ -1,25 +0,0 @@
-import { Wrapping as grammar } from "./ContentToken";
-import { AnnotatedToken } from "./AnnotatedToken";
-export declare type OpenObject = {
-    readonly "type": ["verbose group", {}] | ["dictionary", {}];
-};
-export declare type OpenArray = {
-    readonly "type": ["shorthand group", {}] | ["list", {}];
-};
-export declare type SimpleString = {
-    readonly "wrapping": grammar;
-    readonly "value": string;
-};
-export declare type MultilineString = {
-    readonly "lines": string[];
-};
-export declare type CloseObject = {};
-export declare type CloseArray = {};
-export declare type TaggedUnion = {};
-export declare type CloseArrayToken<EventAnnotation> = AnnotatedToken<CloseArray, EventAnnotation>;
-export declare type CloseObjectToken<EventAnnotation> = AnnotatedToken<CloseObject, EventAnnotation>;
-export declare type OpenArrayToken<EventAnnotation> = AnnotatedToken<OpenArray, EventAnnotation>;
-export declare type OpenObjectToken<EventAnnotation> = AnnotatedToken<OpenObject, EventAnnotation>;
-export declare type SimpleStringToken<EventAnnotation> = AnnotatedToken<SimpleString, EventAnnotation>;
-export declare type MultilineStringToken<EventAnnotation> = AnnotatedToken<MultilineString, EventAnnotation>;
-export declare type TaggedUnionToken<EventAnnotation> = AnnotatedToken<TaggedUnion, EventAnnotation>;

package/dist/modules/grammar/interface/types/tokens.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/schema/esc/implementation/createASTNSchemaBuilder.generated.d.ts

@@ -1,3 +0,0 @@
-import * as astn from "../../../astn/interface";
-import * as typedTokenize from "../../../typedTokenize/interface";
-export declare function createASTNSchemaBuilder<SchemaAnnotation, BodyAnnotation>(createExpectContext: astn.CreateExpectContext<SchemaAnnotation>, createDummyTypedHandler: astn.CreateDummyTypedHandler<BodyAnnotation>): typedTokenize.SchemaSchemaBuilder<SchemaAnnotation, BodyAnnotation> | null;

package/dist/modules/schema/esc/implementation/createASTNSchemaBuilder.generated.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createASTNSchemaBuilder = void 0;
-const createASTNSchemaDeserializer_generated_1 = require("./createASTNSchemaDeserializer.generated"); //FIXME
-function createASTNSchemaBuilder(createExpectContext, createDummyTypedHandler) {
-    return (onError2, onSchema) => {
-        let foundErrors = false;
-        return (0, createASTNSchemaDeserializer_generated_1.createASTNSchemaDeserializer)(createExpectContext({
-            issueHandler: ($) => {
-                if ($.severity === ["error", {}]) {
-                    onError2(["expect", $.issue], $.annotation);
-                }
-            },
-            duplicateEntrySeverity: ["warning", {}],
-            onDuplicateEntry: ["ignore", {}],
-        }), (message, annotation) => {
-            foundErrors = true;
-            onError2(["validation", { message: message }], annotation);
-        }, (schema) => {
-            if (schema === null) {
-                if (foundErrors === false) {
-                    throw new Error("no schema, no errors");
-                }
-            }
-            else {
-                onSchema({
-                    getSchema: () => schema,
-                    createStreamingValidator: () => {
-                        return createDummyTypedHandler();
-                    },
-                });
-            }
-        });
-    };
-}
-exports.createASTNSchemaBuilder = createASTNSchemaBuilder;

package/dist/modules/schema/esc/implementation/createASTNSchemaDeserializer.generated.d.ts

@@ -1,4 +0,0 @@
-import * as x from "../../interface/types/generated_schema";
-import { ITreeHandler } from "../../../grammar/interface/interfaces/ITreeHandler";
-import { IExpectContext } from "../../../astn/interface/interfaces/IExpectContext";
-export declare function createASTNSchemaDeserializer<EventAnnotation>(context: IExpectContext<EventAnnotation>, raiseValidationError: (message: string, annotation: EventAnnotation) => void, callback: (result: x.__root_T | null) => void): ITreeHandler<EventAnnotation>;

package/dist/modules/schema/esc/implementation/createASTNSchemaDeserializer.generated.js

@@ -1,448 +0,0 @@
-"use strict";
-/*eslint
-    "@typescript-eslint/no-unused-vars": 0,
-    "@typescript-eslint/no-shadow": 0,
-    "camelcase": 0,
-    "dot-notation": 0,
-    "no-underscore-dangle": 0,
-    "quote-props": 0
-*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createASTNSchemaDeserializer = void 0;
-const pr = __importStar(require("pareto-runtime"));
-function createASTNSchemaDeserializer(context, raiseValidationError, callback) {
-    const resolveRegistry = pr.createResolveRegistry();
-    function wrap(handler) {
-        return {
-            exists: handler,
-            missing: () => { },
-        };
-    }
-    function _generateHandler_root(callback) {
-        return ((callback) => {
-            let _root_type_v = null;
-            const _types_v = pr.createDictionaryBuilder();
-            return context.expectVerboseGroup({
-                properties: {
-                    "root type": {
-                        onNotExists: () => { },
-                        onExists: () => wrap(context.expectQuotedString({
-                            warningOnly: true,
-                            callback: ($) => {
-                                _root_type_v = {
-                                    annotation: $.token.annotation,
-                                    value: $.token.token.value,
-                                };
-                            },
-                        })),
-                    },
-                    "types": {
-                        onNotExists: () => { },
-                        onExists: () => wrap(context.expectDictionary({
-                            onProperty: (propertyData) => {
-                                return wrap(((callback) => {
-                                    let _value_v = null;
-                                    return context.expectVerboseGroup({
-                                        properties: {
-                                            "value": {
-                                                onNotExists: () => { },
-                                                onExists: () => wrap(_generateHandler_value((node) => _value_v = node, _types_v.toDictionary().getLookup())),
-                                            },
-                                        },
-                                        onEnd: () => {
-                                            if (_value_v === null) {
-                                                _value_v = {
-                                                    "type": ["simple string", {
-                                                            "default value": "",
-                                                            "quoted": true,
-                                                        }],
-                                                };
-                                            }
-                                            callback({
-                                                "value": _value_v,
-                                            });
-                                        },
-                                    });
-                                })((node) => _types_v.add(propertyData.token.token.value, node)));
-                            },
-                        })),
-                    },
-                },
-                onEnd: ($) => {
-                    // if (_root_type_v === null) {
-                    //     _root_type_v = ""
-                    // }
-                    callback({
-                        "root type": pr.createReference("root type", _root_type_v, "root", $.annotation, _types_v.toDictionary().getLookup(), resolveRegistry.getRegistrater()),
-                        "types": _types_v.toDictionary(),
-                    });
-                },
-            });
-        })((node) => callback(node));
-    }
-    function _generateHandler_simple_string(callback) {
-        return ((callback) => {
-            let _default_value_v = null;
-            let _quoted_v = null;
-            return context.expectVerboseGroup({
-                properties: {
-                    "default value": {
-                        onNotExists: () => { },
-                        onExists: () => wrap(context.expectQuotedString({
-                            warningOnly: true,
-                            callback: ($) => {
-                                _default_value_v = $.token.token.value;
-                            },
-                        })),
-                    },
-                    "quoted": {
-                        onNotExists: () => { },
-                        onExists: () => wrap(context.expectTaggedUnion({
-                            options: {
-                                "yes": () => {
-                                    return wrap(context.expectGroup({}));
-                                },
-                                "no": () => {
-                                    _quoted_v = false;
-                                    return wrap(context.expectGroup({}));
-                                },
-                            },
-                        })),
-                    },
-                },
-                onEnd: () => {
-                    if (_default_value_v === null) {
-                        _default_value_v = "";
-                    }
-                    if (_quoted_v === null) {
-                        _quoted_v = true;
-                    }
-                    callback({
-                        "default value": _default_value_v,
-                        "quoted": _quoted_v,
-                    });
-                },
-            });
-        })((node) => callback(node));
-    }
-    function _generateHandler_value(callback, types) {
-        return ((callback) => {
-            let _type_v = null;
-            return context.expectVerboseGroup({
-                properties: {
-                    "type": {
-                        onNotExists: () => { },
-                        onExists: () => wrap(context.expectTaggedUnion({
-                            options: {
-                                "dictionary": () => {
-                                    return wrap(((callback) => {
-                                        let _key_v = null;
-                                        let _value_v = null;
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "key": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(_generateHandler_simple_string((node) => _key_v = node)),
-                                                },
-                                                "value": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(_generateHandler_value((node) => _value_v = node, types)),
-                                                },
-                                            },
-                                            onEnd: () => {
-                                                if (_key_v === null) {
-                                                    _key_v = {
-                                                        "default value": "",
-                                                        "quoted": true,
-                                                    };
-                                                }
-                                                if (_value_v === null) {
-                                                    _value_v = {
-                                                        "type": ["simple string", {
-                                                                "default value": "",
-                                                                "quoted": true,
-                                                            }],
-                                                    };
-                                                }
-                                                callback({
-                                                    "key": _key_v,
-                                                    "value": _value_v,
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["dictionary", node]));
-                                },
-                                "group": () => {
-                                    return wrap(((callback) => {
-                                        const _properties_v = pr.createDictionaryBuilder();
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "properties": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectDictionary({
-                                                        onProperty: (propertyData) => {
-                                                            return wrap(((callback) => {
-                                                                let _value_v = null;
-                                                                return context.expectVerboseGroup({
-                                                                    properties: {
-                                                                        "value": {
-                                                                            onNotExists: () => { },
-                                                                            onExists: () => wrap(_generateHandler_value((node) => _value_v = node, types)),
-                                                                        },
-                                                                    },
-                                                                    onEnd: () => {
-                                                                        if (_value_v === null) {
-                                                                            _value_v = {
-                                                                                "type": ["simple string", {
-                                                                                        "default value": "",
-                                                                                        "quoted": true,
-                                                                                    }],
-                                                                            };
-                                                                        }
-                                                                        callback({
-                                                                            "value": _value_v,
-                                                                        });
-                                                                    },
-                                                                });
-                                                            })((node) => _properties_v.add(propertyData.token.token.value, node)));
-                                                        },
-                                                    })),
-                                                },
-                                            },
-                                            onEnd: () => {
-                                                callback({
-                                                    "properties": _properties_v.toDictionary(),
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["group", node]));
-                                },
-                                "list": () => {
-                                    return wrap(((callback) => {
-                                        let _value_v = null;
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "value": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(_generateHandler_value((node) => _value_v = node, types)),
-                                                },
-                                            },
-                                            onEnd: () => {
-                                                if (_value_v === null) {
-                                                    _value_v = {
-                                                        "type": ["simple string", {
-                                                                "default value": "",
-                                                                "quoted": true,
-                                                            }],
-                                                    };
-                                                }
-                                                callback({
-                                                    "value": _value_v,
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["list", node]));
-                                },
-                                "multiline string": () => {
-                                    return wrap(((callback) => {
-                                        return context.expectVerboseGroup({
-                                            properties: {},
-                                            onEnd: () => {
-                                                callback({});
-                                            },
-                                        });
-                                    })((node) => _type_v = ["multiline string", node]));
-                                },
-                                "simple string": () => {
-                                    return wrap(((callback) => {
-                                        let _default_value_v = null;
-                                        let _quoted_v = null;
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "default value": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectQuotedString({
-                                                        warningOnly: true,
-                                                        callback: ($) => {
-                                                            _default_value_v = $.token.token.value;
-                                                        },
-                                                    })),
-                                                },
-                                                "quoted": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectTaggedUnion({
-                                                        options: {
-                                                            "yes": () => {
-                                                                return wrap(context.expectGroup({}));
-                                                            },
-                                                            "no": () => {
-                                                                _quoted_v = false;
-                                                                return wrap(context.expectGroup({}));
-                                                            },
-                                                        },
-                                                    })),
-                                                },
-                                            },
-                                            onEnd: () => {
-                                                if (_default_value_v === null) {
-                                                    _default_value_v = "";
-                                                }
-                                                if (_quoted_v === null) {
-                                                    _quoted_v = true;
-                                                }
-                                                callback({
-                                                    "default value": _default_value_v,
-                                                    "quoted": _quoted_v,
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["simple string", node]));
-                                },
-                                "tagged union": () => {
-                                    return wrap(((callback) => {
-                                        let _default_option_v = null;
-                                        const _options_v = pr.createDictionaryBuilder();
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "default option": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectQuotedString({
-                                                        warningOnly: true,
-                                                        callback: ($) => {
-                                                            _default_option_v = {
-                                                                value: $.token.token.value,
-                                                                annotation: $.token.annotation,
-                                                            };
-                                                        },
-                                                    })),
-                                                },
-                                                "options": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectDictionary({
-                                                        onProperty: (propertyData) => {
-                                                            return wrap(((callback) => {
-                                                                let _value_v = null;
-                                                                return context.expectVerboseGroup({
-                                                                    properties: {
-                                                                        "value": {
-                                                                            onNotExists: () => { },
-                                                                            onExists: () => wrap(_generateHandler_value((node) => _value_v = node, types)),
-                                                                        },
-                                                                    },
-                                                                    onEnd: () => {
-                                                                        if (_value_v === null) {
-                                                                            _value_v = {
-                                                                                "type": ["simple string", {
-                                                                                        "default value": "",
-                                                                                        "quoted": true,
-                                                                                    }],
-                                                                            };
-                                                                        }
-                                                                        callback({
-                                                                            "value": _value_v,
-                                                                        });
-                                                                    },
-                                                                });
-                                                            })((node) => _options_v.add(propertyData.token.token.value, node)));
-                                                        },
-                                                    })),
-                                                },
-                                            },
-                                            onEnd: ($) => {
-                                                // if (_default_option_v === null) {
-                                                //     _default_option_v = ""
-                                                // }
-                                                callback({
-                                                    "default option": pr.createReference("default option", _default_option_v, "yes", $.annotation, _options_v.toDictionary().getLookup(), resolveRegistry.getRegistrater()),
-                                                    "options": _options_v.toDictionary(),
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["tagged union", node]));
-                                },
-                                "type reference": () => {
-                                    return wrap(((callback) => {
-                                        let _type_v = null;
-                                        return context.expectVerboseGroup({
-                                            properties: {
-                                                "type": {
-                                                    onNotExists: () => { },
-                                                    onExists: () => wrap(context.expectQuotedString({
-                                                        warningOnly: true,
-                                                        callback: ($) => {
-                                                            _type_v = {
-                                                                value: $.token.token.value,
-                                                                annotation: $.token.annotation,
-                                                            };
-                                                        },
-                                                    })),
-                                                },
-                                            },
-                                            onEnd: ($) => {
-                                                // if (_type_v === null) {
-                                                //     _type_v = ""
-                                                // }
-                                                callback({
-                                                    "type": pr.createReference("type", _type_v, "", $.annotation, types, resolveRegistry.getRegistrater()),
-                                                });
-                                            },
-                                        });
-                                    })((node) => _type_v = ["type reference", node]));
-                                },
-                            },
-                        })),
-                    },
-                },
-                onEnd: () => {
-                    if (_type_v === null) {
-                        _type_v = ["simple string", {
-                                "default value": "",
-                                "quoted": true,
-                            }];
-                    }
-                    callback({
-                        "type": _type_v,
-                    });
-                },
-            });
-        })((node) => callback(node));
-    }
-    return {
-        "root": wrap(_generateHandler_root((root) => {
-            const success = resolveRegistry.resolve((error) => {
-                raiseValidationError(error.message, error.annotation);
-            });
-            if (success) {
-                callback(root);
-            }
-            else {
-                callback(null);
-            }
-        })),
-        onEnd: () => { },
-    };
-}
-exports.createASTNSchemaDeserializer = createASTNSchemaDeserializer;

package/dist/modules/schema/esc/implementation/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./createASTNSchemaBuilder.generated";
-export * from "./createASTNSchemaDeserializer.generated";
-export * from "./serializeSchema.generated";

package/dist/modules/schema/esc/implementation/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./createASTNSchemaBuilder.generated"), exports);
-__exportStar(require("./createASTNSchemaDeserializer.generated"), exports);
-__exportStar(require("./serializeSchema.generated"), exports);

package/dist/modules/schema/esc/implementation/serializeSchema.generated.d.ts

@@ -1,3 +0,0 @@
-import { Schema } from "../../../typed/interface/interfaces/definitions";
-import { ContentToken } from "../../../grammar/interface/types/ContentToken";
-export declare function serializeSchema(schema: Schema, sendEvent: (event: ContentToken) => void): void;