@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/dist/defineMacro-BTXvS8nI.js

@@ -0,0 +1,106 @@
+import "./chunk-CNktS9qV.js";
+import { r as transform } from "./visitor-DJ6ZEJvq.js";
+//#region src/defineMacro.ts
+/**
+* Visitor callback names a macro can implement, one per traversable node kind.
+* Mirrors the keys of {@link Visitor}.
+*/
+const macroKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
+/**
+* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
+* list keeps its authored order.
+*/
+function enforceWeight(enforce) {
+	if (enforce === "pre") return 0;
+	if (enforce === "post") return 2;
+	return 1;
+}
+/**
+* Types a macro for inference and a single construction site, mirroring `definePlugin`.
+* Adds no runtime behavior.
+*
+* @example
+* ```ts
+* const macroUntagged = defineMacro({
+*   name: 'untagged',
+*   operation(node) {
+*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+*   },
+* })
+* ```
+*/
+function defineMacro(macro) {
+	return macro;
+}
+/**
+* Runs every macro's callback for one node kind in order, chaining the result so each macro sees
+* the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
+* original reference (structural sharing).
+*/
+function chain(macros, key, node, context) {
+	let current = node;
+	for (const macro of macros) {
+		const callback = macro[key];
+		if (!callback) continue;
+		if (macro.when && !macro.when(current)) continue;
+		const next = callback(current, context);
+		if (next != null) current = next;
+	}
+	return current === node ? void 0 : current;
+}
+/**
+* Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
+* transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
+* sequentially per node so later macros see earlier output. This differs from a plain visitor, which
+* has no names, ordering, or composition.
+*
+* @example
+* ```ts
+* const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
+* const next = transform(root, visitor)
+* ```
+*/
+function composeMacros(macros) {
+	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
+	const visitor = {};
+	for (const key of macroKeys) {
+		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
+		const callback = (node, context) => chain(ordered, key, node, context);
+		visitor[key] = callback;
+	}
+	return visitor;
+}
+/**
+* Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
+* structural sharing, so an empty or no-op macro list returns the same reference. Pass
+* `depth: 'shallow'` to rewrite the root node only.
+*
+* @example
+* ```ts
+* const next = applyMacros(root, [macroIntegerToString])
+* ```
+*
+* @example Apply to the root node only
+* ```ts
+* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* ```
+*/
+function applyMacros(root, macros, options) {
+	if (macros.length === 0) return root;
+	return transform(root, {
+		...composeMacros(macros),
+		depth: options?.depth
+	});
+}
+//#endregion
+export { composeMacros as n, defineMacro as r, applyMacros as t };
+
+//# sourceMappingURL=defineMacro-BTXvS8nI.js.map

package/dist/defineMacro-BTXvS8nI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineMacro-BTXvS8nI.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Visitor callback names a macro can implement, one per traversable node kind.\n * Mirrors the keys of {@link Visitor}.\n */\nconst macroKeys = ['input', 'output', 'operation', 'schema', 'property', 'parameter', 'response'] as const\n\ntype MacroKey = (typeof macroKeys)[number]\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: 'pre' | 'post'): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier, surfaced in diagnostics. Follows the `macro<Name>` convention.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: 'pre' | 'post'\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain(macros: ReadonlyArray<Macro>, key: MacroKey, node: Node, context: VisitorContext): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of macroKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain(ordered, key, node, context)\n    ;(visitor as Record<MacroKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), depth: options?.depth }) as TNode\n}\n"],"mappings":";;;;;;;AASA,MAAM,YAAY;CAAC;CAAS;CAAU;CAAa;CAAU;CAAY;CAAa;AAAU;;;;;AAQhG,SAAS,cAAc,SAAkC;CACvD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AASA,SAAS,MAAM,QAA8B,KAAe,MAAY,SAA2C;CACjH,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,WAAW;EAC3B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM,SAAS,KAAK,MAAM,OAAO;EAC1F,QAA6C,OAAO;CACvD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,OAAO,SAAS;CAAM,CAAC;AAC5E"}

package/dist/defineMacro-Bv9R_9a2.cjs

