@abapify/ts-xsd 0.4.0 → 0.4.3

package/dist/generators/index.mjs

@@ -0,0 +1,635 @@
+import { l as resolveSchema, t as runCodegen } from "../runner-BSGqj8LM.mjs";
+import { r as generateInterfaces, t as defineConfig } from "../types-Ch0GQQ5n.mjs";
+
+//#region src/generators/raw-schema.ts
+/**
+* Create a raw schema generator plugin
+*
+* @example
+* ```ts
+* import { rawSchema } from '@abapify/ts-xsd/generators';
+*
+* export default defineConfig({
+*   generators: [
+*     rawSchema(),  // default export
+*     rawSchema({ namedExport: 'mySchema' }),  // named export
+*   ],
+* });
+* ```
+*/
+function rawSchema(options = {}) {
+	const { defaultExport = true, namedExport, $xmlns = true, $imports = true, $includes = true, $filename = false, exclude = ["annotation"], header = true, resolveIncludes = false, resolveAll = false, isolatedDeclarations = false, singleQuote = false } = options;
+	return {
+		name: "raw-schema",
+		transform(ctx) {
+			const { schema, source } = ctx;
+			let schemaToProcess = schema.schema;
+			if (options.resolve) {
+				const resolveOpts = options.resolve === true ? {} : options.resolve;
+				schemaToProcess = resolveSchema(schema.schema, resolveOpts);
+			}
+			if (resolveAll) schemaToProcess = resolveSchema(schema.schema, { filterToRootElements: true });
+			else if (resolveIncludes) schemaToProcess = resolveSchema(schema.schema, {
+				resolveImports: false,
+				keepImportsRef: true
+			});
+			const outputSchema = buildOutputSchema(schemaToProcess, {
+				$xmlns,
+				$imports: resolveAll ? false : $imports,
+				$includes: resolveAll || resolveIncludes ? false : $includes,
+				$filename,
+				exclude,
+				schemaName: schema.name,
+				resolveImport: ctx.resolveImport
+			});
+			const lines = [];
+			if (header) lines.push("/**", " * Auto-generated schema from XSD", " * ", " * DO NOT EDIT - Generated by ts-xsd codegen", ` * Source: ${source.name}/${schema.name}.xsd`, " */", "");
+			if (isolatedDeclarations) lines.push("import type { Schema } from '@abapify/ts-xsd';");
+			const shouldGenerateImports = !options.resolve && !resolveIncludes && !resolveAll && ($imports || $includes);
+			if (shouldGenerateImports) {
+				const imports = getSchemaImports(schema.schema, ctx.resolveImport, {
+					$imports,
+					$includes
+				});
+				if (imports.length > 0) for (const imp of imports) if (isolatedDeclarations) lines.push(`import { schema as ${imp.name} } from '${imp.path}';`);
+				else lines.push(`import ${imp.name} from '${imp.path}';`);
+			}
+			if (isolatedDeclarations || shouldGenerateImports && getSchemaImports(schema.schema, ctx.resolveImport, {
+				$imports,
+				$includes
+			}).length > 0) lines.push("");
+			const literal = objectToLiteral(outputSchema, true, "  ", 0, singleQuote);
+			if (isolatedDeclarations) {
+				const exportName = namedExport ?? "schema";
+				lines.push(`export const ${exportName} = ${literal} as const satisfies Schema;`);
+				if (defaultExport && !namedExport) lines.push(`export default ${exportName};`);
+			} else if (namedExport) lines.push(`export const ${namedExport} = ${literal} as const;`);
+			else if (defaultExport) lines.push(`export default ${literal} as const;`);
+			lines.push("");
+			return [{
+				path: `${schema.name}.ts`,
+				content: lines.join("\n")
+			}];
+		}
+	};
+}
+function buildOutputSchema(schema, options) {
+	const result = {};
+	const excludeSet = new Set(options.exclude);
+	if (options.$xmlns && schema.$xmlns) result.$xmlns = schema.$xmlns;
+	if (options.$imports && schema.import) {
+		const importRefs = [];
+		const imports = schema.import;
+		for (const imp of imports) if (imp.schemaLocation) {
+			if (!options.resolveImport(imp.schemaLocation)) throw new Error(`Cannot resolve xs:import schemaLocation: ${imp.schemaLocation} (in ${options.schemaName}.xsd)`);
+			const name = imp.schemaLocation.replace(/\.xsd$/, "").replace(/^.*\//, "");
+			importRefs.push(new SchemaRef(name));
+		}
+		if (importRefs.length > 0) result.$imports = importRefs;
+	}
+	if (options.$includes && schema.include) {
+		const includeRefs = [];
+		const includes = schema.include;
+		for (const inc of includes) if (inc.schemaLocation) {
+			if (!options.resolveImport(inc.schemaLocation)) throw new Error(`Cannot resolve xs:include schemaLocation: ${inc.schemaLocation} (in ${options.schemaName}.xsd)`);
+			const name = inc.schemaLocation.replace(/\.xsd$/, "").replace(/^.*\//, "");
+			includeRefs.push(new SchemaRef(name));
+		}
+		if (includeRefs.length > 0) result.$includes = includeRefs;
+	}
+	if (options.$filename) result.$filename = `${options.schemaName}.xsd`;
+	for (const [key, value] of Object.entries(schema)) {
+		if (key === "$xmlns" || key === "$imports" || key === "$includes" || key === "$filename") continue;
+		if (key === "import" && options.$imports) continue;
+		if (key === "include" && options.$includes) continue;
+		if (!excludeSet.has(key)) result[key] = filterDeep(value, excludeSet);
+	}
+	return result;
+}
+function getSchemaImports(schema, resolveImport, options = {
+	$imports: true,
+	$includes: true
+}) {
+	const imports = [];
+	if (options.$imports) {
+		const xsdImports = schema.import;
+		if (xsdImports) {
+			for (const imp of xsdImports) if (imp.schemaLocation) {
+				const modulePath = resolveImport(imp.schemaLocation);
+				if (modulePath) {
+					const name = imp.schemaLocation.replace(/\.xsd$/, "").replace(/^.*\//, "");
+					imports.push({
+						name,
+						path: modulePath
+					});
+				}
+			}
+		}
+	}
+	if (options.$includes) {
+		const xsdIncludes = schema.include;
+		if (xsdIncludes) {
+			for (const inc of xsdIncludes) if (inc.schemaLocation) {
+				const modulePath = resolveImport(inc.schemaLocation);
+				if (modulePath) {
+					const name = inc.schemaLocation.replace(/\.xsd$/, "").replace(/^.*\//, "");
+					imports.push({
+						name,
+						path: modulePath
+					});
+				}
+			}
+		}
+	}
+	return imports;
+}
+/** Marker class for schema references in $imports */
+var SchemaRef = class {
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+};
+/**
+* Format a string value as a single-quoted literal, unescaping JSON double quotes
+* and escaping any single quotes.
+*/
+function toSingleQuoteLiteral(jsonStr) {
+	return `'${jsonStr.slice(1, -1).replaceAll("\\\"", "\"").replaceAll("'", "\\'")}'`;
+}
+function filterDeep(value, exclude) {
+	if (value instanceof SchemaRef) return value;
+	if (Array.isArray(value)) return value.map((item) => filterDeep(item, exclude));
+	if (value !== null && typeof value === "object") {
+		const result = {};
+		for (const [k, v] of Object.entries(value)) if (!exclude.has(k)) result[k] = filterDeep(v, exclude);
+		return result;
+	}
+	return value;
+}
+function objectToLiteral(value, pretty, indent, depth, singleQuote = false) {
+	if (value === null || value === void 0) return "undefined";
+	if (value instanceof SchemaRef) return value.name;
+	if (typeof value === "string") {
+		const json = JSON.stringify(value);
+		if (singleQuote) return toSingleQuoteLiteral(json);
+		return json;
+	}
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		const items = value.map((item) => objectToLiteral(item, pretty, indent, depth + 1, singleQuote));
+		if (pretty) {
+			const itemIndent = indent.repeat(depth + 1);
+			const closeIndent = indent.repeat(depth);
+			return `[\n${items.map((item) => `${itemIndent}${item}`).join(",\n")},\n${closeIndent}]`;
+		}
+		return `[${items.join(", ")}]`;
+	}
+	if (typeof value === "object") {
+		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+		if (entries.length === 0) return "{}";
+		const props = entries.map(([key, val]) => {
+			let keyStr = key;
+			if (!isValidIdentifier(key)) {
+				const json = JSON.stringify(key);
+				keyStr = singleQuote ? toSingleQuoteLiteral(json) : json;
+			}
+			const valStr = objectToLiteral(val, pretty, indent, depth + 1, singleQuote);
+			return `${keyStr}: ${valStr}`;
+		});
+		if (pretty) {
+			const propIndent = indent.repeat(depth + 1);
+			const closeIndent = indent.repeat(depth);
+			return `{\n${props.map((prop) => `${propIndent}${prop}`).join(",\n")},\n${closeIndent}}`;
+		}
+		return `{ ${props.join(", ")} }`;
+	}
+	return "undefined";
+}
+const RESERVED_WORDS$2 = /* @__PURE__ */ new Set([
+	"break",
+	"case",
+	"catch",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"class",
+	"const",
+	"enum",
+	"export",
+	"extends",
+	"import",
+	"super",
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"await",
+	"null",
+	"true",
+	"false"
+]);
+function isValidIdentifier(str) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str) && !RESERVED_WORDS$2.has(str);
+}
+
+//#endregion
+//#region src/generators/inferred-types.ts
+/**
+* Create an inferred types generator plugin
+*
+* This generator should be used AFTER rawSchema() in the pipeline.
+* It modifies the generated schema file to add type exports.
+*
+* @example
+* ```ts
+* import { rawSchema, inferredTypes } from '@abapify/ts-xsd/generators';
+*
+* export default defineConfig({
+*   generators: [
+*     rawSchema(),
+*     inferredTypes(),  // Adds: export type Intf = InferSchema<typeof schema>;
+*   ],
+* });
+* ```
+*/
+function inferredTypes(options = {}) {
+	const { inferSchemaImport = "ts-xsd", typeNamePattern = "{Name}" } = options;
+	return {
+		name: "inferred-types",
+		transform(ctx) {
+			const { schema } = ctx;
+			const typeName = typeNamePattern.replace("{Name}", pascalCase$1(schema.name));
+			const lines = [
+				"/**",
+				" * Auto-generated type from schema",
+				" * ",
+				" * DO NOT EDIT - Generated by ts-xsd codegen",
+				" */",
+				"",
+				`import type { InferSchema } from '${inferSchemaImport}';`,
+				`import schema from './${schema.name}';`,
+				"",
+				`/** Inferred type for ${schema.name} schema */`,
+				`export type ${typeName} = InferSchema<typeof schema>;`,
+				"",
+				`export default schema;`,
+				""
+			];
+			return [{
+				path: `${schema.name}.typed.ts`,
+				content: lines.join("\n")
+			}];
+		}
+	};
+}
+function pascalCase$1(str) {
+	return str.replaceAll(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (s) => s.toUpperCase());
+}
+
+//#endregion
+//#region src/generators/interfaces.ts
+/**
+* Extract base name from schema name (handles paths like 'sap/atom' -> 'atom')
+*/
+function getBaseName(schemaName) {
+	return schemaName.split("/").at(-1) ?? schemaName;
+}
+function deriveRootTypeName(schemaName, pattern) {
+	const baseName = getBaseName(schemaName);
+	const capitalized = baseName.charAt(0).toUpperCase() + baseName.slice(1);
+	return pattern.replace("{name}", baseName).replace("{Name}", capitalized);
+}
+/**
+* Create an interfaces generator plugin
+*
+* @example
+* ```ts
+* import { interfaces } from '@abapify/ts-xsd/generators';
+*
+* export default defineConfig({
+*   generators: [
+*     interfaces(),                    // interfaces with imports
+*     interfaces({ flatten: true }),   // fully flattened types
+*   ],
+* });
+* ```
+*/
+function interfaces(options = {}) {
+	const { filePattern = options.flatten ? "{name}.flattened.ts" : "{name}.types.ts", header = true, flatten = false, rootTypePattern = "{Name}Schema", addJsDoc = true } = options;
+	return {
+		name: "interfaces",
+		transform(ctx) {
+			const { schema, source } = ctx;
+			const rootTypeName = deriveRootTypeName(schema.name, rootTypePattern);
+			const targetSchema = resolveSchema(schema.schema, { keepImportsRef: true });
+			const hasRootElements = targetSchema.element && targetSchema.element.length > 0;
+			if (flatten && !hasRootElements) return [];
+			const { code } = generateInterfaces(targetSchema, {
+				rootTypeName: flatten && hasRootElements ? rootTypeName : null,
+				addJsDoc,
+				flatten
+			});
+			const lines = [];
+			if (header) lines.push("/**", " * Auto-generated TypeScript interfaces from XSD", " * DO NOT EDIT - Generated by ts-xsd codegen", ` * Source: ${source.name}/${schema.name}.xsd`, flatten ? " * Mode: Flattened" : " * Mode: Interfaces", " */", "");
+			lines.push(code);
+			return [{
+				path: filePattern.replace("{name}", schema.name).replace("{source}", source.name),
+				content: lines.join("\n")
+			}];
+		}
+	};
+}
+
+//#endregion
+//#region src/generators/index-barrel.ts
+/**
+* Create an index barrel generator plugin
+*
+* This generator runs in finalize() after all schemas are processed.
+* It generates an index.ts that re-exports all schemas.
+*
+* @example
+* ```ts
+* import { rawSchema, indexBarrel } from '@abapify/ts-xsd/generators';
+*
+* export default defineConfig({
+*   generators: [
+*     rawSchema(),
+*     indexBarrel(),  // Generates index.ts with all exports
+*   ],
+* });
+* ```
+*/
+function indexBarrel(options = {}) {
+	const { filename = "index.ts", importExtension = "", namedExports = false, includeTypedExports = false, header = true } = options;
+	return {
+		name: "index-barrel",
+		finalize(ctx) {
+			const files = [];
+			for (const [sourceName, schemas] of ctx.processedSchemas) {
+				if (!ctx.sources[sourceName]) continue;
+				const lines = [];
+				if (header) lines.push("/**", ` * Auto-generated index for ${sourceName} schemas`, " * ", " * DO NOT EDIT - Generated by ts-xsd codegen", " */", "");
+				const sortedSchemas = [...schemas].sort((a, b) => a.name.localeCompare(b.name));
+				for (const schema of sortedSchemas) {
+					if (namedExports) {
+						const exportName = toValidIdentifier$1(schema.name);
+						lines.push(`export { default as ${exportName} } from './${schema.name}${importExtension}';`);
+					} else lines.push(`export * from './${schema.name}${importExtension}';`);
+					if (includeTypedExports) {
+						const typeName = pascalCase(schema.name);
+						lines.push(`export type { ${typeName} } from './${schema.name}.typed${importExtension}';`);
+					}
+				}
+				lines.push("");
+				files.push({
+					path: filename,
+					content: lines.join("\n")
+				});
+			}
+			return files;
+		}
+	};
+}
+const RESERVED_WORDS$1 = /* @__PURE__ */ new Set([
+	"break",
+	"case",
+	"catch",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"class",
+	"const",
+	"enum",
+	"export",
+	"extends",
+	"import",
+	"super",
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"await",
+	"null",
+	"true",
+	"false"
+]);
+function toValidIdentifier$1(name) {
+	let result = name.replaceAll(/-([a-zA-Z])/g, (_, c) => c.toUpperCase());
+	if (RESERVED_WORDS$1.has(result)) result = `${result}_`;
+	return result;
+}
+function pascalCase(str) {
+	return str.replaceAll(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (s) => s.toUpperCase());
+}
+
+//#endregion
+//#region src/generators/typed-schemas.ts
+/**
+* Create a typed schemas generator plugin
+*
+* This generator runs in finalize() after all schemas are processed.
+* It generates a single index file that exports typed schema wrappers.
+*
+* @example
+* ```ts
+* import { rawSchema, interfaces, typedSchemas } from '@abapify/ts-xsd/generators';
+*
+* export default defineConfig({
+*   generators: [
+*     rawSchema(),
+*     interfaces(),
+*     typedSchemas(),  // Generates typed wrappers
+*   ],
+* });
+* ```
+*/
+function typedSchemas(options = {}) {
+	const { outputPath = "src/schemas/generated/index.ts", tsXsdPath = "ts-xsd", schemasPath = "./schemas", typesPath = "./types", header = true } = options;
+	return {
+		name: "typed-schemas",
+		finalize(ctx) {
+			const lines = [];
+			if (header) lines.push("/**", " * Auto-generated typed schema exports", " * ", " * DO NOT EDIT - Generated by ts-xsd codegen", " * ", " * These schemas have pre-computed types for full type inference.", " * Use these instead of raw schemas for type-safe parsing/building.", " * ", " * @example", " * import { classes } from '@abapify/adt-schemas';", " * const data = classes.parse(xml);  // data is fully typed!", " */", "");
+			lines.push(`import { typedSchema, type TypedSchema } from '${tsXsdPath}';`);
+			lines.push("");
+			const schemaExports = [];
+			for (const [sourceName, schemas] of ctx.processedSchemas) {
+				lines.push(`// ${sourceName.toUpperCase()} schemas`);
+				for (const schema of schemas) {
+					const rootTypes = extractRootTypes(schema);
+					if (rootTypes.length === 0) {
+						lines.push(`// ${schema.name}: No root elements found, skipping typed export`);
+						continue;
+					}
+					schemaExports.push({
+						name: schema.name,
+						sourceName,
+						rootTypes
+					});
+					const exportName = toValidIdentifier(schema.name);
+					const schemaImport = `${schemasPath}/${sourceName}/${schema.name}`;
+					const typesImport = `${typesPath}/${sourceName}/${schema.name}.types`;
+					lines.push(`import _${exportName} from '${schemaImport}';`);
+					if (rootTypes.length === 1) lines.push(`import type { ${rootTypes[0]} } from '${typesImport}';`);
+					else lines.push(`import type { ${rootTypes.join(", ")} } from '${typesImport}';`);
+				}
+				lines.push("");
+			}
+			lines.push("// ============================================================================");
+			lines.push("// TYPED SCHEMA EXPORTS");
+			lines.push("// ============================================================================");
+			lines.push("");
+			for (const { name, rootTypes } of schemaExports) {
+				const exportName = toValidIdentifier(name);
+				if (rootTypes.length === 1) lines.push(`export const ${exportName}: TypedSchema<${rootTypes[0]}> = typedSchema<${rootTypes[0]}>(_${exportName});`);
+				else {
+					const unionType = rootTypes.join(" | ");
+					lines.push(`export const ${exportName}: TypedSchema<${unionType}> = typedSchema<${unionType}>(_${exportName});`);
+				}
+			}
+			lines.push("");
+			lines.push("// Types are internal - import directly from types/{source}/{schema}.types if needed");
+			lines.push("");
+			return [{
+				path: outputPath,
+				content: lines.join("\n")
+			}];
+		}
+	};
+}
+/**
+* Extract root element type names from a schema
+*/
+function extractRootTypes(schema) {
+	const types = [];
+	const elements = schema.schema.element;
+	if (!elements || elements.length === 0) return types;
+	for (const element of elements) if (element.type) {
+		const typeName = stripNamespacePrefix(element.type);
+		types.push(toPascalCase(typeName));
+	} else if (element.name) types.push(toPascalCase(element.name));
+	return types;
+}
+/**
+* Strip namespace prefix from QName (e.g., "ns:TypeName" -> "TypeName")
+*/
+function stripNamespacePrefix(qname) {
+	const colonIndex = qname.indexOf(":");
+	return colonIndex >= 0 ? qname.slice(colonIndex + 1) : qname;
+}
+/**
+* Convert to PascalCase
+*/
+function toPascalCase(str) {
+	return str.replaceAll(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (s) => s.toUpperCase());
+}
+const RESERVED_WORDS = /* @__PURE__ */ new Set([
+	"break",
+	"case",
+	"catch",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"class",
+	"const",
+	"enum",
+	"export",
+	"extends",
+	"import",
+	"super",
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"await",
+	"null",
+	"true",
+	"false"
+]);
+function toValidIdentifier(name) {
+	let result = name.replaceAll(/-([a-zA-Z])/g, (_, c) => c.toUpperCase());
+	if (RESERVED_WORDS.has(result)) result = `${result}_`;
+	return result;
+}
+
+//#endregion
+export { defineConfig, indexBarrel, inferredTypes, interfaces, rawSchema, runCodegen, typedSchemas };
+//# sourceMappingURL=index.mjs.map