Method createLibrary

src/code-gen/word-packer.ts:90–153

(structsAndEnums: Array<AbiStruct | AbiEnum>, context: FileContext)

export class UnpackerGen {
	static createLibrary(structsAndEnums: Array<AbiStruct | AbiEnum>, context: FileContext): {
    code: string;
    libraryName?: string;
    externalCode: string;
    hardhatTest: string
  } {
		const libraryCode: string[] = [];
    const externalCode: string[] = [];
    const hardhatTests: string[] = [];
    let processedStruct: ProcessedStruct;
    
		for (let structOrEnum of structsAndEnums) {
			if (structOrEnum.dynamic) {
				throw Error('Dynamic sized structs not currently supported');
			}
			if (structOrEnum.meta === 'enum') {
				libraryCode.push(
          arrJoiner(abiStructToSol(structOrEnum)),
          ''
        );
			} else {
        processedStruct = processStruct(structOrEnum, context)
        const code = generateCoderLibrary(processedStruct, context)
        if (!context.opts.constantsFile) {
          libraryCode.push(arrJoiner(context.constants))
        }
        libraryCode.push(code, '');
        const externalFns = generateExternalCoder(
          context.functions,
          structOrEnum.name,
          `_${structOrEnum.name.toCamelCase()}`,
          `${structOrEnum.name}Coder`
        );
        externalCode.push(arrJoiner(externalFns.externalCode))
        hardhatTests.push(generateHardhatTest(processedStruct, externalFns.externalFunctions, structOrEnum.name))
        context.clearCode();
			}
		}
		if (libraryCode.length && libraryCode[libraryCode.length - 1] === '') {
			libraryCode.pop();
		}
    // let code = arrJoiner([
    //   ...generateFileHeader(true, context.opts.unsafe, context.opts.constantsFile && ['import "./CoderConstants.sol";']),
    //   ...libraryCode,
    // ])
		// code = prettierFormat(
		// 	context.opts.noComments ? strip(code) : code
		// );
    // const testCode = arrJoiner(generateExternalCoder(context.functions, ))
    const structs = structsAndEnums.filter(f => f.meta === 'struct');
    const libraryName = structs.length === 1 && `${structs[0].name}Coder`;
    const code = generateSolFile(libraryCode, context, context.opts.constantsFile && ['import "./CoderConstants.sol";']);
    const coderPath = isSolFile(context.opts.output) ? context.opts.output : path.join(context.opts.output, `${libraryName}.sol`);
    const testPath = context.opts.testContractsDirectory || getDir(coderPath);

    const relativePath = path.normalize(path.relative(testPath, coderPath))
    const externalFile = generateSolFile(externalCode, context, [`import "${relativePath}";`]);
    return {