@kubb/ast 5.0.0-beta.58 → 5.0.0-beta.59

package/README.md

@@ -134,6 +134,16 @@ import { extractRefName } from '@kubb/ast/utils'
 extractRefName('#/components/schemas/Pet') // 'Pet'
 ```
 
+## Adding a node
+
+Adding a node touches three files. The barrels and visitor tables derive the rest.
+
+1. Define the node in its own `src/nodes/*.ts` file. Call `defineNode` and export the resulting `fooDef`, the `createFoo` constructor, and the node's type.
+2. Add `fooDef` to the `nodeDefs` array in `src/registry.ts`.
+3. Re-export `createFoo` from `src/factory.ts`.
+
+Everything else follows from there. `@kubb/ast/types` picks up the node type through `export type *`, the `@kubb/ast` barrel picks up `fooDef` through `export * from './registry.ts'`, and the visitor tables (`VISITOR_KEYS`, `VISITOR_KEY_BY_KIND`, `nodeRebuilders`) come from the def's `children`, `visitorKey`, and `rebuild` fields. `registry.test.ts` fails when a def has no matching `factory.create*`, so missing wiring is caught in CI.
+
 ## Supporting Kubb
 
 Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:

package/dist/casing-BE2R1RXg.cjs

@@ -0,0 +1,88 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "pascalCase", {
+	enumerable: true,
+	get: function() {
+		return pascalCase;
+	}
+});
+
+//# sourceMappingURL=casing-BE2R1RXg.cjs.map

package/dist/casing-BE2R1RXg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"casing-BE2R1RXg.cjs","names":[],"sources":["../../../internals/utils/src/casing.ts"],"sourcesContent":["type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,gBAAgB,MAAc,QAAyB;CAC9D,OAAO,KACJ,KAAK,CAAC,CACN,QAAQ,qBAAqB,OAAO,CAAC,CACrC,QAAQ,yBAAyB,OAAO,CAAC,CACzC,QAAQ,gBAAgB,OAAO,CAAC,CAChC,MAAM,eAAe,CAAC,CACtB,OAAO,OAAO,CAAC,CACf,KAAK,MAAM,MAAM;EAChB,IAAI,KAAK,SAAS,KAAK,SAAS,KAAK,YAAY,GAAG,OAAO;EAE3D,QADa,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,KAC9E,KAAK,MAAM,CAAC;CAC5B,CAAC,CAAC,CACD,KAAK,EAAE,CAAC,CACR,QAAQ,iBAAiB,EAAE;AAChC;;;;;;;;;;AAwBA,SAAgB,WAAW,MAAc,EAAE,SAAS,IAAI,SAAS,OAAgB,CAAC,GAAW;CAC3F,OAAO,gBAAgB,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,IAAI;AAC5D"}

package/dist/extractStringsFromNodes-WMYJ8nQL.d.ts

@@ -0,0 +1,82 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+import { Pt as CodeNode, _t as SchemaNode } from "./index-BzjwdK2M.js";
+
+//#region src/transformers.d.ts
+/**
+ * Replaces a discriminator property's schema with a string enum of allowed values.
+ *
+ * If `node` is not an object schema, or if the property does not exist, the input
+ * node is returned as-is.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({
+ *   type: 'object',
+ *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+ * })
+ * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+ * ```
+ */
+declare function setDiscriminatorEnum({
+  node,
+  propertyName,
+  values,
+  enumName
+}: {
+  node: SchemaNode;
+  propertyName: string;
+  values: Array<string>;
+  enumName?: string;
+}): SchemaNode;
+/**
+ * Merges adjacent anonymous object members into a single anonymous object member.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeAdjacentObjects([
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+ * ])
+ * ```
+ */
+declare function mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined>;
+/**
+ * Removes enum members that are covered by broader scalar primitives in the same union.
+ *
+ * @example
+ * ```ts
+ * const simplified = simplifyUnion([
+ *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+ *   createSchema({ type: 'string' }),
+ * ])
+ * // keeps only string member
+ * ```
+ */
+declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
+declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
+/**
+ * Merges a ref node with its resolved schema, giving usage-site fields precedence.
+ *
+ * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
+ * the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
+ *
+ * @example
+ * ```ts
+ * // Ref with description override
+ * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+ * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
+ * ```
+ */
+declare function syncSchemaRef(node: SchemaNode): SchemaNode;
+//#endregion
+//#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 { simplifyUnion as a, setEnumName as i, mergeAdjacentObjectsLazy as n, syncSchemaRef as o, setDiscriminatorEnum as r, extractStringsFromNodes as t };
+//# sourceMappingURL=extractStringsFromNodes-WMYJ8nQL.d.ts.map