astn 0.105.0 → 0.110.0

package/dist/modules/astnTyped/esc/implementation/createMarshallInterface.js

@@ -1,107 +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 __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.createMarshallInterface = void 0;
-const pr = __importStar(require("pareto-runtime"));
-function createMarshallInterface(ds) {
-    function createValueSerializeInterface(value) {
-        return {
-            toDictionary: (callback) => {
-                if (value.type === null || value.type[0] !== "dictionary") {
-                    throw new Error("Unexpected: missing or invalid dictionary");
-                }
-                const dict = value.type[1];
-                callback({
-                    entries: {
-                        forEach: (callback2) => {
-                            pr.Objectkeys(dict).forEach((key) => {
-                                callback2(createValueSerializeInterface(dict[key]), key);
-                            });
-                        },
-                        isEmpty: () => pr.Objectkeys(dict).length === 0,
-                    },
-                });
-            },
-            toGroup: (callback) => {
-                if (value.type === null || value.type[0] !== "group") {
-                    throw new Error("Unexpected: missing or invalid group");
-                }
-                const group = value.type[1];
-                callback({
-                    onProperty: (key, callback2) => {
-                        const property = group[key];
-                        if (property !== undefined) {
-                            callback2(createValueSerializeInterface(property));
-                        }
-                    },
-                });
-            },
-            toList: (callback) => {
-                if (value.type === null || value.type[0] !== "list") {
-                    throw new Error("Unexpected: missing or invalid list");
-                }
-                const list = value.type[1];
-                callback({
-                    elements: {
-                        forEach: (callback2) => {
-                            list.forEach((e) => {
-                                callback2(createValueSerializeInterface(e));
-                            });
-                        },
-                        isEmpty: () => list.length === 0,
-                    },
-                });
-            },
-            toMultilineString: (callback) => {
-                if (value.type === null || value.type[0] !== "multiline string") {
-                    throw new Error("Unexpected: missing or invalid multiline string");
-                }
-                callback(value.type[1]);
-            },
-            toSimpleString: (callback) => {
-                if (value.type === null || value.type[0] !== "simple string") {
-                    throw new Error("Unexpected: missing or invalid simple string");
-                }
-                callback(value.type[1]);
-            },
-            toTaggedUnion: (callback) => {
-                if (value.type === null || value.type[0] !== "tagged union") {
-                    throw new Error("Unexpected: missing or invalid tagged union");
-                }
-                const tu = value.type[1];
-                if (tu.option !== null) {
-                    callback({
-                        option: tu.option,
-                        value: createValueSerializeInterface(tu.value),
-                    });
-                }
-            },
-        };
-    }
-    return {
-        root: createValueSerializeInterface(ds.root),
-    };
-}
-exports.createMarshallInterface = createMarshallInterface;

package/dist/modules/astnTyped/esc/implementation/createProcessorForASTNStreamWithContext.d.ts

@@ -1,14 +0,0 @@
-import { IResourceProvider } from "../../../etc/interface/interfaces/IResourceProvider";
-import { ContextSchemaIssue } from "../../../typedTokenize/interface/interfaces/ContextSchemaIssue";
-import { ContextSchemaResult } from "../../../typedTokenize/interface/interfaces/ContextSchemaResult";
-import { IStructureParser } from "../../../grammar/interface/interfaces/IStructureParser";
-import { CreateExternalSchemaLoader } from "../../../typedTokenize/interface/interfaces/CreateExternalSchemaLoader";
-export declare type CreateStructureParserX<EventAnnotation> = (contextSchema: ContextSchemaResult<EventAnnotation>) => IStructureParser<EventAnnotation>;
-export declare function createProcessorForASTNStreamWithContext<EventAnnotation>($: {
-    schemaFileName: string;
-    serializedDatasetBaseName: string;
-}, $p: {
-    contextSchemaProvider: IResourceProvider;
-    onContextSchemaIssue: ($: ContextSchemaIssue) => void;
-    fixmeOnResult: ($: IStructureParser<EventAnnotation>) => void;
-}, createExternalSchemaLoader: CreateExternalSchemaLoader<EventAnnotation>, createStructureParser: CreateStructureParserX<EventAnnotation>): void;

package/dist/modules/astnTyped/esc/implementation/createProcessorForASTNStreamWithContext.js

