@kubb/agent 4.33.5 → 4.34.0

package/.output/server/node_modules/@stoplight/yaml/getJsonPathForPosition.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildJsonPath_1 = require("./buildJsonPath");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+exports.getJsonPathForPosition = ({ ast, lineMap }, { line, character }) => {
+    if (line >= lineMap.length || character >= lineMap[line]) {
+        return;
+    }
+    const startOffset = line === 0 ? 0 : lineMap[line - 1] + 1;
+    const node = findClosestScalar(ast, Math.min(lineMap[line] - 1, startOffset + character), line, lineMap);
+    if (!utils_1.isObject(node))
+        return;
+    const path = buildJsonPath_1.buildJsonPath(node);
+    if (path.length === 0)
+        return;
+    return path;
+};
+function* walk(node) {
+    switch (node.kind) {
+        case types_1.Kind.MAP:
+            if (node.mappings.length !== 0) {
+                for (const mapping of node.mappings) {
+                    if (utils_1.isObject(mapping)) {
+                        yield mapping;
+                    }
+                }
+            }
+            break;
+        case types_1.Kind.MAPPING:
+            if (utils_1.isObject(node.key)) {
+                yield node.key;
+            }
+            if (utils_1.isObject(node.value)) {
+                yield node.value;
+            }
+            break;
+        case types_1.Kind.SEQ:
+            if (node.items.length !== 0) {
+                for (const item of node.items) {
+                    if (utils_1.isObject(item)) {
+                        yield item;
+                    }
+                }
+            }
+            break;
+        case types_1.Kind.SCALAR:
+            yield node;
+            break;
+    }
+}
+function getFirstScalarChild(node, line, lineMap) {
+    const startOffset = lineMap[line - 1] + 1;
+    const endOffset = lineMap[line];
+    switch (node.kind) {
+        case types_1.Kind.MAPPING:
+            return node.key;
+        case types_1.Kind.MAP:
+            if (node.mappings.length !== 0) {
+                for (const mapping of node.mappings) {
+                    if (mapping.startPosition > startOffset && mapping.startPosition <= endOffset) {
+                        return getFirstScalarChild(mapping, line, lineMap);
+                    }
+                }
+            }
+            break;
+        case types_1.Kind.SEQ:
+            if (node.items.length !== 0) {
+                for (const item of node.items) {
+                    if (item !== null && item.startPosition > startOffset && item.startPosition <= endOffset) {
+                        return getFirstScalarChild(item, line, lineMap);
+                    }
+                }
+            }
+            break;
+    }
+    return node;
+}
+function findClosestScalar(container, offset, line, lineMap) {
+    for (const node of walk(container)) {
+        if (node.startPosition <= offset && offset <= node.endPosition) {
+            return node.kind === types_1.Kind.SCALAR ? node : findClosestScalar(node, offset, line, lineMap);
+        }
+    }
+    if (lineMap[line - 1] === lineMap[line] - 1) {
+        return container;
+    }
+    if (container.startPosition < lineMap[line - 1] && offset <= container.endPosition) {
+        if (container.kind !== types_1.Kind.MAPPING) {
+            return getFirstScalarChild(container, line, lineMap);
+        }
+        if (container.value && container.key.endPosition < offset) {
+            return getFirstScalarChild(container.value, line, lineMap);
+        }
+    }
+    return container;
+}
+//# sourceMappingURL=getJsonPathForPosition.js.map

