@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/js/regexp.js

@@ -0,0 +1,64 @@
+'use strict';
+var type_1 = require("../../type");
+function resolveJavascriptRegExp(data) {
+    if (null === data) {
+        return false;
+    }
+    if (0 === data.length) {
+        return false;
+    }
+    var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = '';
+    if ('/' === regexp[0]) {
+        if (tail) {
+            modifiers = tail[1];
+        }
+        if (modifiers.length > 3) {
+            return false;
+        }
+        if (regexp[regexp.length - modifiers.length - 1] !== '/') {
+            return false;
+        }
+        regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
+    }
+    try {
+        var dummy = new RegExp(regexp, modifiers);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function constructJavascriptRegExp(data) {
+    var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = '';
+    if ('/' === regexp[0]) {
+        if (tail) {
+            modifiers = tail[1];
+        }
+        regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
+    }
+    return new RegExp(regexp, modifiers);
+}
+function representJavascriptRegExp(object) {
+    var result = '/' + object.source + '/';
+    if (object.global) {
+        result += 'g';
+    }
+    if (object.multiline) {
+        result += 'm';
+    }
+    if (object.ignoreCase) {
+        result += 'i';
+    }
+    return result;
+}
+function isRegExp(object) {
+    return '[object RegExp]' === Object.prototype.toString.call(object);
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:js/regexp', {
+    kind: 'scalar',
+    resolve: resolveJavascriptRegExp,
+    construct: constructJavascriptRegExp,
+    predicate: isRegExp,
+    represent: representJavascriptRegExp
+});
+//# sourceMappingURL=regexp.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/js/undefined.js

@@ -0,0 +1,22 @@
+'use strict';
+var type_1 = require("../../type");
+function resolveJavascriptUndefined() {
+    return true;
+}
+function constructJavascriptUndefined() {
+    return undefined;
+}
+function representJavascriptUndefined() {
+    return '';
+}
+function isUndefined(object) {
+    return 'undefined' === typeof object;
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:js/undefined', {
+    kind: 'scalar',
+    resolve: resolveJavascriptUndefined,
+    construct: constructJavascriptUndefined,
+    predicate: isUndefined,
+    represent: representJavascriptUndefined
+});
+//# sourceMappingURL=undefined.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/map.js

@@ -0,0 +1,7 @@
+'use strict';
+var type_1 = require("../type");
+module.exports = new type_1.Type('tag:yaml.org,2002:map', {
+    kind: 'mapping',
+    construct: function (data) { return null !== data ? data : {}; }
+});
+//# sourceMappingURL=map.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/merge.js

@@ -0,0 +1,10 @@
+'use strict';
+var type_1 = require("../type");
+function resolveYamlMerge(data) {
+    return '<<' === data || null === data;
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:merge', {
+    kind: 'scalar',
+    resolve: resolveYamlMerge
+});
+//# sourceMappingURL=merge.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/null.js

@@ -0,0 +1,30 @@
+'use strict';
+var type_1 = require("../type");
+function resolveYamlNull(data) {
+    if (null === data) {
+        return true;
+    }
+    var max = data.length;
+    return (max === 1 && data === '~') ||
+        (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
+}
+function constructYamlNull() {
+    return null;
+}
+function isNull(object) {
+    return null === object;
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:null', {
+    kind: 'scalar',
+    resolve: resolveYamlNull,
+    construct: constructYamlNull,
+    predicate: isNull,
+    represent: {
+        canonical: function () { return '~'; },
+        lowercase: function () { return 'null'; },
+        uppercase: function () { return 'NULL'; },
+        camelcase: function () { return 'Null'; }
+    },
+    defaultStyle: 'lowercase'
+});
+//# sourceMappingURL=null.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/omap.js