@@ -1,72 +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 __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.createProcessorForASTNStreamWithContext = void 0;
-const pr = __importStar(require("pareto-runtime"));
-function createProcessorForASTNStreamWithContext($, $p, createExternalSchemaLoader, createStructureParser) {
-    const onResult = (contextSchema) => {
-        $p.fixmeOnResult(createStructureParser(contextSchema));
-    };
-    if ($.serializedDatasetBaseName === $.schemaFileName) {
-        //don't validate the schema against itself
-        $p.onContextSchemaIssue({
-            type: ["validating schema file against internal schema", {}],
-            severity: ["warning", {}],
-        });
-        onResult(["ignored", {}]);
-    }
-    else {
-        $p.contextSchemaProvider.getResource($.schemaFileName, createExternalSchemaLoader({
-            onFailed: () => {
-                onResult(["has errors", {}]);
-            },
-            onSucces: (schema) => {
-                onResult(["available", schema]);
-            },
-        }), (error) => {
-            switch (error[0]) {
-                case "not found": {
-                    //this is okay, the context schema is optional
-                    onResult(["not available", {}]);
-                    break;
-                }
-                case "other": {
-                    const $ = error[1];
-                    $p.onContextSchemaIssue({
-                        type: ["loading error", {
-                                message: `problems loading schema: ${$.description}`,
-                            }],
-                        severity: ["error", {}],
-                    });
-                    onResult(["has errors", {}]);
-                    break;
-                }
-                default:
-                    pr.au(error[0]);
-            }
-        });
-    }
-}
-exports.createProcessorForASTNStreamWithContext = createProcessorForASTNStreamWithContext;

package/dist/modules/astnTyped/esc/implementation/createSchemaHandler.d.ts

@@ -1,6 +0,0 @@
-import { SchemaSchemaBuilder } from "../../../typedTokenize/interface/interfaces/SchemaSchemaBuilder";
-import { ISchemaAndSideEffects } from "../../../typedTokenize/interface/interfaces/SchemaAndSideEffects";
-import { IStructureHandler } from "../../../grammar/interface/interfaces/IStructureHandler";
-import { CreateTreeParser } from "../../../astn/interface/interfaces/CreateTreeParser";
-import { ITreeHandler } from "../../../grammar/interface/interfaces/ITreeHandler";
-export declare function createSchemaHandler<SchemaAnnotation, BodyAnnotation>(getSchemaSchemaBuilder: (name: string) => SchemaSchemaBuilder<SchemaAnnotation, BodyAnnotation> | null, onError: () => void, onSchema: (schema: ISchemaAndSideEffects<BodyAnnotation> | null) => void, createTreeParser: CreateTreeParser<SchemaAnnotation>, createDummyTreeHandler: () => ITreeHandler<SchemaAnnotation>): IStructureHandler<SchemaAnnotation>;

package/dist/modules/astnTyped/esc/implementation/createSchemaHandler.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchemaHandler = void 0;
-function createSchemaHandler(getSchemaSchemaBuilder, onError, onSchema, createTreeParser, createDummyTreeHandler) {
-    let foundError = false;
-    let schemaDefinitionFound = false;
-    let schemaSchemaBuilder = null;
-    function onSchemaError() {
-        onError();
-        foundError = true;
-    }
-    function createDummyParser() {
-        return createTreeParser(null); //creates parsing errors
-    }
-    return {
-        onNoInternalSchema: () => { },
-        onEmbeddedSchema: ($$) => {
-            onSchemaError();
-            return createDummyTreeHandler();
-        },
-        onSchemaReference: ($$) => {
-            schemaDefinitionFound = true;
-            schemaSchemaBuilder = getSchemaSchemaBuilder($$.token.token.value);
-            if (schemaSchemaBuilder === null) {
-                //console.error(`unknown schema schema '${schemaSchemaReference.data.value}'`)
-                onSchemaError();
-            }
-        },
-        onBody: () => {
-            if (!schemaDefinitionFound) {
-                //console.error("missing schema schema types")
-                onSchemaError();
-                return createDummyParser();
-            }
-            else {
-                if (schemaSchemaBuilder === null) {
-                    if (!foundError) {
-                        throw new Error("UNEXPECTED: SCHEMA PROCESSOR NOT SUBSCRIBED AND NO ERRORS");
-                    }
-                    return createDummyParser();
-                }
-                else {
-                    const x = createTreeParser(schemaSchemaBuilder((error, annotation2) => {
-                        onError();
-                    }, (schemaAndSideEffects) => {
-                        onSchema(schemaAndSideEffects);
-                    }));
-                    return x;
-                }
-            }
-        },
-    };
-}
-exports.createSchemaHandler = createSchemaHandler;

