@seidor-cloud-produtos/orbit-backend-lib 2.0.110 → 2.0.111

package/dist/clean-arch/infra/scaledjob/amqp/runner.spec.js

@@ -5,123 +5,113 @@ const runner_1 = require("./runner");
 (0, vitest_1.describe)('RabbitMQScaledJobRunner', () => {
     let amqpQueue;
     let handler;
-    let options;
-    let onFinally;
-    let runner;
+    let logger;
     (0, vitest_1.beforeEach)(() => {
         amqpQueue = {
-            connect: vitest_1.vi.fn().mockResolvedValue(undefined),
-            get: vitest_1.vi.fn().mockResolvedValue(null),
+            get: vitest_1.vi.fn(),
             ack: vitest_1.vi.fn().mockResolvedValue(undefined),
             nack: vitest_1.vi.fn().mockResolvedValue(undefined),
             close: vitest_1.vi.fn().mockResolvedValue(undefined),
         };
-        handler = { handle: vitest_1.vi.fn().mockResolvedValue(undefined) };
-        options = {
-            manualAck: true,
-            timeoutMs: 1000,
-            errorStrategy: 'nack-dlq',
-            parse: vitest_1.vi.fn((raw) => ({ ok: true, msg: 'parsed' })),
+        handler = {
+            handle: vitest_1.vi.fn().mockResolvedValue(undefined),
+            getSimultaneity: vitest_1.vi.fn().mockReturnValue(1),
+            getTimeoutPerMessageSeconds: vitest_1.vi.fn().mockReturnValue(undefined),
         };
-        onFinally = vitest_1.vi.fn();
-        runner = new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', handler, options);
+        logger = {
+            info: vitest_1.vi.fn(),
+            warn: vitest_1.vi.fn(),
+            error: vitest_1.vi.fn(),
+            debug: vitest_1.vi.fn(),
+        };
+        vitest_1.vi.spyOn(process, 'exit').mockImplementation((() => undefined));
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
     });
-    (0, vitest_1.it)('should connect, get, handle, ack and close (happy path)', async () => {
-        const rawMessage = { content: Buffer.from('msg') };
+    const makeRunner = (options) => new runner_1.RabbitMQScaledJobRunner(amqpQueue, 'queue', handler, options, logger);
+    (0, vitest_1.it)('should connect the polling flow, parse the message, ack and close', async () => {
+        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
         const channel = {};
+        const runner = makeRunner();
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
         await runner.run();
-        (0, vitest_1.expect)(amqpQueue.connect).toHaveBeenCalledWith('vhost');
         (0, vitest_1.expect)(amqpQueue.get).toHaveBeenCalledWith('queue', { noAck: false });
-        (0, vitest_1.expect)(options.parse).toHaveBeenCalledWith(rawMessage);
-        (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ ok: true, msg: 'parsed' });
+        (0, vitest_1.expect)(handler.handle).toHaveBeenCalledWith({ id: '1' });
         (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
-        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
     });
-    (0, vitest_1.it)('should not ack if manualAck is false', async () => {
-        options.manualAck = false;
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+    (0, vitest_1.it)('should skip ack when manualAck is disabled', async () => {
+        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
+        const runner = makeRunner({ manualAck: false });
+        amqpQueue.get.mockResolvedValue({ channel: {}, rawMessage });
         await runner.run();
+        (0, vitest_1.expect)(amqpQueue.get).toHaveBeenCalledWith('queue', { noAck: true });
         (0, vitest_1.expect)(amqpQueue.ack).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(amqpQueue.nack).not.toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should nack with correct strategy', async () => {
-        options.errorStrategy = 'nack-requeue';
-        const rawMessage = { content: Buffer.from('msg') };
+    (0, vitest_1.it)('should apply nack-requeue when handler fails', async () => {
+        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
         const channel = {};
+        const runner = makeRunner({ errorStrategy: 'nack-requeue' });
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw new Error('fail');
-        });
+        handler.handle.mockRejectedValue(new Error('fail'));
         await runner.run();
         (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, true);
+        (0, vitest_1.expect)(amqpQueue.ack).not.toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should nack with default strategy', async () => {
-        options.errorStrategy = 'nack-dlq';
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw new Error('fail');
-        });
-        await runner.run();
-        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
-    });
-    (0, vitest_1.it)('should log and return if no message is available', async () => {
+    (0, vitest_1.it)('should stop when there is no message available', async () => {
+        const runner = makeRunner();
         amqpQueue.get.mockResolvedValue(null);
         await runner.run();
         (0, vitest_1.expect)(handler.handle).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Nenhuma mensagem disponível.');
     });
-    (0, vitest_1.it)('should log error if amqpQueue.connect throws', async () => {
-        amqpQueue.connect.mockRejectedValue(new Error('fail'));
-        await runner.run();
-        (0, vitest_1.expect)(amqpQueue.connect).toHaveBeenCalledWith('vhost');
-    });
-    (0, vitest_1.it)('should log error if amqpQueue.close throws', async () => {
-        amqpQueue.close.mockRejectedValue(new Error('fail'));
-        const rawMessage = { content: Buffer.from('msg') };
+    (0, vitest_1.it)('should handle timeout and nack the message', async () => {
+        vitest_1.vi.useFakeTimers();
+        const rawMessage = { content: Buffer.from(JSON.stringify({ id: '1' })) };
         const channel = {};
+        const runner = makeRunner();
         amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        await runner.run();
-        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalled();
+        handler.handle.mockImplementation(() => new Promise(() => undefined));
+        handler.getTimeoutPerMessageSeconds.mockReturnValue(1);
+        const runPromise = runner.run();
+        await vitest_1.vi.advanceTimersByTimeAsync(1000);
+        await runPromise;
+        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro: Timeout');
     });
-    (0, vitest_1.it)('should call onFinally if close fails', async () => {
-        amqpQueue.close.mockRejectedValue(new Error('fail'));
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        await runner.run();
-        // onFinally is called inside finishProcess
-        // No assertion needed for logger, just ensure no throw
+    (0, vitest_1.it)('should ignore errors when nack strategy fails', async () => {
+        const runner = makeRunner({ errorStrategy: 'nack-dlq' });
+        amqpQueue.nack.mockRejectedValue(new Error('nack failed'));
+        await (0, vitest_1.expect)(runner['errorStrategy']({
+            channel: {},
+            rawMessage: { content: Buffer.from('{}') },
+        })).resolves.toBeUndefined();
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Falha ao aplicar estratégia de erro');
     });
-    (0, vitest_1.it)('should handle timeout and call nack', async () => {
-        options.timeoutMs = 10;
-        handler.handle = vitest_1.vi.fn(() => new Promise(() => { }));
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        await runner.run();
-        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+    (0, vitest_1.it)('should return early when there is no message to handle as error context', async () => {
+        const runner = makeRunner();
+        await (0, vitest_1.expect)(runner['handleError'](new Error('fail'), null)).resolves.toBeUndefined();
+        (0, vitest_1.expect)(amqpQueue.nack).not.toHaveBeenCalled();
     });
-    (0, vitest_1.it)('should handle error in nack gracefully', async () => {
-        amqpQueue.nack.mockRejectedValue(new Error('fail'));
-        options.errorStrategy = 'nack-dlq';
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
-        handler.handle = vitest_1.vi.fn(() => {
-            throw new Error('fail');
-        });
+    (0, vitest_1.it)('should log close errors and still finish the process', async () => {
+        const runner = makeRunner();
+        amqpQueue.get.mockResolvedValue(null);
+        amqpQueue.close.mockRejectedValue(new Error('close failed'));
         await runner.run();
-        (0, vitest_1.expect)(amqpQueue.nack).toHaveBeenCalledWith(channel, rawMessage, false);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro ao fechar conexão', vitest_1.expect.any(Error));
+        (0, vitest_1.expect)(process.exit).toHaveBeenCalledWith(0);
     });
-    (0, vitest_1.it)('should handle error in ack gracefully', async () => {
-        amqpQueue.ack.mockRejectedValue(new Error('fail'));
-        const rawMessage = { content: Buffer.from('msg') };
-        const channel = {};
-        amqpQueue.get.mockResolvedValue({ channel, rawMessage });
+    (0, vitest_1.it)('should handle unexpected outer errors and still close', async () => {
+        const runner = makeRunner();
+        handler.getSimultaneity.mockImplementation(() => {
+            throw new Error('outer failure');
+        });
         await runner.run();
-        (0, vitest_1.expect)(amqpQueue.ack).toHaveBeenCalledWith(channel, rawMessage);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[RabbitMQScaledJobRunner] Erro: {}');
+        (0, vitest_1.expect)(amqpQueue.close).toHaveBeenCalledTimes(1);
     });
 });

package/dist/clean-arch/infra/scaledjob/sqs/runner.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/infra/scaledjob/sqs/runner.spec.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+const { sendMock } = vitest_1.vi.hoisted(() => ({
+    sendMock: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('@aws-sdk/client-sqs', () => ({
+    ReceiveMessageCommand: class ReceiveMessageCommand {
+        input;
+        constructor(input) {
+            this.input = input;
+        }
+    },
+    DeleteMessageCommand: class DeleteMessageCommand {
+        input;
+        constructor(input) {
+            this.input = input;
+        }
+    },
+    SQSClient: class SQSClient {
+        config;
+        send = sendMock;
+        constructor(config) {
+            this.config = config;
+        }
+    },
+}));
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const handler_1 = tslib_1.__importDefault(require("../../../application/queue/handler"));
+const runner_1 = require("./runner");
+class TestHandler extends handler_1.default {
+    handleMock = vitest_1.vi.fn().mockResolvedValue(undefined);
+    constructor(simultaneity = 1, timeoutPerMessageSeconds) {
+        super();
+        this.simultaneity = simultaneity;
+        this.timeoutPerMessageSeconds = timeoutPerMessageSeconds;
+    }
+    async handle(message) {
+        await this.handleMock(message);
+    }
+}
+const createLogger = () => ({
+    info: vitest_1.vi.fn(),
+    warn: vitest_1.vi.fn(),
+    error: vitest_1.vi.fn(),
+    debug: vitest_1.vi.fn(),
+});
+(0, vitest_1.describe)('SQSScaledJobRunner', () => {
+    (0, vitest_1.beforeEach)(() => {
+        sendMock.mockReset();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.useRealTimers();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('should receive, process and delete messages from SQS', async () => {
+        vitest_1.vi.useFakeTimers();
+        const handler = new TestHandler(1, 1);
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+            waitMessagesTimeSeconds: 5,
+        }, logger);
+        sendMock
+            .mockResolvedValueOnce({
+            Messages: [
+                {
+                    Body: JSON.stringify({ id: '1' }),
+                    ReceiptHandle: 'receipt-handle',
+                },
+            ],
+        })
+            .mockResolvedValueOnce({});
+        const processPromise = runner.process();
+        await vitest_1.vi.runAllTimersAsync();
+        await processPromise;
+        (0, vitest_1.expect)(sendMock).toHaveBeenNthCalledWith(1, vitest_1.expect.any(client_sqs_1.ReceiveMessageCommand));
+        (0, vitest_1.expect)(sendMock.mock.calls[0][0].input).toEqual({
+            QueueUrl: 'queue-url',
+            MaxNumberOfMessages: 1,
+            WaitTimeSeconds: 5,
+        });
+        (0, vitest_1.expect)(handler.handleMock).toHaveBeenCalledWith({ id: '1' });
+        (0, vitest_1.expect)(sendMock).toHaveBeenNthCalledWith(2, vitest_1.expect.any(client_sqs_1.DeleteMessageCommand));
+        (0, vitest_1.expect)(sendMock.mock.calls[1][0].input).toEqual({
+            QueueUrl: 'queue-url',
+            ReceiptHandle: 'receipt-handle',
+        });
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Mensagem processada com sucesso');
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Mensagem deletada');
+    });
+    (0, vitest_1.it)('should keep polling until simultaneity is reached when there are no messages', async () => {
+        const handler = new TestHandler(2);
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, logger);
+        sendMock.mockResolvedValue({
+            Messages: [],
+        });
+        await runner.process();
+        (0, vitest_1.expect)(sendMock).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith('[SQSScaledJobRunner] Nenhuma mensagem disponível.');
+        (0, vitest_1.expect)(handler.handleMock).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('should log invalid messages and guard the parser against unsupported inputs', async () => {
+        const handler = new TestHandler();
+        const logger = createLogger();
+        const runner = new runner_1.SQSScaledJobRunner(handler, 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, logger);
+        sendMock.mockResolvedValueOnce({
+            Messages: [
+                {
+                    Body: null,
+                    ReceiptHandle: 'receipt-handle',
+                },
+            ],
+        });
+        await runner.process();
+        (0, vitest_1.expect)(logger.info).toHaveBeenCalledWith(vitest_1.expect.stringContaining('[SQSScaledJobRunner] Erro:'));
+        (0, vitest_1.expect)(handler.handleMock).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(() => runner_1.SQSScaledJobRunner.parseMessage(undefined)).toThrow('[SQSScaledJobRunner] Mensagem inválida.');
+        (0, vitest_1.expect)(() => runner_1.SQSScaledJobRunner.parseMessage(123)).toThrow('[SQSScaledJobRunner] Mensagem deve ser uma string.');
+    });
+    (0, vitest_1.it)('should race processing with the global timeout when configured', async () => {
+        const runner = new runner_1.SQSScaledJobRunner(new TestHandler(), 'queue-url', {
+            sqsRegion: 'us-east-1',
+            processTimeoutSeconds: 3,
+        }, createLogger());
+        const processSpy = vitest_1.vi
+            .spyOn(runner, 'process')
+            .mockImplementation(() => new Promise(() => undefined));
+        const timeoutSpy = vitest_1.vi
+            .spyOn(runner, 'timeout')
+            .mockResolvedValue(undefined);
+        await runner.run();
+        (0, vitest_1.expect)(processSpy).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(timeoutSpy).toHaveBeenCalledWith(3);
+    });
+    (0, vitest_1.it)('should run processing directly when no global timeout is configured', async () => {
+        const runner = new runner_1.SQSScaledJobRunner(new TestHandler(), 'queue-url', {
+            sqsRegion: 'us-east-1',
+        }, createLogger());
+        const processSpy = vitest_1.vi.spyOn(runner, 'process').mockResolvedValue(undefined);
+        await runner.run();
+        (0, vitest_1.expect)(processSpy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/clean-arch/infra/tracing/start-tracing.d.ts

@@ -0,0 +1,10 @@
+type TracingResourceAttribute = string | number | boolean | undefined;
+interface IStartTracingOptions {
+    serviceName?: string;
+    serviceVersion?: string;
+    disabledInstrumentations?: string[];
+    extraResourceAttributes?: Record<string, TracingResourceAttribute>;
+}
+export declare function shutdownTracing(): Promise<void>;
+export declare function startTracing(options?: IStartTracingOptions): void;
+export {};

package/dist/clean-arch/infra/tracing/start-tracing.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTracing = exports.shutdownTracing = void 0;
+const auto_instrumentations_node_1 = require("@opentelemetry/auto-instrumentations-node");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const DEFAULT_DISABLED_INSTRUMENTATIONS = ['@opentelemetry/instrumentation-fs'];
+let sdk = null;
+let isShutdownHookRegistered = false;
+let shutdownPromise = null;
+function makeDisabledInstrumentationMap(disabledInstrumentations) {
+    return disabledInstrumentations.reduce((accumulator, instrumentationName) => {
+        accumulator[instrumentationName] = { enabled: false };
+        return accumulator;
+    }, {});
+}
+function shutdownTracing() {
+    if (sdk === null) {
+        return Promise.resolve();
+    }
+    if (shutdownPromise !== null) {
+        return shutdownPromise;
+    }
+    const currentShutdownPromise = sdk
+        .shutdown()
+        .then(() => {
+        console.log('Tracing terminated');
+        sdk = null;
+    })
+        .catch((error) => {
+        console.log('Error terminating tracing', error);
+        throw error;
+    })
+        .finally(() => {
+        shutdownPromise = null;
+    });
+    shutdownPromise = currentShutdownPromise;
+    return currentShutdownPromise;
+}
+exports.shutdownTracing = shutdownTracing;
+function registerShutdownHook() {
+    if (isShutdownHookRegistered) {
+        return;
+    }
+    process.on('SIGTERM', () => {
+        void shutdownTracing();
+    });
+    isShutdownHookRegistered = true;
+}
+function startTracing(options = {}) {
+    if (sdk !== null) {
+        return;
+    }
+    const serviceName = options.serviceName;
+    const serviceVersion = options.serviceVersion;
+    const disabledInstrumentations = [
+        ...new Set([
+            ...DEFAULT_DISABLED_INSTRUMENTATIONS,
+            ...(options.disabledInstrumentations ?? []),
+        ]),
+    ];
+    const resourceAttributes = {
+        [semantic_conventions_1.ATTR_SERVICE_NAME]: serviceName,
+        [semantic_conventions_1.ATTR_SERVICE_VERSION]: serviceVersion,
+        ...(options.extraResourceAttributes ?? {}),
+    };
+    sdk = new sdk_node_1.NodeSDK({
+        resource: (0, resources_1.resourceFromAttributes)(resourceAttributes),
+        instrumentations: [
+            (0, auto_instrumentations_node_1.getNodeAutoInstrumentations)(makeDisabledInstrumentationMap(disabledInstrumentations)),
+        ],
+    });
+    sdk.start();
+    console.log('OpenTelemetry tracing started');
+    registerShutdownHook();
+}
+exports.startTracing = startTracing;

package/dist/clean-arch/infra/validations/zod/validation-zod.spec.js

@@ -433,4 +433,27 @@ describe('Validation zod', () => {
             }));
         }
     });
+    test('should return empty sections when the request omits them', async () => {
+        const schema = zod_1.z.object({
+            body: zod_1.z.object({
+                name: zod_1.z.string().optional(),
+            }),
+            headers: zod_1.z.object({
+                tenantid: zod_1.z.string().optional(),
+            }),
+            query: zod_1.z.object({
+                page: zod_1.z.string().optional(),
+            }),
+            params: zod_1.z.object({
+                id: zod_1.z.string().optional(),
+            }),
+        });
+        const validation = new validation_zod_1.default(schema);
+        await expect(validation.validate({})).resolves.toEqual({
+            body: {},
+            headers: {},
+            params: {},
+            query: {},
+        });
+    });
 });

package/dist/clean-arch/shared/pagination/get-take-and-skip.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clean-arch/shared/pagination/get-take-and-skip.spec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const get_take_and_skip_1 = require("./get-take-and-skip");
+(0, vitest_1.describe)('getTakeAndSkip', () => {
+    (0, vitest_1.it)('should parse pagination values and apply defaults', () => {
+        (0, vitest_1.expect)((0, get_take_and_skip_1.getTakeAndSkip)('10', '2')).toEqual({
+            take: 10,
+            skip: 2,
+        });
+        (0, vitest_1.expect)((0, get_take_and_skip_1.getTakeAndSkip)('', '')).toEqual({
+            take: 20,
+            skip: 1,
+        });
+    });
+});

package/dist/coverage/block-navigation.d.ts

@@ -0,0 +1 @@
+declare function jumpToCode(event: any): void;

package/dist/coverage/block-navigation.js

@@ -0,0 +1,72 @@
+'use strict';
+/* eslint-disable */
+var jumpToCode = (function init() {
+  // Classes of code we would like to highlight in the file view
+  var missingCoverageClasses = ['.cbranch-no', '.cstat-no', '.fstat-no'];
+  // Elements to highlight in the file listing view
+  var fileListingElements = ['td.pct.low'];
+  // We don't want to select elements that are direct descendants of another match
+  var notSelector = ':not(' + missingCoverageClasses.join('):not(') + ') > '; // becomes `:not(a):not(b) > `
+  // Selecter that finds elements on the page to which we can jump
+  var selector =
+    fileListingElements.join(', ') +
+    ', ' +
+    notSelector +
+    missingCoverageClasses.join(', ' + notSelector); // becomes `:not(a):not(b) > a, :not(a):not(b) > b`
+  // The NodeList of matching elements
+  var missingCoverageElements = document.querySelectorAll(selector);
+  var currentIndex;
+  function toggleClass(index) {
+    missingCoverageElements.item(currentIndex).classList.remove('highlighted');
+    missingCoverageElements.item(index).classList.add('highlighted');
+  }
+  function makeCurrent(index) {
+    toggleClass(index);
+    currentIndex = index;
+    missingCoverageElements.item(index).scrollIntoView({
+      behavior: 'smooth',
+      block: 'center',
+      inline: 'center',
+    });
+  }
+  function goToPrevious() {
+    var nextIndex = 0;
+    if (typeof currentIndex !== 'number' || currentIndex === 0) {
+      nextIndex = missingCoverageElements.length - 1;
+    } else if (missingCoverageElements.length > 1) {
+      nextIndex = currentIndex - 1;
+    }
+    makeCurrent(nextIndex);
+  }
+  function goToNext() {
+    var nextIndex = 0;
+    if (
+      typeof currentIndex === 'number' &&
+      currentIndex < missingCoverageElements.length - 1
+    ) {
+      nextIndex = currentIndex + 1;
+    }
+    makeCurrent(nextIndex);
+  }
+  return function jump(event) {
+    if (
+      document.getElementById('fileSearch') === document.activeElement &&
+      document.activeElement != null
+    ) {
+      // if we're currently focused on the search input, we don't want to navigate
+      return;
+    }
+    switch (event.which) {
+      case 78: // n
+      case 74: // j
+        goToNext();
+        break;
+      case 66: // b
+      case 75: // k
+      case 80: // p
+        goToPrevious();
+        break;
+    }
+  };
+})();
+window.addEventListener('keydown', jumpToCode);