@@ -0,0 +1,123 @@
+require("./response-hnSw2NKE.cjs");
+const require_visitor = require("./visitor-DpKZ9Tk0.cjs");
+//#region src/defineMacro.ts
+/**
+* Visitor callback names a macro can implement, one per traversable node kind.
+* Mirrors the keys of {@link Visitor}.
+*/
+const macroKeys = [
+	"input",
+	"output",
+	"operation",
+	"schema",
+	"property",
+	"parameter",
+	"response"
+];
+/**
+* Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
+* list keeps its authored order.
+*/
+function enforceWeight(enforce) {
+	if (enforce === "pre") return 0;
+	if (enforce === "post") return 2;
+	return 1;
+}
+/**
+* Types a macro for inference and a single construction site, mirroring `definePlugin`.
+* Adds no runtime behavior.
+*
+* @example
+* ```ts
+* const macroUntagged = defineMacro({
+*   name: 'untagged',
+*   operation(node) {
+*     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+*   },
+* })
+* ```
+*/
+function defineMacro(macro) {
+	return macro;
+}
+/**
+* Runs every macro's callback for one node kind in order, chaining the result so each macro sees
+* the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the
+* original reference (structural sharing).
+*/
+function chain(macros, key, node, context) {
+	let current = node;
+	for (const macro of macros) {
+		const callback = macro[key];
+		if (!callback) continue;
+		if (macro.when && !macro.when(current)) continue;
+		const next = callback(current, context);
+		if (next != null) current = next;
+	}
+	return current === node ? void 0 : current;
+}
+/**
+* Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
+* transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
+* sequentially per node so later macros see earlier output. This differs from a plain visitor, which
+* has no names, ordering, or composition.
+*
+* @example
+* ```ts
+* const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
+* const next = transform(root, visitor)
+* ```
+*/
+function composeMacros(macros) {
+	const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce));
+	const visitor = {};
+	for (const key of macroKeys) {
+		if (!ordered.some((macro) => typeof macro[key] === "function")) continue;
+		const callback = (node, context) => chain(ordered, key, node, context);
+		visitor[key] = callback;
+	}
+	return visitor;
+}
+/**
+* Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
+* structural sharing, so an empty or no-op macro list returns the same reference. Pass
+* `depth: 'shallow'` to rewrite the root node only.
+*
+* @example
+* ```ts
+* const next = applyMacros(root, [macroIntegerToString])
+* ```
+*
+* @example Apply to the root node only
+* ```ts
+* const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+* ```
+*/
+function applyMacros(root, macros, options) {
+	if (macros.length === 0) return root;
+	return require_visitor.transform(root, {
+		...composeMacros(macros),
+		depth: options?.depth
+	});
+}
+//#endregion
+Object.defineProperty(exports, "applyMacros", {
+	enumerable: true,
+	get: function() {
+		return applyMacros;
+	}
+});
+Object.defineProperty(exports, "composeMacros", {
+	enumerable: true,
+	get: function() {
+		return composeMacros;
+	}
+});
+Object.defineProperty(exports, "defineMacro", {
+	enumerable: true,
+	get: function() {
+		return defineMacro;
+	}
+});
+
+//# sourceMappingURL=defineMacro-Bv9R_9a2.cjs.map

package/dist/defineMacro-Bv9R_9a2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineMacro-Bv9R_9a2.cjs","names":["transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Visitor callback names a macro can implement, one per traversable node kind.\n * Mirrors the keys of {@link Visitor}.\n */\nconst macroKeys = ['input', 'output', 'operation', 'schema', 'property', 'parameter', 'response'] as const\n\ntype MacroKey = (typeof macroKeys)[number]\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: 'pre' | 'post'): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier, surfaced in diagnostics. Follows the `macro<Name>` convention.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: 'pre' | 'post'\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain(macros: ReadonlyArray<Macro>, key: MacroKey, node: Node, context: VisitorContext): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of macroKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain(ordered, key, node, context)\n    ;(visitor as Record<MacroKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), depth: options?.depth }) as TNode\n}\n"],"mappings":";;;;;;;AASA,MAAM,YAAY;CAAC;CAAS;CAAU;CAAa;CAAU;CAAY;CAAa;AAAU;;;;;AAQhG,SAAS,cAAc,SAAkC;CACvD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AASA,SAAS,MAAM,QAA8B,KAAe,MAAY,SAA2C;CACjH,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,WAAW;EAC3B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM,SAAS,KAAK,MAAM,OAAO;EAC1F,QAA6C,OAAO;CACvD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOA,gBAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,OAAO,SAAS;CAAM,CAAC;AAC5E"}