package/dist/modules/astnTyped/esc/implementation/createTreeUnmarshaller.d.ts

@@ -1,12 +0,0 @@
-import { Schema } from "../../../typed/interface/interfaces/definitions";
-import { ITypedTreeHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-import { ITreeHandler } from "../../../grammar/interface/interfaces/ITreeHandler";
-import { DiagnosticSeverity } from "../../../etc/interface/types/DiagnosticSeverity";
-import { UnmarshallError } from "../../../typed/interface/interfaces/UnmarshallError";
-import { DummyHandlers } from "./createValueUnmarshaller";
-export declare function createTreeUnmarshaller<EventAnnotation>($: {
-    schema: Schema;
-    handler: ITypedTreeHandler<EventAnnotation>;
-    onError: (message: UnmarshallError, annotation: EventAnnotation, severity: DiagnosticSeverity) => void;
-    dummyHandlers: DummyHandlers<EventAnnotation>;
-}): ITreeHandler<EventAnnotation>;

package/dist/modules/astnTyped/esc/implementation/createTreeUnmarshaller.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTreeUnmarshaller = void 0;
-const createValueUnmarshaller_1 = require("./createValueUnmarshaller");
-function createTreeUnmarshaller($) {
-    return {
-        root: {
-            exists: (0, createValueUnmarshaller_1.createValueUnmarshaller)($.schema["root type"].get().value, $.handler.root, $.onError, () => { }, null, $.dummyHandlers),
-            missing: () => {
-                (0, createValueUnmarshaller_1.defaultInitializeValue)($.schema["root type"].get().value, $.handler.root, $.onError);
-            },
-        },
-        onEnd: () => $.handler.onEnd({}),
-    };
-}
-exports.createTreeUnmarshaller = createTreeUnmarshaller;

package/dist/modules/astnTyped/esc/implementation/createTypedForker.d.ts

@@ -1,2 +0,0 @@
-import { ITypedTreeHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-export declare function createTypedForker<EventAnnotation>(treeHandlers: ITypedTreeHandler<EventAnnotation>[]): ITypedTreeHandler<EventAnnotation>;

package/dist/modules/astnTyped/esc/implementation/createTypedForker.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypedForker = void 0;
-function createTypedForker(treeHandlers) {
-    function combineTypedValueHandler(handlers) {
-        return {
-            onDictionary: ($) => {
-                const dictHandlers = handlers.map((h) => h.onDictionary($));
-                return {
-                    onClose: ($) => {
-                        dictHandlers.forEach((dh) => dh.onClose($));
-                    },
-                    onEntry: ($) => {
-                        return combineTypedValueHandler(dictHandlers.map((dh) => dh.onEntry($)));
-                    },
-                };
-            },
-            onList: ($) => {
-                const listHandlers = handlers.map((h) => h.onList($));
-                return {
-                    onClose: ($) => {
-                        listHandlers.forEach((dh) => dh.onClose($));
-                    },
-                    onElement: ($) => {
-                        return combineTypedValueHandler(listHandlers.map((dh) => dh.onElement($)));
-                    },
-                };
-            },
-            onTaggedUnion: ($) => {
-                const taggedUnionHandlers = handlers.map((h) => h.onTaggedUnion($));
-                return {
-                    onUnexpectedOption: ($) => {
-                        return combineTypedValueHandler(taggedUnionHandlers.map((tuh) => tuh.onUnexpectedOption($)));
-                    },
-                    onOption: ($) => {
-                        return combineTypedValueHandler(taggedUnionHandlers.map((tuh) => tuh.onOption($)));
-                    },
-                    onEnd: ($) => {
-                        taggedUnionHandlers.forEach((tuh) => tuh.onEnd($));
-                    },
-                };
-            },
-            onSimpleString: ($) => {
-                handlers.forEach((h) => h.onSimpleString($));
-            },
-            onMultilineString: ($) => {
-                handlers.forEach((h) => h.onMultilineString($));
-            },
-            onTypeReference: ($) => {
-                return combineTypedValueHandler(handlers.map((h) => h.onTypeReference($)));
-            },
-            onGroup: ($) => {
-                const shorthandHandlers = handlers.map((h) => h.onGroup($));
-                return {
-                    onUnexpectedProperty: ($) => {
-                        shorthandHandlers.forEach((vth) => vth.onUnexpectedProperty($));
-                    },
-                    onProperty: ($) => {
-                        return combineTypedValueHandler(shorthandHandlers.map((shh) => shh.onProperty($)));
-                    },
-                    onClose: ($) => {
-                        shorthandHandlers.forEach((shh) => shh.onClose($));
-                    },
-                };
-            },
-        };
-    }
-    return {
-        root: combineTypedValueHandler(treeHandlers.map((rh) => rh.root)),
-        onEnd: ($) => {
-            treeHandlers.forEach(($) => {
-                $.onEnd({});
-            });
-        },
-    };
-}
-exports.createTypedForker = createTypedForker;

package/dist/modules/astnTyped/esc/implementation/createValueUnmarshaller.d.ts

@@ -1,31 +0,0 @@
-import { GroupDefinition, OptionDefinition, ValueDefinition } from "../../../typed/interface/interfaces/definitions";
-import * as grammar from "../../../grammar/interface";
-import * as etc from "../../../etc/interface";
-import { UnmarshallError } from "../../../typed/interface/interfaces/UnmarshallError";
-import { ITypedTaggedUnionHandler, ITypedValueHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-import * as typed from "../../../typed/interface";
-import * as t from "../../../typed/interface/interfaces/ITypedTreeHandler";
-export declare type ValueContext<EventAnnotation> = {
-    definition: typed.ValueDefinition;
-    handler: t.ITypedValueHandler<EventAnnotation>;
-};
-export declare type IShorthandParsingState<EventAnnotation> = {
-    wrapup(annotation: EventAnnotation, onError: (message: UnmarshallError, annotation: EventAnnotation, severity: etc.DiagnosticSeverity) => void): void;
-    findNextValue(): ValueContext<EventAnnotation> | null;
-    pushGroup(definition: typed.GroupDefinition, handler: t.ITypedValueHandler<EventAnnotation>): void;
-    pushTaggedUnion(definition: typed.OptionDefinition, taggedUnionHandler: t.ITypedTaggedUnionHandler<EventAnnotation>, optionHandler: t.ITypedValueHandler<EventAnnotation>): void;
-};
-declare type OnError<EventAnnotation> = (message: UnmarshallError, annotation: EventAnnotation, severity: etc.DiagnosticSeverity) => void;
-export declare function defaultInitializeValue<EventAnnotation>(definition: ValueDefinition, handler: ITypedValueHandler<EventAnnotation>, onError: OnError<EventAnnotation>): void;
-declare type MixidIn<EventAnnotation> = {
-    pushGroup: (definition: GroupDefinition, groupContainerHandler: ITypedValueHandler<EventAnnotation>) => grammar.IValueHandler<EventAnnotation>;
-    pushTaggedUnion: (definition: OptionDefinition, taggedUnionHandler: ITypedTaggedUnionHandler<EventAnnotation>, optionHandler: ITypedValueHandler<EventAnnotation>) => void;
-};
-export declare type DummyHandlers<EventAnnotation> = {
-    array: () => grammar.IArrayHandler<EventAnnotation>;
-    object: () => grammar.IObjectHandler<EventAnnotation>;
-    taggedUnion: () => grammar.ITaggedUnionHandler<EventAnnotation>;
-    requiredValue: () => grammar.IRequiredValueHandler<EventAnnotation>;
-};
-export declare function createValueUnmarshaller<EventAnnotation>(definition: ValueDefinition, handler: ITypedValueHandler<EventAnnotation>, onError: OnError<EventAnnotation>, flagNonDefaultPropertiesFound: () => void, mixedIn: null | MixidIn<EventAnnotation>, dummyHandlers: DummyHandlers<EventAnnotation>): grammar.IValueHandler<EventAnnotation>;
-export {};