astn 0.105.0 → 0.110.0

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

@@ -1,212 +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.createASTNUnmarshaller = void 0;
-const pr = __importStar(require("pareto-runtime"));
-function createASTNUnmarshaller($p, createBodyTreeParser, createTreeUnmarshaller, createExternalSchemaLoader) {
-    function onUnmarshallError(error, annotation, severity) {
-        $p.handler.onUnmarshallError({
-            type: error,
-            annotation: annotation,
-            severity: severity,
-        });
-    }
-    let internalParser = null;
-    function createRealParser($) {
-        return createBodyTreeParser(createTreeUnmarshaller({
-            specification: $.specification,
-            schemaAndSideEffects: $.schemaAndSideEffects,
-            onError: (error, annotation, severity) => {
-                onUnmarshallError(["unmarshall", error], annotation, severity);
-            },
-        }));
-    }
-    function createQueueingParser(annotation) {
-        const queue = [];
-        let endAnnotation = null;
-        let downStream = null;
-        return {
-            annotation: annotation,
-            setDownstream: (parser2) => {
-                downStream = parser2;
-                queue.forEach(($) => {
-                    parser2.onToken($);
-                });
-                if (endAnnotation !== null) {
-                    parser2.onEnd(endAnnotation);
-                }
-            },
-            parser: {
-                onEnd: ($) => {
-                    if (downStream !== null) {
-                        downStream.onEnd($);
-                    }
-                    endAnnotation = $;
-                },
-                onToken: (token) => {
-                    if (downStream !== null) {
-                        downStream.onToken(token);
-                    }
-                    queue.push(token);
-                },
-            },
-        };
-    }
-    return {
-        onNoInternalSchema: () => { },
-        onEmbeddedSchema: ($$) => {
-            const qp = createQueueingParser($$.headerAnnotation);
-            internalParser = qp;
-            const schemaSchemaBuilder = $p.handler.getInternalSchemaSchemaBuilder($$.schemaSchemaReferenceToken.token.value);
-            if (schemaSchemaBuilder === null) {
-                throw new Error(`IMPLEMENT ME: unknown schema schema: ${$$.schemaSchemaReferenceToken.token.value}`);
-            }
-            return schemaSchemaBuilder((error, annotation) => {
-                onUnmarshallError(["embedded schema error", error], annotation, ["error", {}]);
-            }, (schemaAndSideEffects) => {
-                const rp = createRealParser({
-                    specification: ["embedded", {}],
-                    schemaAndSideEffects: schemaAndSideEffects,
-                });
-                qp.setDownstream(rp);
-            });
-        },
-        onSchemaReference: ($$) => {
-            const qp = createQueueingParser($$.headerAnnotation);
-            internalParser = qp;
-            $p.handler.referencedSchemaProvider.getResource($$.token.token.value, createExternalSchemaLoader({
-                onFailed: () => { },
-                onSucces: (schemaAndSideEffects) => {
-                    const rp = createRealParser({
-                        schemaAndSideEffects: schemaAndSideEffects,
-                        specification: ["reference", {
-                                name: $$.token.token.value,
-                            }],
-                    });
-                    qp.setDownstream(rp);
-                },
-            }), (error) => {
-                switch (error[0]) {
-                    case "not found": {
-                        $p.handler.onUnmarshallError({
-                            type: ["schema not found", {}],
-                            annotation: $$.token.annotation,
-                            severity: ["error", {}],
-                        });
-                        break;
-                    }
-                    case "other": {
-                        const $ = error[1];
-                        $p.handler.onUnmarshallError({
-                            type: ["loading error", {
-                                    message: `problems loading schema: ${$.description}`,
-                                }],
-                            annotation: $$.token.annotation,
-                            severity: ["error", {}],
-                        });
-                        break;
-                    }
-                    default:
-                        pr.au(error[0]);
-                }
-            });
-        },
-        onBody: () => {
-            function createDummyParser() {
-                return createBodyTreeParser(//logs errors
-                null);
-            }
-            switch ($p.handler.contextSchema[0]) {
-                case "available": {
-                    if (internalParser !== null) {
-                        onUnmarshallError(["found both internal and context schema. ignoring internal schema", {}], internalParser.annotation, ["warning", {}]);
-                    }
-                    return pr.cc($p.handler.contextSchema[1], ($) => {
-                        const rp2 = createRealParser({
-                            schemaAndSideEffects: $,
-                            specification: ["none", {}],
-                        });
-                        return {
-                            onToken: (token) => {
-                                return rp2.onToken(token);
-                            },
-                            onEnd: (endAnnotation) => {
-                                rp2.onEnd(endAnnotation);
-                            },
-                        };
-                    });
-                }
-                case "has errors": {
-                    return createDummyParser();
-                }
-                case "ignored": {
-                    return pr.cc($p.handler.contextSchema[1], ($) => {
-                        if (internalParser === null) {
-                            onUnmarshallError(["no schema", {}], null, ["error", {}]);
-                            return createDummyParser();
-                        }
-                        else {
-                            const ip = internalParser;
-                            return {
-                                onToken: (token) => {
-                                    return ip.parser.onToken(token);
-                                },
-                                onEnd: (endAnnotation) => {
-                                    ip.parser.onEnd(endAnnotation);
-                                },
-                            };
-                        }
-                    });
-                }
-                case "not available":
-                    return pr.cc($p.handler.contextSchema[1], ($) => {
-                        if (internalParser === null) {
-                            onUnmarshallError(["no schema", {}], null, ["error", {}]);
-                            return createDummyParser();
-                        }
-                        else {
-                            const ip = internalParser;
-                            return {
-                                onToken: (token) => {
-                                    return ip.parser.onToken(token);
-                                },
-                                onEnd: (endAnnotation) => {
-                                    ip.parser.onEnd(endAnnotation);
-                                },
-                            };
-                        }
-                    });
-                default:
-                    return pr.au($p.handler.contextSchema[0]);
-            }
-        },
-        // errors: {
-        //     onError: ($$) => {
-        //         onUnmarshallError(["parsing", $$.error], $$.annotation, ["error", {}])
-        //     },
-        // },
-    };
-}
-exports.createASTNUnmarshaller = createASTNUnmarshaller;

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