@@ -0,0 +1,46 @@
+'use strict';
+var type_1 = require("../type");
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+var _toString = Object.prototype.toString;
+function resolveYamlOmap(data) {
+    if (null === data) {
+        return true;
+    }
+    var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
+    for (index = 0, length = object.length; index < length; index += 1) {
+        pair = object[index];
+        pairHasKey = false;
+        if ('[object Object]' !== _toString.call(pair)) {
+            return false;
+        }
+        for (pairKey in pair) {
+            if (_hasOwnProperty.call(pair, pairKey)) {
+                if (!pairHasKey) {
+                    pairHasKey = true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if (!pairHasKey) {
+            return false;
+        }
+        if (-1 === objectKeys.indexOf(pairKey)) {
+            objectKeys.push(pairKey);
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+}
+function constructYamlOmap(data) {
+    return null !== data ? data : [];
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:omap', {
+    kind: 'sequence',
+    resolve: resolveYamlOmap,
+    construct: constructYamlOmap
+});
+//# sourceMappingURL=omap.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/pairs.js

@@ -0,0 +1,55 @@
+'use strict';
+var type_1 = require("../type");
+var ast = require("../yamlAST");
+var _toString = Object.prototype.toString;
+function resolveYamlPairs(data) {
+    if (null === data) {
+        return true;
+    }
+    if (data.kind != ast.Kind.SEQ) {
+        return false;
+    }
+    var index, length, pair, keys, result, object = data.items;
+    for (index = 0, length = object.length; index < length; index += 1) {
+        pair = object[index];
+        if ('[object Object]' !== _toString.call(pair)) {
+            return false;
+        }
+        if (!Array.isArray(pair.mappings)) {
+            return false;
+        }
+        if (1 !== pair.mappings.length) {
+            return false;
+        }
+    }
+    return true;
+}
+function constructYamlPairs(data) {
+    if (null === data || !Array.isArray(data.items)) {
+        return [];
+    }
+    var index, length, keys, result, object = data.items;
+    result = ast.newItems();
+    result.parent = data.parent;
+    result.startPosition = data.startPosition;
+    result.endPosition = data.endPosition;
+    for (index = 0, length = object.length; index < length; index += 1) {
+        var pair = object[index];
+        var mapping = pair.mappings[0];
+        var pairSeq = ast.newItems();
+        pairSeq.parent = result;
+        pairSeq.startPosition = mapping.key.startPosition;
+        pairSeq.endPosition = mapping.value.startPosition;
+        mapping.key.parent = pairSeq;
+        mapping.value.parent = pairSeq;
+        pairSeq.items = [mapping.key, mapping.value];
+        result.items.push(pairSeq);
+    }
+    return result;
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:pairs', {
+    kind: 'sequence',
+    resolve: resolveYamlPairs,
+    construct: constructYamlPairs
+});
+//# sourceMappingURL=pairs.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/seq.js

@@ -0,0 +1,7 @@
+'use strict';
+var type_1 = require("../type");
+module.exports = new type_1.Type('tag:yaml.org,2002:seq', {
+    kind: 'sequence',
+    construct: function (data) { return null !== data ? data : []; }
+});
+//# sourceMappingURL=seq.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/set.js

@@ -0,0 +1,22 @@
+'use strict';
+var type_1 = require("../type");
+var ast = require("../yamlAST");
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+function resolveYamlSet(data) {
+    if (null === data) {
+        return true;
+    }
+    if (data.kind != ast.Kind.MAP) {
+        return false;
+    }
+    return true;
+}
+function constructYamlSet(data) {
+    return null !== data ? data : {};
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:set', {
+    kind: 'mapping',
+    resolve: resolveYamlSet,
+    construct: constructYamlSet
+});
+//# sourceMappingURL=set.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/str.js

@@ -0,0 +1,7 @@
+'use strict';
+var type_1 = require("../type");
+module.exports = new type_1.Type('tag:yaml.org,2002:str', {
+    kind: 'scalar',
+    construct: function (data) { return null !== data ? data : ''; }
+});
+//# sourceMappingURL=str.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/timestamp.js

@@ -0,0 +1,70 @@
+'use strict';
+var type_1 = require("../type");
+var YAML_TIMESTAMP_REGEXP = new RegExp('^([0-9][0-9][0-9][0-9])' +
+    '-([0-9][0-9]?)' +
+    '-([0-9][0-9]?)' +
+    '(?:(?:[Tt]|[ \\t]+)' +
+    '([0-9][0-9]?)' +
+    ':([0-9][0-9])' +
+    ':([0-9][0-9])' +
+    '(?:\\.([0-9]*))?' +
+    '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' +
+    '(?::([0-9][0-9]))?))?)?$');
+function resolveYamlTimestamp(data) {
+    if (null === data) {
+        return false;
+    }
+    var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+    match = YAML_TIMESTAMP_REGEXP.exec(data);
+    if (null === match) {
+        return false;
+    }
+    return true;
+}
+function constructYamlTimestamp(data) {
+    var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+    match = YAML_TIMESTAMP_REGEXP.exec(data);
+    if (null === match) {
+        throw new Error('Date resolve error');
+    }
+    year = +(match[1]);
+    month = +(match[2]) - 1;
+    day = +(match[3]);
+    if (!match[4]) {
+        return new Date(Date.UTC(year, month, day));
+    }
+    hour = +(match[4]);
+    minute = +(match[5]);
+    second = +(match[6]);
+    if (match[7]) {
+        fraction = match[7].slice(0, 3);
+        while (fraction.length < 3) {
+            fraction = fraction + '0';
+        }
+        fraction = +fraction;
+    }
+    if (match[9]) {
+        tz_hour = +(match[10]);
+        tz_minute = +(match[11] || 0);
+        delta = (tz_hour * 60 + tz_minute) * 60000;
+        if ('-' === match[9]) {
+            delta = -delta;
+        }
+    }
+    date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+    if (delta) {
+        date.setTime(date.getTime() - delta);
+    }
+    return date;
+}
+function representYamlTimestamp(object) {
+    return object.toISOString();
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:timestamp', {
+    kind: 'scalar',
+    resolve: resolveYamlTimestamp,
+    construct: constructYamlTimestamp,
+    instanceOf: Date,
+    represent: representYamlTimestamp
+});
+//# sourceMappingURL=timestamp.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type.js

@@ -0,0 +1,54 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+var YAMLException = require("./exception");
+var TYPE_CONSTRUCTOR_OPTIONS = [
+    'kind',
+    'resolve',
+    'construct',
+    'instanceOf',
+    'predicate',
+    'represent',
+    'defaultStyle',
+    'styleAliases'
+];
+var YAML_NODE_KINDS = [
+    'scalar',
+    'sequence',
+    'mapping'
+];
+function compileStyleAliases(map) {
+    var result = {};
+    if (null !== map) {
+        Object.keys(map).forEach(function (style) {
+            map[style].forEach(function (alias) {
+                result[String(alias)] = style;
+            });
+        });
+    }
+    return result;
+}
+var Type = (function () {
+    function Type(tag, options) {
+        options = options || {};
+        Object.keys(options).forEach(function (name) {
+            if (-1 === TYPE_CONSTRUCTOR_OPTIONS.indexOf(name)) {
+                throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+            }
+        });
+        this.tag = tag;
+        this.kind = options['kind'] || null;
+        this.resolve = options['resolve'] || function () { return true; };
+        this.construct = options['construct'] || function (data) { return data; };
+        this.instanceOf = options['instanceOf'] || null;
+        this.predicate = options['predicate'] || null;
+        this.represent = options['represent'] || null;
+        this.defaultStyle = options['defaultStyle'] || null;
+        this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
+        if (-1 === YAML_NODE_KINDS.indexOf(this.kind)) {
+            throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+        }
+    }
+    return Type;
+}());
+exports.Type = Type;
+//# sourceMappingURL=type.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/yamlAST.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Kind;
+(function (Kind) {
+    Kind[Kind["SCALAR"] = 0] = "SCALAR";
+    Kind[Kind["MAPPING"] = 1] = "MAPPING";
+    Kind[Kind["MAP"] = 2] = "MAP";
+    Kind[Kind["SEQ"] = 3] = "SEQ";
+    Kind[Kind["ANCHOR_REF"] = 4] = "ANCHOR_REF";
+    Kind[Kind["INCLUDE_REF"] = 5] = "INCLUDE_REF";
+})(Kind = exports.Kind || (exports.Kind = {}));
+function newMapping(key, value) {
+    var end = (value ? value.endPosition : key.endPosition + 1);
+    var node = {
+        key: key,
+        value: value,
+        startPosition: key.startPosition,
+        endPosition: end,
+        kind: Kind.MAPPING,
+        parent: null,
+        errors: []
+    };
+    return node;
+}
+exports.newMapping = newMapping;
+function newAnchorRef(key, start, end, value) {
+    return {
+        errors: [],
+        referencesAnchor: key,
+        value: value,
+        startPosition: start,
+        endPosition: end,
+        kind: Kind.ANCHOR_REF,
+        parent: null
+    };
+}
+exports.newAnchorRef = newAnchorRef;
+function newScalar(v) {
+    if (v === void 0) { v = ""; }
+    var result = {
+        errors: [],
+        startPosition: -1,
+        endPosition: -1,
+        value: "" + v,
+        kind: Kind.SCALAR,
+        parent: null,
+        doubleQuoted: false,
+        rawValue: "" + v,
+    };
+    if (typeof v !== "string") {
+        result.valueObject = v;
+    }
+    return result;
+}
+exports.newScalar = newScalar;
+function newItems() {
+    return {
+        errors: [],
+        startPosition: -1,
+        endPosition: -1,
+        items: [],
+        kind: Kind.SEQ,
+        parent: null
+    };
+}
+exports.newItems = newItems;
+function newSeq() {
+    return newItems();
+}
+exports.newSeq = newSeq;
+function newMap(mappings) {
+    return {
+        errors: [],
+        startPosition: -1,
+        endPosition: -1,
+        mappings: mappings ? mappings : [],
+        kind: Kind.MAP,
+        parent: null
+    };
+}
+exports.newMap = newMap;
+//# sourceMappingURL=yamlAST.js.map

package/.output/server/node_modules/yaml-ast-parser/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "yaml-ast-parser",
+  "version": "0.0.43",
+  "main": "dist/src/index.js",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "pullall": "dev-env-installer pullall",
+    "buildall": "dev-env-installer buildall",
+    "testall": "dev-env-installer testall",
+    "devInstall": "dev-env-installer install",
+    "test": "npm run build && mocha --ui tdd dist/test"
+  },
+  "dependencies": {},
+  "typings": "dist/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mulesoft-labs/yaml-ast-parser.git"
+  },
+  "keywords": [
+    "raml",
+    "ast",
+    "yaml"
+  ],
+  "homepage": "https://github.com/mulesoft-labs/yaml-ast-parser",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/mulesoft-labs/yaml-ast-parser/issues"
+  },
+  "devDependencies": {
+    "@types/chai": "4.0.1",
+    "@types/mocha": "2.2.41",
+    "@types/node": "4.2.20",
+    "chai": "4.0.2",
+    "dev-env-installer": "0.0.14",
+    "mocha": "3.4.2",
+    "rimraf": "*",
+    "typescript": "3.0.1"
+  }
+}

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/agent-prod",
-  "version": "4.33.1",
+  "version": "4.33.2",
   "type": "module",
   "private": true,
   "dependencies": {
@@ -23,12 +23,17 @@
     "@readme/openapi-parser": "5.5.0",
     "@readme/openapi-schemas": "3.1.0",
     "@readme/postman-to-openapi": "4.1.0",
+    "@redocly/ajv": "8.18.0",
+    "@redocly/config": "0.44.0",
+    "@redocly/openapi-core": "2.20.4",
     "ajv": "8.17.1",
     "ajv-draft-04": "1.0.0",
+    "ajv-formats": "3.0.1",
     "anymatch": "3.1.3",
     "buffer-from": "1.1.2",
     "call-me-maybe": "1.0.2",
     "chokidar": "5.0.0",
+    "colorette": "1.4.0",
     "compute-gcd": "1.2.1",
     "compute-lcm": "1.1.2",
     "consola": "3.4.2",
@@ -47,6 +52,7 @@
     "iconv-lite": "0.6.3",
     "is-promise": "2.2.2",
     "jiti": "2.5.1",
+    "js-levenshtein": "1.1.6",
     "js-tokens": "4.0.0",
     "js-yaml": "4.1.1",
     "json-schema-compare": "0.2.2",
@@ -73,6 +79,7 @@
     "path-to-regexp": "8.3.0",
     "picocolors": "1.1.1",
     "picomatch": "2.3.1",
+    "pluralize": "8.0.0",
     "react-devtools-core": "6.1.5",
     "readdirp": "5.0.0",
     "reftools": "1.1.9",
@@ -97,6 +104,7 @@
     "validate.io-number": "1.0.3",
     "ws": "8.19.0",
     "yaml": "1.10.2",
+    "yaml-ast-parser": "0.0.43",
     "yocto-queue": "1.2.2"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/agent",
-  "version": "4.33.1",
+  "version": "4.33.2",
   "description": "Agent server for Kubb, enabling HTTP-based access to code generation capabilities.",
   "keywords": [
     "agent",
@@ -40,21 +40,21 @@
     "tinyexec": "^1.0.2",
     "unstorage": "^1.17.4",
     "ws": "^8.19.0",
-    "@kubb/core": "4.33.1",
-    "@kubb/plugin-client": "4.33.1",
-    "@kubb/plugin-cypress": "4.33.1",
-    "@kubb/plugin-faker": "4.33.1",
-    "@kubb/plugin-mcp": "4.33.1",
-    "@kubb/plugin-msw": "4.33.1",
-    "@kubb/plugin-oas": "4.33.1",
-    "@kubb/plugin-react-query": "4.33.1",
-    "@kubb/plugin-redoc": "4.33.1",
-    "@kubb/plugin-solid-query": "4.33.1",
-    "@kubb/plugin-svelte-query": "4.33.1",
-    "@kubb/plugin-swr": "4.33.1",
-    "@kubb/plugin-ts": "4.33.1",
-    "@kubb/plugin-vue-query": "4.33.1",
-    "@kubb/plugin-zod": "4.33.1"
+    "@kubb/core": "4.33.2",
+    "@kubb/plugin-client": "4.33.2",
+    "@kubb/plugin-cypress": "4.33.2",
+    "@kubb/plugin-faker": "4.33.2",
+    "@kubb/plugin-mcp": "4.33.2",
+    "@kubb/plugin-msw": "4.33.2",
+    "@kubb/plugin-oas": "4.33.2",
+    "@kubb/plugin-react-query": "4.33.2",
+    "@kubb/plugin-redoc": "4.33.2",
+    "@kubb/plugin-solid-query": "4.33.2",
+    "@kubb/plugin-svelte-query": "4.33.2",
+    "@kubb/plugin-swr": "4.33.2",
+    "@kubb/plugin-ts": "4.33.2",
+    "@kubb/plugin-vue-query": "4.33.2",
+    "@kubb/plugin-zod": "4.33.2"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",