package/.output/server/node_modules/@stoplight/yaml/getLocationForJsonPath.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lineForPosition_1 = require("./lineForPosition");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+exports.getLocationForJsonPath = ({ ast, lineMap, metadata }, path, closest = false) => {
+    const node = findNodeAtPath(ast, path, { closest, mergeKeys: metadata !== undefined && metadata.mergeKeys === true });
+    if (node === void 0)
+        return;
+    return getLoc(lineMap, {
+        start: getStartPosition(node, lineMap.length > 0 ? lineMap[0] : 0),
+        end: getEndPosition(node),
+    });
+};
+function getStartPosition(node, offset) {
+    if (node.parent && node.parent.kind === types_1.Kind.MAPPING) {
+        if (node.parent.value === null) {
+            return node.parent.endPosition;
+        }
+        if (node.kind !== types_1.Kind.SCALAR) {
+            return node.parent.key.endPosition + 1;
+        }
+    }
+    if (node.parent === null && offset - node.startPosition === 0) {
+        return 0;
+    }
+    return node.startPosition;
+}
+function getEndPosition(node) {
+    switch (node.kind) {
+        case types_1.Kind.SEQ:
+            const { items } = node;
+            if (items.length !== 0) {
+                const lastItem = items[items.length - 1];
+                if (lastItem !== null) {
+                    return getEndPosition(lastItem);
+                }
+            }
+            break;
+        case types_1.Kind.MAPPING:
+            if (node.value !== null) {
+                return getEndPosition(node.value);
+            }
+            break;
+        case types_1.Kind.MAP:
+            if (node.value !== null && node.mappings.length !== 0) {
+                return getEndPosition(node.mappings[node.mappings.length - 1]);
+            }
+            break;
+        case types_1.Kind.SCALAR:
+            if (node.parent !== null && node.parent.kind === types_1.Kind.MAPPING && node.parent.value === null) {
+                return node.parent.endPosition;
+            }
+            break;
+    }
+    return node.endPosition;
+}
+function findNodeAtPath(node, path, { closest, mergeKeys }) {
+    pathLoop: for (const segment of path) {
+        if (!utils_1.isObject(node)) {
+            return closest ? node : void 0;
+        }
+        switch (node.kind) {
+            case types_1.Kind.MAP:
+                const mappings = getMappings(node.mappings, mergeKeys);
+                for (let i = mappings.length - 1; i >= 0; i--) {
+                    const item = mappings[i];
+                    if (item.key.value === segment) {
+                        if (item.value === null) {
+                            node = item.key;
+                        }
+                        else {
+                            node = item.value;
+                        }
+                        continue pathLoop;
+                    }
+                }
+                return closest ? node : void 0;
+            case types_1.Kind.SEQ:
+                for (let i = 0; i < node.items.length; i++) {
+                    if (i === Number(segment)) {
+                        const item = node.items[i];
+                        if (item === null) {
+                            break;
+                        }
+                        node = item;
+                        continue pathLoop;
+                    }
+                }
+                return closest ? node : void 0;
+            default:
+                return closest ? node : void 0;
+        }
+    }
+    return node;
+}
+function getMappings(mappings, mergeKeys) {
+    if (!mergeKeys)
+        return mappings;
+    return mappings.reduce((mergedMappings, mapping) => {
+        if (utils_1.isObject(mapping)) {
+            if (mapping.key.value === "<<") {
+                mergedMappings.push(...reduceMergeKeys(mapping.value));
+            }
+            else {
+                mergedMappings.push(mapping);
+            }
+        }
+        return mergedMappings;
+    }, []);
+}
+function reduceMergeKeys(node) {
+    if (!utils_1.isObject(node))
+        return [];
+    switch (node.kind) {
+        case types_1.Kind.SEQ:
+            return node.items.reduceRight((items, item) => {
+                items.push(...reduceMergeKeys(item));
+                return items;
+            }, []);
+        case types_1.Kind.MAP:
+            return node.mappings;
+        case types_1.Kind.ANCHOR_REF:
+            return reduceMergeKeys(node.value);
+        default:
+            return [];
+    }
+}
+const getLoc = (lineMap, { start = 0, end = 0 }) => {
+    const startLine = lineForPosition_1.lineForPosition(start, lineMap);
+    const endLine = lineForPosition_1.lineForPosition(end, lineMap);
+    return {
+        range: {
+            start: {
+                line: startLine,
+                character: start - (startLine === 0 ? 0 : lineMap[startLine - 1]),
+            },
+            end: {
+                line: endLine,
+                character: end - (endLine === 0 ? 0 : lineMap[endLine - 1]),
+            },
+        },
+    };
+};
+//# sourceMappingURL=getLocationForJsonPath.js.map

package/.output/server/node_modules/@stoplight/yaml/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./buildJsonPath"), exports);
+tslib_1.__exportStar(require("./dereferenceAnchor"), exports);
+tslib_1.__exportStar(require("./getJsonPathForPosition"), exports);
+tslib_1.__exportStar(require("./getLocationForJsonPath"), exports);
+tslib_1.__exportStar(require("./lineForPosition"), exports);
+var parse_1 = require("./parse");
+exports.parse = parse_1.parse;
+var parseWithPointers_1 = require("./parseWithPointers");
+exports.parseWithPointers = parseWithPointers_1.parseWithPointers;
+tslib_1.__exportStar(require("./safeStringify"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./trapAccess"), exports);
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@stoplight/yaml/lineForPosition.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineForPosition = (pos, lines, start = 0, end) => {
+    if (pos === 0 || lines.length === 0 || pos < lines[0]) {
+        return 0;
+    }
+    if (typeof end === 'undefined') {
+        end = lines.length;
+    }
+    const target = Math.floor((end - start) / 2) + start;
+    if (pos >= lines[target] && !lines[target + 1]) {
+        return target + 1;
+    }
+    const nextLinePos = lines[Math.min(target + 1, lines.length)];
+    if (pos === lines[target] - 1) {
+        return target;
+    }
+    if (pos >= lines[target] && pos <= nextLinePos) {
+        if (pos === nextLinePos) {
+            return target + 2;
+        }
+        return target + 1;
+    }
+    if (pos > lines[target]) {
+        return exports.lineForPosition(pos, lines, target + 1, end);
+    }
+    else {
+        return exports.lineForPosition(pos, lines, start, target - 1);
+    }
+};
+//# sourceMappingURL=lineForPosition.js.map

package/.output/server/node_modules/@stoplight/yaml/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@stoplight/yaml",
+  "version": "4.3.0",
+  "description": "Useful functions when working with YAML.",
+  "keywords": [
+    "yaml",
+    "yaml parser",
+    "yaml.parse",
+    "parser",
+    "sourcemap"
+  ],
+  "main": "index.js",
+  "sideEffects": false,
+  "files": [
+    "**/*"
+  ],
+  "author": "Stoplight <support@stoplight.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stoplightio/yaml"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=10.8"
+  },
+  "dependencies": {
+    "@stoplight/ordered-object-literal": "^1.0.5",
+    "@stoplight/types": "^14.1.1",
+    "@stoplight/yaml-ast-parser": "0.0.50",
+    "tslib": "^2.2.0"
+  },
+  "typings": "index.d.ts"
+}

package/.output/server/node_modules/@stoplight/yaml/parse.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseWithPointers_1 = require("./parseWithPointers");
+exports.parse = (value) => parseWithPointers_1.parseWithPointers(value).data;
+//# sourceMappingURL=parse.js.map