@@ -1,3 +0,0 @@
-import { Datastore } from "../../../typed/interface/interfaces/Datastore";
-import { ITypedTreeHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-export declare function createBuilder<EventAnnotation>(ds: Datastore, onEnd: () => void): ITypedTreeHandler<EventAnnotation>;

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

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBuilder = void 0;
-function createBuilder(ds, onEnd) {
-    function buildValue(value) {
-        return {
-            onDictionary: () => {
-                const dict = {};
-                value.type = ["dictionary", dict];
-                return {
-                    onClose: () => { },
-                    onEntry: ($) => {
-                        const entry = { type: null };
-                        dict[$.token.token.value] = entry;
-                        return buildValue(entry);
-                    },
-                };
-            },
-            onList: () => {
-                const list = [];
-                value.type = ["list", list];
-                return {
-                    onClose: () => { },
-                    onElement: () => {
-                        const element = { type: null };
-                        list.push(element);
-                        return buildValue(element);
-                    },
-                };
-            },
-            onTaggedUnion: ($) => {
-                const taggedUnion = {
-                    option: null,
-                    value: { type: null },
-                };
-                value.type = ["tagged union", taggedUnion];
-                return {
-                    onUnexpectedOption: () => {
-                        taggedUnion.option = $.definition["default option"].name;
-                        return buildValue(taggedUnion.value);
-                    },
-                    onOption: ($$) => {
-                        taggedUnion.option = $$.name;
-                        return buildValue(taggedUnion.value);
-                    },
-                    onEnd: () => { },
-                };
-            },
-            onSimpleString: ($) => {
-                value.type = ["simple string", $.value];
-            },
-            onMultilineString: ($) => {
-                value.type = ["multiline string", $.token === null ? [] : $.token.token.lines];
-            },
-            onTypeReference: () => {
-                return buildValue(value);
-            },
-            onGroup: () => {
-                const group = {};
-                value.type = ["group", group];
-                return {
-                    onUnexpectedProperty: () => { },
-                    onProperty: ($) => {
-                        const property = { type: null };
-                        group[$.key] = property;
-                        return buildValue(property);
-                    },
-                    onClose: () => { },
-                };
-            },
-        };
-    }
-    return {
-        root: buildValue(ds.root),
-        onEnd: () => {
-            onEnd();
-        },
-    };
-}
-exports.createBuilder = createBuilder;

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

@@ -1,5 +0,0 @@
-import { TokenizerAnnotationData } from "../../../tokenLevel/interface/interfaces/TokenizerAnnotationData";
-import { ITypedTreeHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-import { Range } from "../../../tokenLevel/interface/interfaces/Range";
-import { Location } from "../../../tokenLevel/interface/interfaces/Location";
-export declare function createCodeCompletionFinder(completionPositionLine: number, completionPositionCharacter: number, callback: (codeCompletion: string) => void, getEndLocationFromRange: (range: Range) => Location): ITypedTreeHandler<TokenizerAnnotationData>;

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

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCodeCompletionFinder = void 0;
-const createCodeCompletionsGenerator_1 = require("./createCodeCompletionsGenerator");
-const isPositionBeforeLocation_1 = require("./isPositionBeforeLocation");
-function onPositionInContextOfRange(positionLine, positionCharacter, range, onBefore, onIn, onAfter, getEndLocationFromRange) {
-    if ((0, isPositionBeforeLocation_1.isPositionBeforeLocation)({
-        positionLine: positionLine,
-        positionCharacter: positionCharacter,
-        location: range.start,
-    })) {
-        onBefore();
-    }
-    else if ((0, isPositionBeforeLocation_1.isPositionBeforeLocation)({
-        positionLine: positionLine,
-        positionCharacter: positionCharacter,
-        location: getEndLocationFromRange(range),
-    })) {
-        onIn();
-    }
-    else {
-        onAfter();
-    }
-}
-function createCodeCompletionFinder(completionPositionLine, completionPositionCharacter, callback, getEndLocationFromRange) {
-    let positionAlreadyFound = false;
-    let previousAfter = null;
-    //console.log("FINDING COMPLETIONS", line, character)
-    function generate(gs) {
-        if (gs !== null) {
-            const codeCompletions = gs();
-            //console.log(codeCompletions)
-            codeCompletions.forEach((codeCompletion) => {
-                //console.log("codeCompletion", codeCompletion)
-                callback(codeCompletion);
-            });
-        }
-    }
-    return (0, createCodeCompletionsGenerator_1.createCodeCompletionsGenerator)((annotation, intra, after) => {
-        if (!positionAlreadyFound) {
-            onPositionInContextOfRange(completionPositionLine, completionPositionCharacter, annotation.range, () => {
-                generate(previousAfter);
-                positionAlreadyFound = true;
-            }, () => {
-                generate(intra);
-                positionAlreadyFound = true;
-            }, () => {
-                previousAfter = after;
-            }, getEndLocationFromRange);
-        }
-    }, () => {
-        if (!positionAlreadyFound) {
-            generate(previousAfter);
-        }
-    });
-}
-exports.createCodeCompletionFinder = createCodeCompletionFinder;

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

@@ -1,5 +0,0 @@
-import { ITypedTreeHandler } from "../../../typed/interface/interfaces/ITypedTreeHandler";
-declare type GetCodeCompletions = () => string[];
-export declare type OnToken<EventAnnotation> = (annotation: EventAnnotation, getCodeCompletionsInToken: GetCodeCompletions | null, getCodeCompletionsAfterToken: GetCodeCompletions | null) => void;
-export declare function createCodeCompletionsGenerator<EventAnnotation>(onToken: OnToken<EventAnnotation>, onEnd: () => void): ITypedTreeHandler<EventAnnotation>;
-export {};