@kubb/core 5.0.0-beta.94 → 5.0.0-beta.96

package/dist/index.cjs

@@ -33,7 +33,6 @@ node_process = require_usingCtx.__toESM(node_process, 1);
 *     // Convert the source (path or inline data) into an InputNode.
 *     return ast.factory.createInput()
 *   },
-*   getImports: () => [],
 *   async validate() {
 *     // Throw here when the spec is invalid.
 *   },
@@ -192,7 +191,7 @@ function memoize(store, factory) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.94";
+var version = "5.0.0-beta.96";
 //#endregion
 //#region src/constants.ts
 /**
@@ -813,9 +812,9 @@ function toBaseName({ name, extname }) {
 /**
 * Base constraint for all plugin resolver objects.
 *
-* The built-in machinery lives under `default`. Generators call the top-level `name` and
-* `file`, and a plugin overrides them to set its conventions. Extend with top-level helpers
-* (`typeName`, …) and/or grouped namespaces (`query`, `schema`, …).
+* The built-in machinery lives under `default`. Generators call the top-level `name`, `file`,
+* and `imports`, and a plugin overrides `name` and `file` to set its conventions. Extend with
+* top-level helpers (`typeName`, …) and/or grouped namespaces (`query`, `schema`, …).
 *
 * @example Top-level helper
 * ```ts
@@ -873,23 +872,61 @@ var Resolver = class Resolver {
 		return this.#resolveFile(options);
 	}
 	/**
-	* Merges `override` over `base` and returns a new resolver with helpers re-bound. Top-level
-	* keys replace, and a namespace (or `file`) merges per method, so overriding `query.name`
-	* keeps the base `query.keyName`. Used when applying `setResolver` partial overrides. Reads a
-	* resolver's options through the shared brand rather than `instanceof`, so a `file` override
-	* survives even when `base` and `override` come from different `@kubb/core` copies.
-	*/
-	static merge(base, override) {
-		const patch = resolverOptions in override ? override[resolverOptions] : override;
-		const merged = { ...base[resolverOptions] };
-		for (const [key, value] of Object.entries(patch)) {
-			if (value === void 0) continue;
-			const current = merged[key];
-			merged[key] = isNamespace(value) && isNamespace(current) ? {
-				...current,
-				...value
-			} : value;
-		}
+	* Builds one `ImportNode` per unique schema referenced in the tree, in first-occurrence
+	* order. Each ref's target resolves through `resolveRefName`, so collision- or macro-renamed
+	* schemas (`targetName`) import the emitted name. Names and paths go through the top-level
+	* `name` and `file`, so import entries follow the plugin's conventions, and a per-call
+	* `name` override wins over both.
+	*/
+	imports(options) {
+		const { node, root, output, group, extname = ".ts", name } = options;
+		const resolveName = name ?? ((schemaName) => this.name(schemaName));
+		const seen = /* @__PURE__ */ new Set();
+		return (0, _kubb_ast.collect)(node, { schema: (schemaNode) => {
+			const schemaRef = (0, _kubb_ast.narrowSchema)(schemaNode, "ref");
+			if (!schemaRef?.ref) return null;
+			const schemaName = (0, _kubb_ast.resolveRefName)(schemaRef);
+			if (!schemaName || seen.has(schemaName)) return null;
+			seen.add(schemaName);
+			return _kubb_ast.ast.factory.createImport({
+				name: [resolveName(schemaName)],
+				path: this.file({
+					name: schemaName,
+					extname,
+					root,
+					output,
+					group
+				}).path
+			});
+		} });
+	}
+	/**
+	* Folds each `override` over `base`, left to right, and returns a new resolver with helpers
+	* re-bound. Top-level keys replace, and a namespace (or `file`) merges per method, so overriding
+	* `query.name` keeps the base `query.keyName`. The last override wins per key. Used when applying
+	* `setResolver` partial overrides, and to compose shared resolver fragments without spreading each
+	* namespace by hand. Reads a resolver's options through the shared brand rather than `instanceof`,
+	* so a `file` override survives even when `base` and `override` come from different `@kubb/core`
+	* copies.
+	*
+	* @example Fold several partial overrides onto a resolver
+	* ```ts
+	* const resolver = Resolver.merge(defaultResolver, sharedNamingPatch, { name: (name) => name.toUpperCase() })
+	* ```
+	*/
+	static merge(base, ...overrides) {
+		const merged = overrides.reduce((acc, override) => {
+			const patch = resolverOptions in override ? override[resolverOptions] : override;
+			for (const [key, value] of Object.entries(patch)) {
+				if (value === void 0) continue;
+				const current = acc[key];
+				acc[key] = isNamespace(value) && isNamespace(current) ? {
+					...current,
+					...value
+				} : value;
+			}
+			return acc;
+		}, { ...base[resolverOptions] });
 		return new Resolver(merged);
 	}
 	/**