@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.39

package/.output/server/node_modules/@kubb/plugin-cypress/dist/index.js

@@ -1,79 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { n as camelCase } from "./components-BK_6GU4v.js";
-import { t as cypressGenerator } from "./generators-D5YFtyyC.js";
-import path from "node:path";
-import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
-import { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
-//#region src/plugin.ts
-const pluginCypressName = "plugin-cypress";
-const pluginCypress = definePlugin((options) => {
-	const { output = {
-		path: "cypress",
-		barrelType: "named"
-	}, group, dataReturnType = "data", exclude = [], include, override = [], transformers = {}, generators = [cypressGenerator].filter(Boolean), contentType, baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline" } = options;
-	return {
-		name: pluginCypressName,
-		options: {
-			output,
-			dataReturnType,
-			group,
-			baseURL,
-			paramsCasing,
-			paramsType,
-			pathParamsType
-		},
-		pre: [pluginOasName, pluginTsName].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return path.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Requests`;
-				};
-				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return path.resolve(root, output.path, baseName);
-		},
-		resolveName(name, type) {
-			const resolvedName = camelCase(name, { isFile: type === "file" });
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.resolve(root, output.path));
-			const oas = await this.getOas();
-			const files = await new OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				pluginManager: this.pluginManager,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				exclude,
-				include,
-				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginKey: this.plugin.key }
-			});
-			await this.upsertFile(...barrelFiles);
-		}
-	};
-});
-//#endregion
-export { pluginCypress, pluginCypressName };
-
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@kubb/plugin-cypress/package.json

@@ -1,108 +0,0 @@
-{
-  "name": "@kubb/plugin-cypress",
-  "version": "4.37.2",
-  "description": "Cypress test generator plugin for Kubb, creating end-to-end tests from OpenAPI specifications for automated API testing.",
-  "keywords": [
-    "cypress",
-    "e2e-testing",
-    "end-to-end",
-    "testing",
-    "test-generation",
-    "api-testing",
-    "test-automation",
-    "integration-testing",
-    "typescript",
-    "openapi",
-    "swagger",
-    "oas",
-    "code-generator",
-    "codegen",
-    "plugins",
-    "kubb"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kubb-labs/kubb.git",
-    "directory": "packages/plugin-cypress"
-  },
-  "license": "MIT",
-  "author": "stijnvanhulle",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./components": {
-      "import": "./dist/components.js",
-      "require": "./dist/components.cjs"
-    },
-    "./generators": {
-      "import": "./dist/generators.js",
-      "require": "./dist/generators.cjs"
-    },
-    "./package.json": "./package.json"
-  },
-  "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "utils": [
-        "./dist/utils.d.ts"
-      ],
-      "hooks": [
-        "./dist/hooks.d.ts"
-      ],
-      "components": [
-        "./dist/components.d.ts"
-      ],
-      "generators": [
-        "./dist/generators.d.ts"
-      ]
-    }
-  },
-  "files": [
-    "src",
-    "dist",
-    "!/**/**.test.**",
-    "!/**/__tests__/**",
-    "!/**/__snapshots__/**"
-  ],
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
-    }
-  ],
-  "dependencies": {
-    "@kubb/react-fabric": "0.14.0",
-    "@kubb/core": "4.37.2",
-    "@kubb/oas": "4.37.2",
-    "@kubb/plugin-oas": "4.37.2",
-    "@kubb/plugin-ts": "4.37.2"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "devDependencies": {
-    "@internals/utils": "0.0.0"
-  },
-  "scripts": {
-    "build": "tsdown && size-limit",
-    "clean": "npx rimraf ./dist",
-    "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint --fix --unsafe .",
-    "release": "pnpm publish --no-git-check",
-    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
-    "start": "tsdown --watch",
-    "test": "vitest --passWithNoTests",
-    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
-  }
-}

package/.output/server/node_modules/@kubb/plugin-faker/dist/chunk--u3MIqq1.js

@@ -1,8 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-//#endregion
-export { __name as t };

package/.output/server/node_modules/@kubb/plugin-faker/dist/components-BkBIov4R.js

@@ -1,419 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { createParser, findSchemaKeyword, isKeyword, schemaKeywords } from "@kubb/plugin-oas";
-import { File, Function, FunctionParams } from "@kubb/react-fabric";
-import { jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
-//#region ../../internals/utils/src/string.ts
-/**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
-*
-* @example
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
-*/
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
-}
-/**
-* Escapes characters that are not allowed inside JS string literals.
-* Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).
-*
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-*/
-function jsStringEscape(input) {
-	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-		switch (character) {
-			case "\"":
-			case "'":
-			case "\\": return `\\${character}`;
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "\u2028": return "\\u2028";
-			case "\u2029": return "\\u2029";
-			default: return "";
-		}
-	});
-}
-//#endregion
-//#region ../../internals/utils/src/object.ts
-/**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
-*
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
-*/
-function stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(trimQuotes(value.toString()));
-}
-//#endregion
-//#region ../../internals/utils/src/regexp.ts
-/**
-* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
-* Inline flags expressed as `^(?im)` prefixes are extracted and applied to the resulting expression.
-* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
-*
-* @example
-* toRegExpString('^(?im)foo')       // → 'new RegExp("foo", "im")'
-* toRegExpString('^(?im)foo', null) // → '/foo/im'
-*/
-function toRegExpString(text, func = "RegExp") {
-	const raw = trimQuotes(text);
-	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
-	const replacementTarget = match?.[1] ?? "";
-	const matchedFlags = match?.[2];
-	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
-	const { source, flags } = new RegExp(cleaned, matchedFlags);
-	if (func === null) return `/${source}/${flags}`;
-	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
-}
-//#endregion
-//#region src/parser.ts
-const fakerKeywordMapper = {
-	any: () => "undefined",
-	unknown: () => "undefined",
-	void: () => "undefined",
-	number: (min, max) => {
-		if (max !== void 0 && min !== void 0) return `faker.number.float({ min: ${min}, max: ${max} })`;
-		if (max !== void 0) return `faker.number.float({ max: ${max} })`;
-		if (min !== void 0) return `faker.number.float({ min: ${min} })`;
-		return "faker.number.float()";
-	},
-	integer: (min, max) => {
-		if (max !== void 0 && min !== void 0) return `faker.number.int({ min: ${min}, max: ${max} })`;
-		if (max !== void 0) return `faker.number.int({ max: ${max} })`;
-		if (min !== void 0) return `faker.number.int({ min: ${min} })`;
-		return "faker.number.int()";
-	},
-	bigint: () => "faker.number.bigInt()",
-	string: (min, max) => {
-		if (max !== void 0 && min !== void 0) return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
-		if (max !== void 0) return `faker.string.alpha({ length: ${max} })`;
-		if (min !== void 0) return `faker.string.alpha({ length: ${min} })`;
-		return "faker.string.alpha()";
-	},
-	boolean: () => "faker.datatype.boolean()",
-	undefined: () => "undefined",
-	null: () => "null",
-	array: (items = [], min, max) => {
-		if (items.length > 1) return `faker.helpers.arrayElements([${items.join(", ")}])`;
-		const item = items.at(0);
-		if (min !== void 0 && max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: ${min}, max: ${max} }})`;
-		if (min !== void 0) return `faker.helpers.multiple(() => (${item}), { count: ${min} })`;
-		if (max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: 0, max: ${max} }})`;
-		return `faker.helpers.multiple(() => (${item}))`;
-	},
-	tuple: (items = []) => `[${items.join(", ")}]`,
-	enum: (items = [], type = "any") => `faker.helpers.arrayElement<${type}>([${items.join(", ")}])`,
-	union: (items = []) => `faker.helpers.arrayElement<any>([${items.join(", ")}])`,
-	datetime: () => "faker.date.anytime().toISOString()",
-	date: (type = "string", parser = "faker") => {
-		if (type === "string") {
-			if (parser !== "faker") return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`;
-			return "faker.date.anytime().toISOString().substring(0, 10)";
-		}
-		if (parser !== "faker") throw new Error(`type '${type}' and parser '${parser}' can not work together`);
-		return "faker.date.anytime()";
-	},
-	time: (type = "string", parser = "faker") => {
-		if (type === "string") {
-			if (parser !== "faker") return `${parser}(faker.date.anytime()).format("HH:mm:ss")`;
-			return "faker.date.anytime().toISOString().substring(11, 19)";
-		}
-		if (parser !== "faker") throw new Error(`type '${type}' and parser '${parser}' can not work together`);
-		return "faker.date.anytime()";
-	},
-	uuid: () => "faker.string.uuid()",
-	url: () => "faker.internet.url()",
-	and: (items = []) => {
-		if (items.length === 0) return "{}";
-		if (items.length === 1) return items[0] ?? "{}";
-		return `{...${items.join(", ...")}}`;
-	},
-	object: () => "object",
-	ref: () => "ref",
-	matches: (value = "", regexGenerator = "faker") => {
-		if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
-		return `faker.helpers.fromRegExp("${value}")`;
-	},
-	email: () => "faker.internet.email()",
-	firstName: () => "faker.person.firstName()",
-	lastName: () => "faker.person.lastName()",
-	password: () => "faker.internet.password()",
-	phone: () => "faker.phone.number()",
-	blob: () => "faker.image.url() as unknown as Blob",
-	default: void 0,
-	describe: void 0,
-	const: (value) => value ?? "",
-	max: void 0,
-	min: void 0,
-	nullable: void 0,
-	nullish: void 0,
-	optional: void 0,
-	readOnly: void 0,
-	writeOnly: void 0,
-	deprecated: void 0,
-	example: void 0,
-	schema: void 0,
-	catchall: void 0,
-	name: void 0,
-	interface: void 0,
-	exclusiveMaximum: void 0,
-	exclusiveMinimum: void 0
-};
-/**
-* @link based on https://github.com/cellular/oazapfts/blob/7ba226ebb15374e8483cc53e7532f1663179a22c/src/codegen/generate.ts#L398
-*/
-function schemaKeywordSorter(_a, b) {
-	if (b.keyword === "null") return -1;
-	return 0;
-}
-function joinItems(items) {
-	switch (items.length) {
-		case 0: return "undefined";
-		case 1: return items[0];
-		default: return fakerKeywordMapper.union(items);
-	}
-}
-const parse = createParser({
-	mapper: fakerKeywordMapper,
-	handlers: {
-		union(tree, options) {
-			const { current, schema, name, siblings } = tree;
-			if (Array.isArray(current.args) && !current.args.length) return "";
-			return fakerKeywordMapper.union(current.args.map((it) => this.parse({
-				schema,
-				parent: current,
-				name,
-				current: it,
-				siblings
-			}, {
-				...options,
-				canOverride: false
-			})).filter((x) => Boolean(x)));
-		},
-		and(tree, options) {
-			const { current, schema, siblings } = tree;
-			return fakerKeywordMapper.and(current.args.map((it) => this.parse({
-				schema,
-				parent: current,
-				current: it,
-				siblings
-			}, {
-				...options,
-				canOverride: false
-			})).filter((x) => Boolean(x)));
-		},
-		array(tree, options) {
-			const { current, schema } = tree;
-			return fakerKeywordMapper.array(current.args.items.map((it) => this.parse({
-				schema,
-				parent: current,
-				current: it,
-				siblings: current.args.items
-			}, {
-				...options,
-				typeName: `NonNullable<${options.typeName}>[number]`,
-				canOverride: false
-			})).filter((x) => Boolean(x)), current.args.min, current.args.max);
-		},
-		enum(tree, options) {
-			const { current, parent, name } = tree;
-			if (parent ? isKeyword(parent, schemaKeywords.tuple) : false) return fakerKeywordMapper.enum(current.args.items.map((schema) => {
-				if (schema.format === "number") return schema.value;
-				if (schema.format === "boolean") return schema.value;
-				return stringify(schema.value);
-			}));
-			return fakerKeywordMapper.enum(current.args.items.map((schema) => {
-				if (schema.format === "number") return schema.value;
-				if (schema.format === "boolean") return schema.value;
-				return stringify(schema.value);
-			}), name ? options.typeName : void 0);
-		},
-		ref(tree, options) {
-			const { current, parent } = tree;
-			if (!current.args?.name) throw new Error(`Name not defined for keyword ${current.keyword}`);
-			if (options.rootTypeName && current.args.name === options.rootTypeName) return "undefined as any";
-			const isNestedInObjectOrAnd = parent && (isKeyword(parent, schemaKeywords.object) || isKeyword(parent, schemaKeywords.and));
-			if (options.canOverride && !isNestedInObjectOrAnd) return `${current.args.name}(data)`;
-			return `${current.args.name}()`;
-		},
-		object(tree, options) {
-			const { current, schema } = tree;
-			return `{${Object.entries(current.args?.properties || {}).filter((item) => {
-				const schema = item[1];
-				return schema && typeof schema.map === "function";
-			}).map(([name, schemas]) => {
-				const mappedName = schemas.find((schema) => schema.keyword === schemaKeywords.name)?.args || name;
-				if (options.mapper && Object.hasOwn(options.mapper, mappedName)) return `"${name}": ${options.mapper?.[mappedName]}`;
-				return `"${name}": ${joinItems(schemas.sort(schemaKeywordSorter).map((it) => this.parse({
-					schema,
-					name,
-					parent: current,
-					current: it,
-					siblings: schemas
-				}, {
-					...options,
-					typeName: `NonNullable<${options.typeName}>[${JSON.stringify(name)}]`,
-					canOverride: false
-				})).filter((x) => Boolean(x)))}`;
-			}).join(",")}}`;
-		},
-		tuple(tree, options) {
-			const { current, schema, siblings } = tree;
-			if (Array.isArray(current.args.items)) return fakerKeywordMapper.tuple(current.args.items.map((it) => this.parse({
-				schema,
-				parent: current,
-				current: it,
-				siblings
-			}, {
-				...options,
-				canOverride: false
-			})).filter((x) => Boolean(x)));
-			return this.parse({
-				schema,
-				parent: current,
-				current: current.args.items,
-				siblings
-			}, {
-				...options,
-				canOverride: false
-			});
-		},
-		const(tree, _options) {
-			const { current } = tree;
-			if (current.args.format === "number" && current.args.name !== void 0) return fakerKeywordMapper.const(current.args.name?.toString());
-			return fakerKeywordMapper.const(stringify(current.args.value));
-		},
-		matches(tree, options) {
-			const { current } = tree;
-			if (current.args) return fakerKeywordMapper.matches(current.args, options.regexGenerator);
-		},
-		null() {
-			return fakerKeywordMapper.null();
-		},
-		undefined() {
-			return fakerKeywordMapper.undefined();
-		},
-		any() {
-			return fakerKeywordMapper.any();
-		},
-		string(tree, _options) {
-			const { siblings } = tree;
-			if (siblings) {
-				const minSchema = findSchemaKeyword(siblings, "min");
-				const maxSchema = findSchemaKeyword(siblings, "max");
-				return fakerKeywordMapper.string(minSchema?.args, maxSchema?.args);
-			}
-			return fakerKeywordMapper.string();
-		},
-		number(tree, _options) {
-			const { siblings } = tree;
-			if (siblings) {
-				const minSchema = findSchemaKeyword(siblings, "min");
-				const maxSchema = findSchemaKeyword(siblings, "max");
-				return fakerKeywordMapper.number(minSchema?.args, maxSchema?.args);
-			}
-			return fakerKeywordMapper.number();
-		},
-		integer(tree, _options) {
-			const { siblings } = tree;
-			if (siblings) {
-				const minSchema = findSchemaKeyword(siblings, "min");
-				const maxSchema = findSchemaKeyword(siblings, "max");
-				return fakerKeywordMapper.integer(minSchema?.args, maxSchema?.args);
-			}
-			return fakerKeywordMapper.integer();
-		},
-		bigint(_tree, _options) {
-			return fakerKeywordMapper.bigint();
-		},
-		datetime() {
-			return fakerKeywordMapper.datetime();
-		},
-		date(tree, options) {
-			const { current } = tree;
-			return fakerKeywordMapper.date(current.args.type, options.dateParser);
-		},
-		time(tree, options) {
-			const { current } = tree;
-			return fakerKeywordMapper.time(current.args.type, options.dateParser);
-		}
-	}
-});
-//#endregion
-//#region src/components/Faker.tsx
-function Faker({ tree, description, name, typeName, seed, regexGenerator, canOverride, mapper, dateParser }) {
-	const fakerText = joinItems(tree.map((schema, _index, siblings) => parse({
-		name,
-		schema,
-		parent: void 0,
-		current: schema,
-		siblings
-	}, {
-		typeName,
-		rootTypeName: name,
-		regexGenerator,
-		mapper,
-		canOverride,
-		dateParser
-	})).filter((x) => Boolean(x)));
-	const isArray = fakerText.startsWith("faker.helpers.arrayElements") || fakerText.startsWith("faker.helpers.multiple");
-	const isRefToArray = tree.some((s) => isKeyword(s, schemaKeywords.schema) && s.args.type === "array");
-	const isObject = fakerText.startsWith("{");
-	const isTuple = fakerText.startsWith("faker.helpers.arrayElement");
-	const isSimpleString = name === "string";
-	const isSimpleInt = name === "integer";
-	const isSimpleFloat = name === "float";
-	let fakerTextWithOverride = fakerText;
-	if (canOverride && isObject) fakerTextWithOverride = `{
-  ...${fakerText},
-  ...data || {}
-}`;
-	if (canOverride && isTuple) fakerTextWithOverride = `data || ${fakerText}`;
-	if (canOverride && isArray) fakerTextWithOverride = `[
-      ...${fakerText},
-      ...data || []
-    ]`;
-	if (canOverride && isSimpleString) fakerTextWithOverride = "data ?? faker.string.alpha()";
-	if (canOverride && isSimpleInt) fakerTextWithOverride = "data ?? faker.number.int()";
-	if (canOverride && isSimpleFloat) fakerTextWithOverride = "data ?? faker.number.float()";
-	let type = `Partial<${typeName}>`;
-	if (isArray) type = typeName;
-	if (isRefToArray) type = typeName;
-	if (isSimpleString) type = name;
-	if (isSimpleInt || isSimpleFloat) type = "number";
-	const params = FunctionParams.factory({ data: {
-		type,
-		optional: true
-	} });
-	let returnType = canOverride ? typeName : void 0;
-	if (isSimpleString || isSimpleInt || isSimpleFloat) returnType = type;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsxs(Function, {
-			export: true,
-			name,
-			JSDoc: { comments: [description ? `@description ${jsStringEscape(description)}` : void 0].filter(Boolean) },
-			params: canOverride ? params.toConstructor() : void 0,
-			returnType,
-			children: [
-				seed ? `faker.seed(${JSON.stringify(seed)})` : void 0,
-				/* @__PURE__ */ jsx("br", {}),
-				`return ${fakerTextWithOverride}`
-			]
-		})
-	});
-}
-//#endregion
-export { Faker as t };
-
-//# sourceMappingURL=components-BkBIov4R.js.map