@eliseev_s/tolk-tlb-transpiler
Version:
Transpile Tolk structs to TLB definitions and generate TypeScript wrappers for TON blockchain smart contracts
106 lines • 4.33 kB
JavaScript
;
// ============================================================================
// Code Generation Helpers - Generate reusable helper functions instead of IIFE
// ============================================================================
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateDictLoaderHelper = generateDictLoaderHelper;
exports.generateOptionalStructLoaderHelper = generateOptionalStructLoaderHelper;
exports.collectRequiredHelpers = collectRequiredHelpers;
exports.generateAllHelpers = generateAllHelpers;
const type_converters_1 = require("./type-converters");
/**
* Generate helper function for loading dictionary from optional cell
* Replaces inline IIFE: (() => { const dictCell = stack.readCellOpt(); return loadDict_X_Y(dictCell); })()
*/
function generateDictLoaderHelper(keyType, valueType) {
const keyInfo = (0, type_converters_1.generateDictKeyDescriptor)(keyType);
const keyTs = keyInfo.ts; // Use the correct TS type (number for <=32 bits, bigint for >32)
const valueTs = (0, type_converters_1.tolkTypeToTSType)(valueType);
const loaderName = (0, type_converters_1.getDictLoaderName)(keyType, valueType);
return `function ${loaderName}FromStack(stack: TupleReader): Dictionary<${keyTs}, ${valueTs}> {
const dictCell = stack.readCellOpt();
return ${loaderName}(dictCell);
}`;
}
/**
* Generate helper function for loading optional struct from cell
* Replaces inline IIFE: (() => { const cell = stack.readCellOpt(); return cell === null ? null : loadStruct(cell.beginParse()) })()
*/
function generateOptionalStructLoaderHelper(structName) {
return `function load${structName}Opt(cell: Cell | null): ${structName} | null {
return cell === null ? null : load${structName}(cell.beginParse());
}`;
}
/**
* Collect all unique helper functions needed for the generated code
*/
function collectRequiredHelpers(structs, getMethods) {
const helpers = [];
const generatedDictLoaders = new Set();
const generatedStructLoaders = new Set();
const processType = (type) => {
if (!type)
return;
switch (type.kind) {
case 'map':
const loaderName = (0, type_converters_1.getDictLoaderName)(type.key, type.value);
if (!generatedDictLoaders.has(loaderName)) {
generatedDictLoaders.add(loaderName);
helpers.push(generateDictLoaderHelper(type.key, type.value));
}
processType(type.key);
processType(type.value);
break;
case 'nullable':
if (type.inner.kind === 'type_identifier') {
const helperName = `load${type.inner.name}Opt`;
if (!generatedStructLoaders.has(helperName)) {
generatedStructLoaders.add(helperName);
helpers.push(generateOptionalStructLoaderHelper(type.inner.name));
}
}
processType(type.inner);
break;
case 'tensor':
case 'tuple':
type.items.forEach(processType);
break;
case 'union':
type.alternatives.forEach(processType);
break;
case 'generic':
type.params.forEach(processType);
break;
case 'cell_ref':
if (type.inner)
processType(type.inner);
break;
}
};
// Process all struct fields
for (const struct of structs) {
for (const field of struct.fields) {
processType(field.type);
}
}
// Process all get method types
for (const method of getMethods) {
processType(method.returnType);
for (const param of method.parameters) {
processType(param.type);
}
}
return helpers;
}
/**
* Generate all helper functions as a single string
*/
function generateAllHelpers(structs, getMethods) {
const helpers = collectRequiredHelpers(structs, getMethods);
if (helpers.length === 0) {
return '';
}
return `// Helper functions for loading complex types
${helpers.join('\n\n')}`;
}
//# sourceMappingURL=codegen-helpers.js.map