package/dist/extractStringsFromNodes-Cja-xxx5.js

@@ -0,0 +1,29 @@
+import "./chunk-CNktS9qV.js";
+//#region src/utils/extractStringsFromNodes.ts
+/**
+* Extracts all string content from a `CodeNode` tree recursively.
+*
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used to build the full source string for import filtering.
+*/
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	return nodes.map((node) => {
+		if (typeof node === "string") return node;
+		if (node.kind === "Text") return node.value;
+		if (node.kind === "Break") return "";
+		if (node.kind === "Jsx") return node.value;
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		return parts.join("\n");
+	}).filter(Boolean).join("\n");
+}
+//#endregion
+export { extractStringsFromNodes as t };
+
+//# sourceMappingURL=extractStringsFromNodes-Cja-xxx5.js.map

package/dist/extractStringsFromNodes-Cja-xxx5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractStringsFromNodes-Cja-xxx5.js","names":[],"sources":["../src/utils/extractStringsFromNodes.ts"],"sourcesContent":["import type { CodeNode } from '../nodes/code.ts'\n\n/**\n * Extracts all string content from a `CodeNode` tree recursively.\n *\n * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),\n * and nested node content. Used to build the full source string for import filtering.\n */\nexport function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string {\n  if (!nodes?.length) return ''\n  return nodes\n    .map((node) => {\n      // Backward-compat: compiled plugins may still pass bare strings at runtime\n      if (typeof node === 'string') return node as string\n      if (node.kind === 'Text') return node.value\n      if (node.kind === 'Break') return ''\n      if (node.kind === 'Jsx') return node.value\n\n      const parts: Array<string> = []\n\n      if ('params' in node && node.params) parts.push(node.params)\n      if ('generics' in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(', ') : node.generics)\n      if ('returnType' in node && node.returnType) parts.push(node.returnType)\n      if ('type' in node && typeof node.type === 'string') parts.push(node.type)\n\n      const nested = extractStringsFromNodes(node.nodes)\n\n      if (nested) parts.push(nested)\n\n      return parts.join('\\n')\n    })\n    .filter(Boolean)\n    .join('\\n')\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,wBAAwB,OAA4C;CAClF,IAAI,CAAC,OAAO,QAAQ,OAAO;CAC3B,OAAO,MACJ,KAAK,SAAS;EAEb,IAAI,OAAO,SAAS,UAAU,OAAO;EACrC,IAAI,KAAK,SAAS,QAAQ,OAAO,KAAK;EACtC,IAAI,KAAK,SAAS,SAAS,OAAO;EAClC,IAAI,KAAK,SAAS,OAAO,OAAO,KAAK;EAErC,MAAM,QAAuB,CAAC;EAE9B,IAAI,YAAY,QAAQ,KAAK,QAAQ,MAAM,KAAK,KAAK,MAAM;EAC3D,IAAI,cAAc,QAAQ,KAAK,UAAU,MAAM,KAAK,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK,SAAS,KAAK,IAAI,IAAI,KAAK,QAAQ;EAC3H,IAAI,gBAAgB,QAAQ,KAAK,YAAY,MAAM,KAAK,KAAK,UAAU;EACvE,IAAI,UAAU,QAAQ,OAAO,KAAK,SAAS,UAAU,MAAM,KAAK,KAAK,IAAI;EAEzE,MAAM,SAAS,wBAAwB,KAAK,KAAK;EAEjD,IAAI,QAAQ,MAAM,KAAK,MAAM;EAE7B,OAAO,MAAM,KAAK,IAAI;CACxB,CAAC,CAAC,CACD,OAAO,OAAO,CAAC,CACf,KAAK,IAAI;AACd"}

package/dist/extractStringsFromNodes-DKgDjFO0.cjs

@@ -0,0 +1,34 @@
+require("./response-hnSw2NKE.cjs");
+//#region src/utils/extractStringsFromNodes.ts
+/**
+* Extracts all string content from a `CodeNode` tree recursively.
+*
+* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+* and nested node content. Used to build the full source string for import filtering.
+*/
+function extractStringsFromNodes(nodes) {
+	if (!nodes?.length) return "";
+	return nodes.map((node) => {
+		if (typeof node === "string") return node;
+		if (node.kind === "Text") return node.value;
+		if (node.kind === "Break") return "";
+		if (node.kind === "Jsx") return node.value;
+		const parts = [];
+		if ("params" in node && node.params) parts.push(node.params);
+		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
+		if ("returnType" in node && node.returnType) parts.push(node.returnType);
+		if ("type" in node && typeof node.type === "string") parts.push(node.type);
+		const nested = extractStringsFromNodes(node.nodes);
+		if (nested) parts.push(nested);
+		return parts.join("\n");
+	}).filter(Boolean).join("\n");
+}
+//#endregion
+Object.defineProperty(exports, "extractStringsFromNodes", {
+	enumerable: true,
+	get: function() {
+		return extractStringsFromNodes;
+	}
+});
+
+//# sourceMappingURL=extractStringsFromNodes-DKgDjFO0.cjs.map

package/dist/extractStringsFromNodes-DKgDjFO0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractStringsFromNodes-DKgDjFO0.cjs","names":[],"sources":["../src/utils/extractStringsFromNodes.ts"],"sourcesContent":["import type { CodeNode } from '../nodes/code.ts'\n\n/**\n * Extracts all string content from a `CodeNode` tree recursively.\n *\n * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),\n * and nested node content. Used to build the full source string for import filtering.\n */\nexport function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string {\n  if (!nodes?.length) return ''\n  return nodes\n    .map((node) => {\n      // Backward-compat: compiled plugins may still pass bare strings at runtime\n      if (typeof node === 'string') return node as string\n      if (node.kind === 'Text') return node.value\n      if (node.kind === 'Break') return ''\n      if (node.kind === 'Jsx') return node.value\n\n      const parts: Array<string> = []\n\n      if ('params' in node && node.params) parts.push(node.params)\n      if ('generics' in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(', ') : node.generics)\n      if ('returnType' in node && node.returnType) parts.push(node.returnType)\n      if ('type' in node && typeof node.type === 'string') parts.push(node.type)\n\n      const nested = extractStringsFromNodes(node.nodes)\n\n      if (nested) parts.push(nested)\n\n      return parts.join('\\n')\n    })\n    .filter(Boolean)\n    .join('\\n')\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,wBAAwB,OAA4C;CAClF,IAAI,CAAC,OAAO,QAAQ,OAAO;CAC3B,OAAO,MACJ,KAAK,SAAS;EAEb,IAAI,OAAO,SAAS,UAAU,OAAO;EACrC,IAAI,KAAK,SAAS,QAAQ,OAAO,KAAK;EACtC,IAAI,KAAK,SAAS,SAAS,OAAO;EAClC,IAAI,KAAK,SAAS,OAAO,OAAO,KAAK;EAErC,MAAM,QAAuB,CAAC;EAE9B,IAAI,YAAY,QAAQ,KAAK,QAAQ,MAAM,KAAK,KAAK,MAAM;EAC3D,IAAI,cAAc,QAAQ,KAAK,UAAU,MAAM,KAAK,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK,SAAS,KAAK,IAAI,IAAI,KAAK,QAAQ;EAC3H,IAAI,gBAAgB,QAAQ,KAAK,YAAY,MAAM,KAAK,KAAK,UAAU;EACvE,IAAI,UAAU,QAAQ,OAAO,KAAK,SAAS,UAAU,MAAM,KAAK,KAAK,IAAI;EAEzE,MAAM,SAAS,wBAAwB,KAAK,KAAK;EAEjD,IAAI,QAAQ,MAAM,KAAK,MAAM;EAE7B,OAAO,MAAM,KAAK,IAAI;CACxB,CAAC,CAAC,CACD,OAAO,OAAO,CAAC,CACf,KAAK,IAAI;AACd"}

package/dist/extractStringsFromNodes-p4mX1TQD.d.ts

@@ -0,0 +1,14 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+import { Pt as CodeNode } from "./index-BzjwdK2M.js";
+
+//#region src/utils/extractStringsFromNodes.d.ts
+/**
+ * Extracts all string content from a `CodeNode` tree recursively.
+ *
+ * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
+ * and nested node content. Used to build the full source string for import filtering.
+ */
+declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
+//#endregion
+export { extractStringsFromNodes as t };
+//# sourceMappingURL=extractStringsFromNodes-p4mX1TQD.d.ts.map

package/dist/factory-CZNOGI-N.js

@@ -0,0 +1,283 @@
+import { t as __exportAll } from "./chunk-CNktS9qV.js";
+import { B as createFunction, D as createSource, E as createImport, H as createText, L as createArrowFunction, N as createContent, R as createBreak, T as createExport, U as createType, V as createJsx, X as createSchema, _ as createIndexedAccessType, a as createParameter, d as createRequestBody, g as createFunctionParameters, h as createFunctionParameter, l as createOperation, p as createInput, r as createProperty, s as createOutput, t as createResponse, v as createObjectBindingPattern, y as createTypeLiteral, z as createConst } from "./response-KUdWiDWw.js";
+import { t as extractStringsFromNodes } from "./extractStringsFromNodes-Cja-xxx5.js";
+import { hash } from "node:crypto";
+import path from "node:path";
+//#region ../../internals/utils/src/fs.ts
+/**
+* Strips the file extension from a path or file name.
+* Only removes the last `.ext` segment when the dot is not part of a directory name.
+*
+* @example
+* trimExtName('petStore.ts')             // 'petStore'
+* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
+* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
+* trimExtName('noExtension')             // 'noExtension'
+*/
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+//#endregion
+//#region src/utils/fileMerge.ts
+function sourceKey(source) {
+	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
+}
+function pathTypeKey(path, isTypeOnly) {
+	return `${path}:${isTypeOnly ?? false}`;
+}
+function exportKey(path, name, isTypeOnly, asAlias) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
+}
+function importKey(path, name, isTypeOnly) {
+	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
+}
+/**
+* Computes a multi-level sort key for exports and imports:
+* non-array names first (wildcards/namespace aliases). Type-only before value. Alphabetical path. Unnamed before named.
+*/
+function sortKey(node) {
+	const isArray = Array.isArray(node.name) ? "1" : "0";
+	const typeOnly = node.isTypeOnly ? "0" : "1";
+	const hasName = node.name != null ? "1" : "0";
+	const name = Array.isArray(node.name) ? node.name.toSorted().join("\0") : node.name ?? "";
+	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
+}
+/**
+* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
+*
+* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
+*/
+function combineSources(sources) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const key = sourceKey(source);
+		if (!seen.has(key)) seen.set(key, source);
+	}
+	return [...seen.values()];
+}
+/**
+* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
+*
+* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
+*/
+function mergeNameArrays(existing, incoming) {
+	const merged = new Set(existing);
+	for (const name of incoming) merged.add(name);
+	return [...merged];
+}
+/**
+* Deduplicates and merges `ExportNode` objects by path and type.
+*
+* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
+* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
+*/
+function combineExports(exports) {
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = exports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		const { name, path, isTypeOnly, asAlias } = curr;
+		if (Array.isArray(name)) {
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name: [...new Set(name)]
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			const key = exportKey(path, name, isTypeOnly, asAlias);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+/**
+* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
+*
+* Retains imports that are referenced in `source` or re-exported. Imports with the same path and
+* `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
+*/
+function combineImports(imports, exports, source) {
+	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
+	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
+	const importNameMemo = /* @__PURE__ */ new Map();
+	const canonicalizeName = (n) => {
+		if (typeof n === "string") return n;
+		const key = `${n.propertyName}:${n.name ?? ""}`;
+		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
+		return importNameMemo.get(key);
+	};
+	const pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
+	for (const node of imports) {
+		if (!Array.isArray(node.name)) continue;
+		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
+	}
+	const result = [];
+	const namedByPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const keyed = imports.map((node) => ({
+		node,
+		key: sortKey(node)
+	}));
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	for (const { node: curr } of keyed) {
+		if (curr.path === curr.root) continue;
+		const { path, isTypeOnly } = curr;
+		let { name } = curr;
+		if (Array.isArray(name)) {
+			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
+			if (!name.length) continue;
+			const key = pathTypeKey(path, isTypeOnly);
+			const existing = namedByPath.get(key);
+			if (existing && Array.isArray(existing.name)) existing.name = mergeNameArrays(existing.name, name);
+			else {
+				const newItem = {
+					...curr,
+					name
+				};
+				result.push(newItem);
+				namedByPath.set(key, newItem);
+			}
+		} else {
+			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) continue;
+			const key = importKey(path, name, isTypeOnly);
+			if (!seen.has(key)) {
+				result.push(curr);
+				seen.add(key);
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	createArrowFunction: () => createArrowFunction,
+	createBreak: () => createBreak,
+	createConst: () => createConst,
+	createContent: () => createContent,
+	createExport: () => createExport,
+	createFile: () => createFile,
+	createFunction: () => createFunction,
+	createFunctionParameter: () => createFunctionParameter,
+	createFunctionParameters: () => createFunctionParameters,
+	createImport: () => createImport,
+	createIndexedAccessType: () => createIndexedAccessType,
+	createInput: () => createInput,
+	createJsx: () => createJsx,
+	createObjectBindingPattern: () => createObjectBindingPattern,
+	createOperation: () => createOperation,
+	createOutput: () => createOutput,
+	createParameter: () => createParameter,
+	createProperty: () => createProperty,
+	createRequestBody: () => createRequestBody,
+	createResponse: () => createResponse,
+	createSchema: () => createSchema,
+	createSource: () => createSource,
+	createText: () => createText,
+	createType: () => createType,
+	createTypeLiteral: () => createTypeLiteral,
+	update: () => update
+});
+/**
+* Identity-preserving node update: returns `node` unchanged when every field in
+* `changes` already equals (by reference) the current value, otherwise a new node
+* with the changes applied.
+*
+* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
+* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+* downstream passes can detect "nothing changed" by identity. Comparison is
+* shallow: a structurally-equal but newly-allocated array/object counts as a change.
+*
+* @example
+* ```ts
+* update(node, { name: node.name })        // -> same `node` reference
+* update(node, { name: 'renamed' })        // -> new node, `name` replaced
+* ```
+*/
+function update(node, changes) {
+	for (const key in changes) if (changes[key] !== node[key]) return {
+		...node,
+		...changes
+	};
+	return node;
+}
+/**
+* Creates a fully resolved `FileNode` from a file input descriptor.
+*
+* Computes:
+* - `id` SHA256 hash of the file path
+* - `name` `baseName` without extension
+* - `extname` extension extracted from `baseName`
+*
+* Deduplicates:
+* - `sources` via `combineSources`
+* - `exports` via `combineExports`
+* - `imports` via `combineImports` (also filters unused imports)
+*
+* @throws {Error} when `baseName` has no extension.
+*
+* @example
+* ```ts
+* const file = createFile({
+*   baseName: 'petStore.ts',
+*   path: 'src/models/petStore.ts',
+*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+*   imports: [createImport({ name: ['z'], path: 'zod' })],
+*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+* })
+* // file.id      = SHA256 hash of 'src/models/petStore.ts'
+* // file.name    = 'petStore'
+* // file.extname = '.ts'
+* ```
+*/
+function createFile(input) {
+	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
+	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
+	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
+	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
+	const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
+	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
+	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
+	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
+		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
+		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
+		if (!kept.length) return [];
+		return [kept.length === imp.name.length ? imp : {
+			...imp,
+			name: kept
+		}];
+	});
+	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
+	return {
+		kind: "File",
+		...input,
+		id: hash("sha256", input.path, "hex"),
+		name: trimExtName(input.baseName),
+		extname,
+		imports: resolvedImports,
+		exports: resolvedExports,
+		sources: resolvedSources,
+		meta: input.meta ?? {}
+	};
+}
+//#endregion
+export { factory_exports as n, update as r, createFile as t };
+
+//# sourceMappingURL=factory-CZNOGI-N.js.map