brick-codegen/dist/index.js

Better React Native native module development

import { a as IOSPlatformGenerator, c as Generator, i as isIOSPlatformGenerator, n as PlatformRegistry, o as AndroidPlatformGenerator, r as isAndroidPlatformGenerator, s as Parser, t as Scanner } from "./scanner-DT8NcN4x.js";

//#region src/utils/type-mapping.ts
const TYPE_MAPPINGS = {
	string: {
		typescript: "string",
		swift: "String",
		objectiveC: "NSString *",
		java: "String",
		kotlin: "String"
	},
	number: {
		typescript: "number",
		swift: "Double",
		objectiveC: "double",
		java: "double",
		kotlin: "Double"
	},
	boolean: {
		typescript: "boolean",
		swift: "Bool",
		objectiveC: "BOOL",
		java: "boolean",
		kotlin: "Boolean"
	},
	void: {
		typescript: "void",
		swift: "Void",
		objectiveC: "void",
		java: "void",
		kotlin: "Unit"
	},
	any: {
		typescript: "any",
		swift: "Any",
		objectiveC: "id",
		java: "Object",
		kotlin: "Any"
	}
};
function mapTypeScriptType(tsType, platform) {
	if (tsType.startsWith("Promise<") && tsType.endsWith(">")) return mapTypeScriptType(tsType.slice(8, -1), platform);
	if (tsType.endsWith("[]")) {
		const elementType = tsType.slice(0, -2);
		if (elementType.startsWith("{") && elementType.endsWith("}")) switch (platform) {
			case "swift": return `[${elementType}]`;
			case "objectiveC": return "NSArray *";
			case "java": return "ReadableArray";
			case "kotlin": return `List<ReadableMap>`;
			default: return "Array";
		}
		const mappedElementType = mapTypeScriptType(elementType, platform);
		switch (platform) {
			case "swift": return `[${mappedElementType}]`;
			case "objectiveC": return "NSArray *";
			case "java": return "ReadableArray";
			case "kotlin": return `List<${mappedElementType}>`;
			default: return "Array";
		}
	}
	if (tsType.startsWith("{") && tsType.endsWith("}")) switch (platform) {
		case "swift": return tsType;
		case "objectiveC": return "id";
		case "java": return "ReadableMap";
		case "kotlin": return "ReadableMap";
		default: return "Object";
	}
	const mapping = TYPE_MAPPINGS[tsType];
	if (mapping) return mapping[platform];
	if (tsType.match(/^[A-Z][a-zA-Z0-9]*$/)) {
		console.log(`[type-mapping] Converting interface type '${tsType}' for platform '${platform}'`);
		switch (platform) {
			case "swift": return tsType;
			case "objectiveC": return "id";
			case "java": return "ReadableMap";
			case "kotlin": return "ReadableMap";
			default: return "Object";
		}
	}
	return TYPE_MAPPINGS.any?.[platform] || "Object";
}
function generateMethodSignature(methodName, params, returnType, platform, isAsync = false) {
	switch (platform) {
		case "swift": return generateSwiftSignature(methodName, params, returnType, isAsync);
		case "objectiveC": return generateObjCSignature(methodName, params, returnType, isAsync);
		case "java": return generateJavaSignature(methodName, params, returnType, isAsync);
		case "kotlin": return generateKotlinSignature(methodName, params, returnType, isAsync);
		default: throw new Error(`Unsupported platform: ${platform}`);
	}
}
function generateSwiftSignature(methodName, params, returnType, isAsync) {
	return `func ${methodName}(${params.map((p) => `${p.name}: ${mapTypeScriptType(p.type, "swift")}`).join(", ")}) ${isAsync ? "async " : ""}throws -> ${mapTypeScriptType(returnType, "swift")}`;
}
function generateObjCSignature(methodName, params, returnType, isAsync) {
	let signature = `- (${isAsync ? "void" : mapTypeScriptType(returnType, "objectiveC")})${methodName}`;
	if (params.length > 0) {
		const paramStrings = params.map((param, index) => {
			const objcType = mapTypeScriptType(param.type, "objectiveC");
			return index === 0 ? `:(${objcType})${param.name}` : `${param.name}:(${objcType})${param.name}`;
		});
		signature += paramStrings.join(" ");
	}
	if (isAsync) signature += " resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject";
	return signature;
}
function generateJavaSignature(methodName, params, returnType, isAsync) {
	const mappedReturnType = isAsync ? "void" : mapTypeScriptType(returnType, "java");
	const paramList = params.map((p) => `${mapTypeScriptType(p.type, "java")} ${p.name}`);
	if (isAsync) paramList.push("Promise promise");
	return `public ${mappedReturnType} ${methodName}(${paramList.join(", ")})`;
}
function generateKotlinSignature(methodName, params, returnType, isAsync) {
	const mappedReturnType = isAsync ? "Unit" : mapTypeScriptType(returnType, "kotlin");
	const paramList = params.map((p) => `${p.name}: ${mapTypeScriptType(p.type, "kotlin")}`);
	if (isAsync) paramList.push("promise: Promise");
	return `fun ${methodName}(${paramList.join(", ")}): ${mappedReturnType}`;
}

//#endregion
export { AndroidPlatformGenerator, Generator, IOSPlatformGenerator, Parser, PlatformRegistry, Scanner, TYPE_MAPPINGS, generateMethodSignature, isAndroidPlatformGenerator, isIOSPlatformGenerator, mapTypeScriptType };
//# sourceMappingURL=index.js.map