SearchInputPlaceholder: localize()

in src/eventSchemas/commands/searchSchemas.ts [65:157]
82 lines of code
7 McCabe index (conditional complexity)

                SearchInputPlaceholder: localize(
                    'AWS.schemas.search.input.placeholder',
                    'Search for schema keyword...'
                ),
                VersionPrefix: localize('AWS.schemas.search.version.prefix', 'Search matched version:'),
                Scripts: loadScripts,
                Libraries: loadLibs,
                Stylesheets: loadStylesheets,
            }),
        })

        view.webview.postMessage({
            command: 'setLocalizedMessages',
            noSchemasFound: localize('AWS.schemas.search.no_results', 'No schemas found'),
            searching: localize('AWS.schemas.search.searching', 'Searching for schemas...'),
            loading: localize('AWS.schemas.search.loading', 'Loading...'),
            select: localize('AWS.schemas.search.select', 'Select a schema'),
        })

        view.webview.onDidReceiveMessage(
            createMessageReceivedFunc({
                registryNames: registryNames,
                schemaClient: client,
                telemetryService: globals.telemetry,
                onPostMessage: message => view.webview.postMessage(message),
                outputChannel: params.outputChannel,
            }),
            undefined,
            globals.context.subscriptions
        )
    } catch (err) {
        webviewResult = 'Failed'
        const error = err as Error
        logger.error('Error searching schemas: %O', error)
    } finally {
        // TODO make this telemetry actually record failures
        recordSchemasSearch({ result: webviewResult })
    }
}

export async function getRegistryNames(node: RegistryItemNode | SchemasNode, client: SchemaClient): Promise<string[]> {
    const registryNames: string[] = []

    if (node instanceof SchemasNode) {
        try {
            const registries = await toArrayAsync(listRegistryItems(client))
            registries.forEach(element => registryNames.push(element.RegistryName!))
        } catch (err) {
            const error = err as Error
            getLogger().error(error)
            vscode.window.showErrorMessage(
                localize('AWS.message.error.schemas.search.failed_to_load_resources', 'Error loading Schemas resources')
            )
        }
    }

    if (node instanceof RegistryItemNode) {
        registryNames.push(node.registryName)
    }

    return registryNames
}

export function getPageHeader(registryNames: string[]): string {
    if (registryNames.length === 1) {
        return localize('AWS.schemas.search.header.text.singleRegistry', 'Search "{0}" registry', registryNames[0])
    }

    return localize('AWS.schemas.search.header.text.allRegistries', 'Search across all registries')
}

export interface CommandMessage {
    command: string
    keyword?: string
    schemaSummary?: SchemaVersionedSummary
    version?: string
}

export function createMessageReceivedFunc({
    registryNames,
    schemaClient,
    telemetryService,
    ...restParams
}: {
    registryNames: string[]
    schemaClient: SchemaClient
    telemetryService: TelemetryService
    onPostMessage(message: any): Thenable<boolean>
    outputChannel: vscode.OutputChannel
}): (message: CommandMessage) => Promise<void> {
    return async (message: CommandMessage) => {
        switch (message.command) {
            case 'fetchSchemaContent': {